Issue #11

Swift allows us to define more methods on existing class using extension.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

extension UIView {

  func shake() {

  }

  func fade() {

  }

  func centerIn(anotherView: UIView) {

  }
}

If you ‘re afraid of the naming conflict, you can prefix your methods, like

1
2
3

view.abc_shake()
view.abc_fade()
view.abc_centerIn(anotherView: containerView)

Or a better way, reverse it 💃 , like

1
2
3

view.animation.shake()
view.animation.fade()
view.layout.centerIn(anotherView)

This way, no more conflict and we make it clear that shake() and fade() belongs to animation category
Actually, animation and layout are properties in UIView extension. This may cause naming conflict, but the number of them is reduced

This is how it works

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

extension UIView {

  struct Animation {
    let view: UIView

    func shake() {
      // Shake the view
    }

    func fade() {
      PowerfulAnimationEngine.fade(view)
    }
  }

  var animation: Animation {
    return Animation(view: self)
  }

  struct Layout {
    let view: UIView

    func centerIn(anotherView: UIView) {

    }
  }

  var layout: Layout {
    return Layout(view: self)
  }
}

Issue #10

There is time we want to execute an action only once. We can surely introduce a flag, but it will be nicer if we abstract that out using composition. Then we have

1
2
3
4
5
6
7
8
9
10
11
12
13

class Once {

  var already: Bool = false

  func run(@noescape block: () -> Void) {
    guard !already else { 
      return 
    }

    block()
    already = true
  }
}

Usage

1
2
3
4
5
6
7
8
9
10
11

class ViewController: UIViewController {
  let once = Once()

  override func viewDidAppear(animated: Bool) {
    super.viewDidAppear(animated)

    once.run {
      cameraMan.setup()
    }
  }
}

In the same way, we can check to run a closure when a value changes

1
2
3
4
5
6
7
8
9
10
11
12
13
14

final class WhenChange<T: Equatable> {
    private(set) var value: T

    init(value: T) {
        self.value = value
    }

    func run(newValue: T, closure: (T) -> Void) {
        if newValue != value {
            value = newValue
            closure(value)
        }
    }
}

Issue #9

The other day I was watching Inside Sweden’s Silicon Valley, and he mentions Law of Jante

It is pretty much this

• You’re not to think you are anything special.
• You’re not to think you are as good as we are.
• You’re not to think you are smarter than we are.
• You’re not to convince yourself that you are better than we are.
• You’re not to think you know more than we do.
• You’re not to think you are more important than we are.
• You’re not to think you are good at anything.
• You’re not to laugh at us.
• You’re not to think anyone cares about you.
• You’re not to think you can teach us anything.

This is controversial, there are many discussions about this

• http://www.ibtimes.com/law-jante-how-swedish-cultural-principle-drives-ikea-ericsson-volvo-beat-financial-1397589
• https://www.quora.com/Is-answering-publicly-on-Quora-incompatible-with-the-Law-of-Jante
• https://www.quora.com/Would-global-application-of-Jantes-laws-be-beneficial
• http://www.lifeinnorway.net/2015/06/what-exactly-is-janteloven/

Putting on your black hat, it sounds negative. Putting on your yellow hat, it sounds positive
But what I learn about it is the team work. No one lives alone, everyone lives among the others. It is about to be humble and learn collaboration

Issue #8

Some say these are from the book Dumbing Down America of Charles Sykes, some say they are from Bill Gates ‘s speech to high school students. I don’t know the origin, but they are cool enough, so I tend to share it again and again

• Life is not fair. Get used to it ⭐️
• The world won’t care about your self-esteem. The world will expect you to accomplish something BEFORE you feel good about yourself
• You will NOT make 40 thousand dollars a year right out of high school. You won’t be a vice president with car phone, until you earn both.
• If you think your teacher is tough, wait till you get a boss. He doesn’t have tenure.
• If you mess up, it’s not your parents’ fault, so don’t whine about your mistakes, learn from them.
• Your school may have done away with winners and losers, but life may not. In some schools they have abolished failing grades and they’ll give you as many times as you want to get the right answer. This doesn’t bear the slightest resemblance to ANYTHING in real life.
• Life is not divided into semesters. You don’t get summers off and very few employers are interested in helping you find yourself. Do that on your own time.
• Television is NOT real life. In real life people actually have to leave the coffee shop and go to jobs.
• Be nice to nerds. Chances are you’ll end up working for one.
• Before you were born your parents weren’t as boring as they are now. They got that way paying your bills, cleaning up your room and listening to you tell them how idealistic you are. And by the way, before you save the rain forest from the blood-sucking parasites of your parents’ generation, try delousing the closet in your bedroom ⭐️

Reference

• https://www.se.rit.edu/~jrv/personal/RulesForStudents.html

Issue #7

Original post https://medium.com/@onmyway133/check-before-you-commit-5a7601cffc87

We usually have some experiment code that we don’t want they to step into our commit. I usually mark my experiment with // but sometimes forget to unstage that
Starting with 2.9, Git has improvement on its commit hook which makes it globally using hooksPath

Create pre-commit file

Create a file called pre-commit, and place it into, for example /Users/khoa/hooks

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

#!/bin/sh

# https://appventure.me/2016/04/04/prevent-accidental-test-code-commits/

if git rev-parse --verify HEAD >/dev/null 2>&1
then
  against=HEAD
else
  # Initial commit: diff against an empty tree object
  against=4b825dc642cb6eb9a060e54bf8d69288fbee4904
fi

# The special marker tag to mark things which we still need to change
marker="<TEST>"

# Redirect output to stderr.
exec 1>&2

if test $(git diff --cached -z $against | grep $marker | wc -c) != 0 
then
    cat <<\EOF
    Error: Still has invalid debug markers in code:
EOF
    echo `git diff --cached -z $against -G $marker`
    exit 1
fi

Apply the hook

In your project, run git config core.hooksPath /Users/khoa/hooks
That’s it. Whenever you commit a file with that pattern, it won’t let you commit

How to use

Try

1
2

// <TEST>
UserManager.shared.isActive = true

and git commit -m "my commit message" will assert with Error: Still has invalid debug markers in code:

Reference

• http://pre-commit.com/
• https://appventure.me/2016/04/04/prevent-accidental-test-code-commits/
• http://merowing.info/2016/08/setting-up-pre-commit-hook-for-ios/

Issue #6

I like writing with markdown, it gives me comfortable experience with complete control over what I want to write.

I recommend vmd which renders exactly as GitHub. vmd is for rendering only, you need an editor to write, I use Sublime Text because it opens very fast

I also recommend using spectacle to easily split and organize windows

Issue #5

https://onmyway133.github.io/opensource/

Issue #4

Realm is great. But without primary key, it will duplicate the record, like https://github.com/realm/realm-java/issues/2730, http://stackoverflow.com/questions/32322460/should-i-define-the-primary-key-for-each-entity-in-realm, … So to force ourselves into the good habit of declaring primary key, we can leverage Swift protocol

Create primary constrain protocol like this

1
2
3
4

protocol PrimaryKeyAware {
  var id: Int { get }
  static func primaryKey() -> String?
}

and conform it in out Realm object

1
2
3
4
5
6
7
8
9
10

class Profile: Object, PrimaryKeyAware {

  dynamic var firstName: String = ""
  dynamic var lastName: String = ""
  dynamic var id: Int = 0

  override static func primaryKey() -> String? {
    return "id"
  }
}

This way, when using that object in out RealmStorage, we are safe to say that it has a primary key

1
2
3
4
5
6
7
8
9
10
11
12
13

class RealmStorage<T: Object> where T: PrimaryKeyAware {
  let realm: Realm

  init(realm: Realm = RealmProvider.realm()) {
    self.realm = realm
  }

  func save(_ objects: [T]) {
    try? realm.write {
      realm.add(objects, update: true)
    }
  }
}

The usage is like this

1
2
3

let profile = Profile()
let storage = RealmStorage<Profile>()
storage.save([profile])

Issue #3

The other day I was browsing through https://github.com/sindresorhus/touch-bar-simulator, it was very brilliant of him to pull IDETouchBarSimulatorHostWindowController from DFRSupportKit.framework. This is worth checking out

Issue #2

When I was reading through Swinject, I found something interesting https://github.com/Swinject/Swinject/blob/master/Sources/Container.swift

1
2
3
4

public convenience init(parent: Container? = nil, registeringClosure: (Container) -> Void) {
  self.init(parent: parent)
  registeringClosure(self)
}

The init has a closure that makes configuration easy, much like a Builder pattern. So I think we can learn from that and make a Configurable protocol

1
2
3
4
5
6
7
8
9
10

protocol Configurable: class {}

extension Configurable {
  func config(block: (Self) -> Void) -> Self {
    block(self)
    return self
  }
}

extension NSObject : Configurable {}

With this, we can init some class with less hassle

1
2
3
4

let view = UIView().config {
  $0.backgroundColor = .white
  $0.layer.cornerRadius = 2
}

Issue #1

I’ve used Wordpress, then moved to GitHub Pages with Jekyll, Octopress, Hexo, Hugo. You can view my page here http://fantageek.com/. It was good with all the custom themes and Disqus

But then I was a bit lazy with all the commands generate, commit, deploy, it hinders me from writing, so I moved to Medium.

The only thing I like about Medium is its discovery, your posts have high chanced of finding and viewing by people. What’s the point of writing if no one read it? But then I miss all the awesome markdown features of GitHub Pages. Medium is easy to use, but it seems it’s not for hackers, and I find it really uncomfortable when adding code block and headings. Medium also lists my comments as stories, which is kind of 😲

I like to write fast, and with good comments system, and I love Markdown.

I like GitHub. I use GitHub for my notes, so I think I will use it for my blog as well. Hope all these GitHub convenience will encourage me to write more often. This will, of course, be less discoverable by people. So if you by any chance visit this blog, ohayou from me 👋

Updated at 2020-12-17 17:12:38