In year 0, a promise was made. For the two people to be together. As God has said: And We created pairs of all things so perhaps you would be mindful.

Still year 0, but a bit later. Once, I said to her “I like to go to places. To see mountains and beaches. To ride a motorbike or to drive a car. To sit in an airplane or to be a boat passenger. Previously, I go everywhere alone. From now on, do you want to go to places with me? I really want to see the world”

She answered with a smile. An implicit reply of a yes.

Year 1 . She went to study in a faraway country. She likes to send presents even when she is away. Not like the ignorant me. In year 1, the flower and the cake accompany me, celebrating our first anniversary. She was in Germany. I was in Singapore here.

Year 1 continues. From time to time, we would meet. We still liked to go to places. Maybe just crossing to another island from Singapore. To find good foods to eat or just to see the city. After short meet we will be away again until another couple of months gap.

The year 2 anniversary was coming. We were still not in the same place. She wrote me another beautiful note and a present.

Yes, she is also the greatest thing that happened in my life.

Year 2 continues. It was hard to be away. We then made a plan. As she finished her degree, I told her. "Let's see the world now. Let's go to the country we haven't gone to before. Let's see the city we haven't seen before."

Off we go.  We went to Frankfurt, Brussels, Amsterdam, Oslo, Bergen, Stockholm, Helsinki, Tallin, Riga, Prague, Budapest, Rome, Venice, Barcelona, and Paris.

It was year 3. We were together again. No more long-distance calls. No more annoyance due to different time zones. We were building our life in Lion city.

Year 4. "Let's see down under". I asked her. "Let's drive from Sydney to Melbourne, then go to Great Ocean Road, and then back to Sydney again via Canberra. Let's drive the biggest car we can get. Let's sleep and camp in the car. Let's stop in many good places."

"Sure, let's go." She said. An explicit reply of a yes.

Year 5. She likes to eat sushi. Sometimes we will cross to the north of the country and stay for one night in a good hotel. We shop, we eat and we go back down to Singapore.

Year 5 continues. She asked, "We have been only two for these years. Let's go on a pilgrimage journey."

I said, "Yes we definitely should go and pray for even more asks. Let's ask The All-Mighty for all of our wishes. Pray for forgiveness for all of our mistakes. Pray for beautiful and righteous children. Pray for good wealth that brings peace. Pray for sharp minds and warm hearts for us. Pray for a long healthy life. Pray to be a good person with a good life."

Year 5 was a long year. Not long after the pilgrimage journey, she was expecting. Unfortunately, the baby was never born. We were still just two. It was a sad year.

I asked her, "Let's go on a camping trip to a side of a lake. It's gonna be expensive but perhaps it can cover sad memories with some sweet memories."

Year 5 was a long year, but eventually, it seemed to turn into something good. Another baby was coming. "Will we become three after this?" I was wondering.

Year 6 plus. Yes, we became three. It was a girl. We named her A.

Year 7. We still continue to go to places. We like to eat different foods and go to different cities.

Year 8. "Let's go to the down under again with the little girl." I asked. No need for any reply. Both the girls agreed.

Year 9. It was a strange year. It was a year when many people are locked in their houses. Many unfortunate souls were taken on during these times. Families separated away in different countries and cities.

We and our family were more than grateful to be spared. We hope so much the pandemi will finally be really ended. No more face need to be masked or excessive hand sanitizer to be applied.

It is still year 9 of us being together. We waited 6 years to get the little girl. We were not putting too much hope in another little soul. But he was coming at the beginning of October. We now became four. We named the boy R.

It is a decade together. 10 years. Like a blink of an eye.

Year 10 is also the year we finally got our own shelter. Somewhere we really can call home. The place to raise our two little souls. The place where warm memories collected and infinite dreams materialized. A part of the wealth that we hope can bring peace to our hearts and minds.

Finally, year 11 is here. It was just like yesterday when the two rings were ordered from the shop and a vow was declared.

From one becomes two. From two becomes three. From three then now we are four.

The last 11 years was beautiful. I wish the next many years to come will be even more beautiful.

Happy 11 years anniversary to the person I feel is closest to me, more than anyone.

Brussels, 18 November 2022.

I just noticed today that in LLVM 13, dot callgraph is generating the output in the location of the IR ll files instead of the in the current directory. However, all other dot-* passes are still generating the dot files in the current directory. Hence this is an inconsistent behaviour which should be fixed, in my opinion. The changes must be happening between version 10 and 13. I will try to look where and how the changes happen.

This is the output from LLVM 13.

This is the output from LLVM 10.

opt file.ll -passes=view-cfg

Instead of opening xdot that will view the CFG, opt opened Google Chrome and downloaded the file. Previously I just work around this by using the dot-cfg pass and then run xdot manually.

opt file.ll -passes=dot-cfg

However, I am getting curious this morning because I want to reduce the additional step of generating dot files and running xdot. Apparently, the issue must be around mime typing. This is also might be caused by I am running the view-cfg pass inside WSL which doesn't have a desktop environment, instead of full Linux distribution, hence the mime typing is not handled automatically. I have configured the X server so the issue is not because xdot won't open. In fact, chrome can open easily and I also have been using different Jebtrains IDE from my WSL. There is plenty of guide in the internet for anyone who want to run desktop from WSL.

The terminal programs, such as opt, will open desktop applications using xdg-open. xdg-open decides which program to open using the mime type. First, I want to see what is the mime type of the dot file is identified by xdg-open.

$ xdg-mime query filetype .main.dot
application/text

It is clear now the reason why xdg-open decided to open Chrome. It might be a fallback for any application/text file.

Next, I will need to register xdot as a desktop application that will handle *.dot file. We can do it by adding desktop in a new file under ~/.local/share/applications/xdot.desktop. I am getting this guide from this blog.

[Desktop Entry]                                                               
Name=Xdot                                                                     
Exec=/usr/bin/xdot                                                            
MimeType=text/vnd.graphviz                                                     
Type=Application

However, we still need one more additional step. Which is to register that *.dot file will be having text/vnd.graphviz mime. Following the guide here, we need to install libfile-mimeinfo-perl. Then add the following file in /usr/share/mime/packages/xdot.xml.

<?xml version="1.0" encoding="UTF-8"?>
<mime-info xmlns="http://www.freedesktop.org/standards/shared-mime-info">
  <mime-type type="text/vnd.graphviz">
    <glob weight="100" pattern="*.dot"/>
  </mime-type>
</mime-info>

Then, we run update-mime-database /usr/share/mime and check again the mime type.

$ xdg-mime query filetype .main.dot
text/vnd.graphviz

It is working now. Last, we will run view-cfg pass again.

opt file.ll -passes=view-cfg

There is "800 permission denied error" that appeared in the terminal. But I decided to ignore it because at least the xdot can open the dot file now.

This post is a reference that I will use the typical workflow when you want to code in python.

Version

Which python version to use? My quick answer is focus on Python 3 and forget Python 2.

Editor/IDE

I am using vim so far. But I have never optimised the editor usage by installing plugins that can improve productivity. As a comparison, I am very comfortable writing Golang using vim-go and writing Java or Kotlin using Intellij Idea. However, I am still not finding ideal setup for Python.

Package Manager

By default python will install library to its system folder. Therefore it will be difficult if we need to use different libraries with conflicting dependencies. The easy solution is pipenv.

In MacOS, we can install it easy using brew.

brew install pipenv

Once pipenv installed, we just need to navigate to working directory that we want to use. For example, we want to install pandas.

pipenv install pandas

pipenv will install pandas library locally. Next we just need to invoke shell command so that python script or python shell will run in the pipenv context.

pipenv shell

The only setup that we have to do is to load MathJax script in all pages of our blog. In Ghost that setup can be done from Code Injection menu as can be seen below.

The code to be injected will be as follow. Or else just go to MathJax documentation to refer to the latest way of injecting the script.

<script src="https://polyfill.io/v3/polyfill.min.js?features=es6"></script>
<script id="MathJax-script" async src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js"></script>

Let's enter this sample code that will render quadratic equation formula.

<p>
  When \(a \ne 0\), there are two solutions to \(ax^2 + bx + c = 0\) and they are
  \[x = {-b \pm \sqrt{b^2-4ac} \over 2a}.\]
</p>

Following is how the above latex script will be rendered.

When \(a \ne 0\), there are two solutions to \(ax^2 + bx + c = 0\) and they are \[x = {-b \pm \sqrt{b^2-4ac} \over 2a}.\]

What is The Problem?

Why we need to bother setting up multiple VMs? In today software development world, most system is deployed as part of distributed systems. The simplest form is two tier monolith service and data store. However, nowadays people have been breaking down the monolith into multiple microservices. Put also into the equation that some integration point is being setup asynchronously using various kind of messaging or log system. Also since data is so ubiquitous, we have big data processing infrastructures either using batch or streaming. I always excited of how the things work in that distributed systems setup. We can learn and investigate the characteristic of those distributed systems in our local computer. It is cheaper than if spawn the same instance in the cloud provider.

We will do step by step process of having the multi machine setup. The complete Vagrantfile configuration can be downloaded in my github.

Step 0: Setup

We only need two applications in setting up multiple VMs in local guest operating system:

• VM provider such as VirtualBox
• Vagrant to automate the provisioning of the VMs

Step 1: Create Vagrantfile

We can use vagrant init command that will generate default file with many configuration example. Or we can just create a new empty Vagrantfile. Let's add this first content:

Vagrant.configure("2") do |config|
  # setup and provisioning will be added here
end

Vagrantfile is written in Ruby. Underestanding Ruby will help but not mandatory, unless we want to make complex customisation or provisioning. Vagrantfile will start with the configure method. "2" in the configure argument is the vagrant configuration version. I don't see any reason why we want to use version other than 2. The configuration will pass the config object in the lambda argument.

Step 2: Configure provider setting

config.vm.provider "virtualbox" do |v|
  v.memory = 256
end

We might want to limit the VMs hardware resource just to make sure it doesn't overwhelme the host operating system. In the configuration above, we limit the VM RAM to 256MB.

Step 3: Create a single machine

config.vm define "box_1 do |box|
  box.vm.box = "ubuntu/bionic64"
  box.vm.network "private_network", ip: "192.168.51.1"
  box.vm.provision "shell", inline: "echo 'hello world'"
end

We are creating one VM box with that given IP and box type passed to box.vm.box variable. We are setting the network to private and pass the static ip address in the ip argument. In the provision part we are passing a simple shell inline script that just echoing "hello world".

Step 4: Create multiple machines

box_name = "ubuntu/bionic64"

base_ip = 100
base_ip_addresses = "192.168.51"

ip_addresses = (1..number_of_machines).map{ |i| "#{base_ip_addresses}.#{base_ip + i}" }

script = <<-SCRIPT
  echo "hello world"
SCRIPT

config.vm.provider "virtualbox" do |v|
  v.memory = 256
end

(1..number_of_machines).each do |i|
  config.vm.define "box_#{i}" do |box|
    box.vm.box = box_name
    box.vm.network "private_network", ip: "#{ip_addresses[i-1]}"

    box.vm.provision "shell", inline: "#{script}"
  end
end

The configuration of multiple machine is just the extension from the single machine setup. Fundamentally we are just looping the configuration to the number of machine that we want to create.

In the Vagrantfile fragment above, the only dynamic configuration for each machine is we want to make sure no machine has the same IP address conflict. The easy way we can just use dhcp. But we want to know the IP for each machine in a static way, hence we generate the IP address by enumerating it based on how many devices we want to create. In this example we will start with starting address of 192.168.58.100. Since we want to make two boxes, therefore we assign 192.168.58.101 to the first box and 192.168.58.102 to the second box.

Step 5: Customize the provisioning

When provisioning the box for the first time, there might be a need to configure some initial setup. Such as installing apps or copying files. Vagrant provide different provisioners such as shell as the simplest to using Ansible. In this example we are just echoing "hello world" when the box is provisioned.

Once more, the complete of Vagrantscript from this post is available here.

Then the last step concludes this post. I am pretty sure will use this post when exploring clustering configuration for some distributed system out there.

There was a time when I was slightly feel annoyed with Golang introducing different approaches of dependency management in very short period of time. I was starting a project using glide. Then I migrated it to dep, because I was told, it is the official approach. Only then I learned, go moved to go module. It only makes sense after I watched very clear explanation of Russ Cox in Gophercon 2018. The reason of introducing go module is to have build tool with this principles:

1. Compatibility
2. Repeatability
3. Cooperation

Russ Cox  has also written multiple blog posts in elaborating the arguments which culminate in the official blog post in the Golang blog.

This blog post doesn’t try to repeat what that has clearly explained in documentation, the original blog post and Russ Cox's blog and video. I just want to synthesize my understanding and try to give personal example so that I can internalize the reason and understand how go module works. Go module has preliminary support

Dependency

In the beginning your code will be simple without any 3rd party dependencies.

// main.go
package main

import (
  "fmt"
)

func main() {
  fmt.Println(greet())
}

func greet() string {
  return "Hello World"
}

‌Now let's extract this simple functionality into its own package within the same source three. The structure will be look like following.

user@machine: ~/go/src/github.com/lamida/gomoddemo $ tree
.
├── cmd
│   └── main.go
└── greeter
    └── greeter.go

// greeter.go
package greeter
func Greet() string {
  return "Hello There!"
}

// main.go
package main
import (
  "fmt"

  "github.com/lamida/gomoddemo/greeter"
)
func main() {
  fmt.Println(greeter.Greet())
}

Publish The Package

As example, we want to extract the Greet() functionality into its own golang package. Of course in real world, there is a very rare occasion to have too simple library like this. We want to use this just for example.

user@machine: ~/go/src/github.com/lamida/gomoddemolib $ tree
.
└── greeter
    └── greeter.go

What we will do is just pushing the greeter package into its own git repo.

After that, we also can delete that gomoddemolib above project from our local disk. Please note that when publishing the package to git repo, there is no need to make the package as go modules package. For our example, one greeter.go file under greeter folder is enough.

At the same time, we will remove package greeter from gomoddemo project. Hence the project structure now just become like this.

user@machine: ~/go/src/github.com/lamida/gomoddemo$ tree
.
└── cmd
    └── main.go

In the main.go we have to make sure to import the greeter from the new path.

// main.go
package main

import (
  "fmt"
  // this import is from the new repo
  "github.com/lamida/gomoddemolib/greeter"
)

func main() {
  fmt.Println(greeter.Greet())
}

If we try to build this, we will get error like this.

user@machine: ~/go/src/github.com/lamida/gomoddemo $ go build
main.go:6:2: cannot find package "github.com/lamida/gomoddemolib/greeter" in any of:
        /snap/go/3739/src/github.com/lamida/gomoddemolib/greeter (from $GOROOT)
        /home/lamida/go/src/github.com/lamida/gomoddemolib/greeter (from $GOPATH)

That happens because gomoddemo project can't find dependency to gomoddemolib since we have deleted that from our local disk.

We need to enable go modules for gomoddemo so that go can manage the dependency for us.

user@machine: ~/go/src/github.com/lamida/gomoddemo $ go mod init github.com/lamida/gomoddemo
go: creating new go.mod: module github.com/lamida/gomoddemo

Let's see what is inside go.mod file.

// go.mod
module github.com/lamida/gomoddemo

go 1.12

It is just module declaration and go version. Next we can run go build for the main package under cmd folder.

user@machine: ~/go/src/github.com/lamida/gomoddemo $ cd cmd
user@machine: ~/go/src/github.com/lamida/gomoddemo $ go build
go: finding github.com/lamida/gomoddemolib/greeter latest
go: finding github.com/lamida/gomoddemolib latest
user@machine: ~/go/src/github.com/lamida/gomoddemo $ ./cmd
Hello from module

go build command automatically scan import in our codes and download the dependency directly. When we execute the binary named cmd under the cmd folder, it shows the output as what we import from the external package.

go.sum

After running go build, we also discover that there is a new file added in the root folder of the project.

//go.sum
github.com/lamida/gomoddemolib v0.0.0-20190518042331-b7c7cf7d5429/go.mod h1:ql3STdRmz950+yGEEso1wDner5pLOa1keXBZ77ZkT0w=

As we can read from golang wiki go.sum serves this function:

For validation purposes, go.sum contains the expected cryptographic checksums of the content of specific module versions.

To test the checksum, let's modify the sum by appending it with some random text. We can do so by using go mod verify command.

user@machine: ~/go/src/github.com/lamida/gomoddemo $ go mod verify
verifying github.com/lamida/gomoddemolib@v0.0.0-20190518042331-b7c7cf7d5429/go.mod: checksum mismatch
        downloaded: h1:ql3STdRmz950+yGEEso1wDner5pLOa1keXBZ77ZkT0w=
        go.sum:     h1:ql3STdRmz950+yGEEso1wDner5pLOa1keXBZ77ZkT0wX=

Updating The Package

The library we are importing are coming without any version metadata. Hence go module just pulls the latest commit from the master branch. Let's test to update the gomoddemolib another commit to the master branch. I am updating the greet message from "Hello from module" to "Hello from module updated". If we run go build after that, nothing is changed.

Updating Patch Version

The most easiest way to update this is to update release tag to gomodlib.

user@machine: ~/go/src/github.com/lamida/gomoddemolib $ git tag v0.0.1
user@machine: ~/go/src/github.com/lamida/gomoddemolib $ git push origin v0.0.1
Total 0 (delta 0), reused 0 (delta 0)
To github.com:lamida/gomoddemolib
 * [new tag]         v0.0.1 -> v0.0.1

Next we update the version in go.mod in gomoddemo project to point to this new version. But instead of pointing to the specific patch version, we will just set it to major version v0.

// go.mod
module github.com/lamida/gomoddemo

go 1.12

require github.com/lamida/gomoddemolib v0

Running go build will fetch the latest version.

user@machine: ~/go/src/github.com/lamida/gomoddemo/cmd $ go build
go: finding github.com/lamida/gomoddemolib v0.0.1
go: downloading github.com/lamida/gomoddemolib v0.0.1
go: extracting github.com/lamida/gomoddemolib v0.0.1
user@machine: ~/go/src/github.com/lamida/gomoddemo/cmd $ ./cmd
Hello from module updated

We can push another patch version from gomodlib.

user@machine: ~/go/src/github.com/lamida/gomoddemolib $ git tag v0.0.2
user@machine: ~/go/src/github.com/lamida/gomoddemolib $ git push origin v0.0.2
Total 0 (delta 0), reused 0 (delta 0)
To github.com:lamida/gomoddemolib
 * [new tag]         v0.0.2 -> v0.0.2

Running go build will automatically fetch another patch version.

Updating Minor Version

This also applicable if the library updates the minor version.

user@machine: ~/go/src/github.com/lamida/gomoddemolib $ git tag v0.1.0
user@machine: ~/go/src/github.com/lamida/gomoddemolib $ git push origin v0.1.0
Total 0 (delta 0), reused 0 (delta 0)
To github.com:lamida/gomoddemolib
 * [new tag]         v0.1.0 -> v0.1.0

On running go build in the client code, the latest version of the dependency will be fetched.

user@machine: ~/go/src/github.com/lamida/gomoddemo/cmd $ go build
go: finding github.com/lamida/gomoddemolib v0.1.0
go: downloading github.com/lamida/gomoddemolib v0.1.0
go: extracting github.com/lamida/gomoddemolib v0.1.0

Updating Major Version

There are a different semantic for major version though. Let say after the library got stable, it releases v1 and then after that v2.

Updating to v1 is as simple as updating the go.mod to point to v1.

// go.mod
module github.com/lamida/gomoddemo

go 1.12

require github.com/lamida/gomoddemolib v1

However if you update to v2, go build will still fetch the latest update but the client code wouldn't directly run the v2 library.

user@machine: ~/go/src/github.com/lamida/gomoddemo/cmd $ go build
go: finding github.com/lamida/gomoddemolib v2.0.0+incompatible
go: downloading github.com/lamida/gomoddemolib v2.0.0+incompatible
go: extracting github.com/lamida/gomoddemolib v2.0.0+incompatible
$ ./cmd
Hello from module v1.0.0

We would have to enable the v2 by explicitly importing it in the client code.

// main.go
package main

import (
	"fmt"

	v2 "github.com/lamida/gomoddemolib/v2/greeter"
)

func main() {
	fmt.Println(v2.Greet())
}

user@machine: ~/go/src/github.com/lamida/gomoddemo/cmd $ go build
go: finding github.com/lamida/gomoddemolib v2.0.0+incompatible
go: downloading github.com/lamida/gomoddemolib v2.0.0+incompatible
go: extracting github.com/lamida/gomoddemolib v2.0.0+incompatible
$ ./cmd
Hello from module v2.0.0

If you saw error of module can't be found, make sure to update the version in the go.mod file to v2 and re-run go build or run command.

// go.mod
module github.com/lamida/gomoddemo

go 1.12

require github.com/lamida/gomoddemolib v2

The example concludes how we use go modules.

The code example used in this blog post is available in this git repo.

Resolution Notes from Previous Years

1. 2017 resolution note
2. 2016 resolution note
3. 2015 personal note
4. 2014 personal note
5. 2013 personal note
6. 2012 personal note
7. 2011 personal note
8. 2010 personal note

Last Year Review

Like usual let's start with what I wanted  to do by last year. [Y] means achieved, [N] means not achieved.

• [N] Completing at least 6 2 MOOC courses: I don't do any course at all. I signed many of them but almost don't finish any week for any course at all
• [N] Take a GRE PTE test: I don't do any test
• [N] Launch Work consistently on Travelogee project: There is no new post in Travelogee for the past one year.
• [Y] Raise a happy, healthy and smart kid. At least focus play with the kid minimum 30 minutes a day on weekday and 1 hour on weekend: Alula is 15 months old now. She is growing up very well. Although I am not tracking in detail, but I can say that I am quite on track in this goal. I play with her definetely more than 30 minutes a day and in some weekend I spent time almost whole day with her. Hurray!
• [N] Reach Tech Lead position in the new work place: there are some career ups and downs with some sweet and bitter lessons. But at the end I am back with normal coding.
• [N] Weight no more than 65 60 Kg: I don't dare to weight myself but It was more than 70 Kg last time.
• [Y] Read minimum a book per 2 months and make a review on it: I have been trying to fix my reading habit by really consciously absorbing the information when reading by taking notes and review the book. I have read at least 8 books for the past 5 months. It is clearly above the goal I set.
• [N] Write a book about Golang: Nothing happen on this yet.
• [N] Speak in a country level technical conference: Even I don't speak anywhere at all.
• [N] Long duration travel to uncommon destination country such as Central Asia: no major travel for the past 2 years.
• [Y] Get Singapore Class 2 Motorbike license: Yes I am Class 2 license holder now!
• [N] Touring using big motorbike for at least to distance like from Sydney to Melbourne: Maybe next time.
• [N} Speak English fluently to the level of IELTS 8 band score: I haven't taken any IELTS test yet and my English seems stagnant because I don't speak so much.
• [N] Resume to study German to basic communication level or more: I even didn't start anything.
• [N] Finish marathon sub 4 hours: I am couch potato which hasn't been running at all for the past 15 months
• [N] Exercise every day: no
• [N] Do SAVERS every day: no!

Ok let's set objective for this year. I wouldn't re-explain what OKR is. For anyone who are not familiar to it, can read Measure What Matters by John Doerr. Usually OKR is set quarterly or at most half yearly. But I will set objective for 1 year (technically 7 months from now, because now is already May).

I have divided my life into 6 aspects to help me in setting objectives and todos. This is an somehow abrupt experimental classification which might change in future. What I am going to do is to set at least one objective in each that life aspect with at least one key result in each objective.

• Soul: To make it easy, for me soul is about being religious, mindfulness, something that make you calm, something non material.
• Relationship: Family, friends and other social circles.
• Mind: About learning and how to optimise your brain.
• Wealth: Financial, materialistic possession.
• Fitness: Health, exercise and diet.
• Impact: How I can contribute, writing books, speaking in conference, be an influencer.

(Soul) Be more religious, mindful and calm individual

• Memorise at least 5 additional surah in Juz 30 of Quran by the end of year
• Read 1 new hadith per week
• At least have one mindful praying without too much mind wandering per day. To follow on this key result, I am devising a praying score metric. For each prayer, I will score my prayer from 0-5. 0 means total mind wandering where even I can forgot in which rakaat I am at. 5 means total mindfulness where I am in the flow without any mind wandering at all.
• Write daily journal, at least one paragraph per day
• Write a grateful note every night before sleep

(Relationship) Be closer to family, care more and spend time more with them and increase social circle

• Call mom at least once a month
• Spend specifically dedicated non-distracted time for wife at least 15 minutes a day
• Play with Lulu at least 30 minutes a day in weekday and 2 hours in weekend

(Mind) Learning a specific thing deeply and focus

• Finish one Coursera cloud computing course
• Do 1 German Duolingo session per day
• Read 2 books per month

(Wealth) Increase financial literacy and portfolio

• Get average return of investment for 6% by the end of the year
• Read 5 financial/FIRE movement's books

(Fitness) Be more healthy and fit

• Do push up 5 times per day
• Run at least 15 minutes per week
• Drink not more than 300ml sweet drink per day

(Impact) Screw impostor syndrome, let me share to the world

• Speak in at least local meetup by the end of the year
• Write a book draft about Kotlin by the end of the year by writing at least one page per week
• Contribute 1 pull request to any open source project

Then that's all. I will try to review this at least monthly and add comments or notes as required.

Emacs is a very extensible text editor that was started as far as 1970s. I have never really explored this editor much but somehow recently become interested to get to know this tool a bit more. This post will share a very quick journey of how setting up emacs and getting started to do some basic tasks approximately in 30 minutes.

In this post, we are going to cover these points:

• Checking emacs version
• Installation
• Starting emacs
• Exiting emacs
• Emacs Tutorial
• Emacs Packages
• Evaluating LISP

Checking Version

Emacs is included in macOS by default, but not from the latest version. In my laptop this is the version.

$ emacs --version
GNU Emacs 22.1.1
Copyright (C) 2007 Free Software Foundation, Inc.
GNU Emacs comes with ABSOLUTELY NO WARRANTY.
You may redistribute copies of Emacs
under the terms of the GNU General Public License.
For more information about these matters, see the file named COPYING.

At the time of this writing from this link the current version of emacs is 26.1. We will get that latest version, instead of the old default version.

Installing Emacs

There are several options to install the latest version of emacs. My preference usually is to use brew, so that it is easier to manage the instalation, uninstalation and update.

Run this brew command to install the gui version of emacs.

$ brew cask install emacs

After the installation we can check quickly the updated version. Make sure to switch the terminal to ensure the PATH will pick the latest installed emacs instead of the old one.

$ emacs --version
GNU Emacs 26.1
Copyright (C) 2018 Free Software Foundation, Inc.
GNU Emacs comes with ABSOLUTELY NO WARRANTY.
You may redistribute copies of GNU Emacs
under the terms of the GNU General Public License.
For more information about these matters, see the file named COPYING.

We have seen the installation run successfully.

Starting Emacs

Since we install emacs using brew cask, brew will add emacs to application folder, therefore the apps can be started from macOS launchpad. However, if you plan to use come emacs internal command, we might want to start it from command line because somehow starting emacs from the launchpad doesn't carry the PATH and environment variable setup in your bash_profile or your terminal profile. I am figuring out how to fix this issue. But for now, I just start emacs from terminal.

Exiting Emacs

Many people getting stuck from exiting vim. I believe there will be less number of people that can't exit emacs since at least there are no different editing and view mode in emacs such as in vim. In emacs GUI, just click the close window button. Or the more canonical way using keyboard binding is to use C-x C-c. See next section to understand what that key binding means.

Emacs Tutorial

No I will not redo excellent tutorial that available inside the application. For you that really never used emacs before, spend your next 30 minutes to do the emacs tutorial that accessible from emacs welcome screen above. Alternatively you can press this key combination to access that C-h t.

Emacs Packages

The power of emacs is of how extendable it is. To see available and installed package, enter these keys M-x list-packages. By default list-packages will show only package maintained by emacs developer.

Sometime a package is hosted elsewhere. Melpa is one well known emacs package archieve. For an example, let us try to install go-mode package which is available in melpa.

To enable melpa in emacs is described in its getting started guide. Let us add the init setup using emacs itself. Enter C-x C-f to visit file and enter ~/.emacs.d/init.el in the input prompt which means we want to edit or create that init file. That file will be read by emacs everytime it starts up. Paste the content of package initializer file as follow in the file.

(require 'package)
(let* ((no-ssl (and (memq system-type '(windows-nt ms-dos))
                    (not (gnutls-available-p))))
       (proto (if no-ssl "http" "https")))
  ;; Comment/uncomment these two lines to enable/disable MELPA and MELPA Stable as desired
  (add-to-list 'package-archives (cons "melpa" (concat proto "://melpa.org/packages/")) t)
  ;;(add-to-list 'package-archives (cons "melpa-stable" (concat proto "://stable.melpa.org/packages/")) t)
  (when (< emacs-major-version 24)
    ;; For important compatibility libraries like cl-lib
    (add-to-list 'package-archives '("gnu" . (concat proto "://elpa.gnu.org/packages/")))))
(package-initialize)

Then press C-x C-s to save and C-x C-c to quit. Start emacs again to reinit emacs with package initialiser above. Then enter M-x list-packages again. We should see some packages from melpa have already been added.

Installing go-mode

To install go-mode, we can either search the package from the list or use this command: M-x package-install, then type go-mode. To see the installation status, switch to *Messages* buffer by pressing C-x C-b and select the *Messages* buffer.

To test the mode, we will create a new file called main.go in folder under $GOPATH. I am assuming reader understand go setup and what $GOPATH means.

Since we have installed go-mode emacs will automatically switch to that mode when editing go source file that ends with .go extension.

With go-mode some extended commands are also added to our emacs installation.

To run the go source file, we also can leverage shell access directly from emacs. To open shell from emacs, type M-x and type shell. From the shell we can run go run main.go the execute the above go hello world example.

I will not go to more details of how setup go development in emacs because there are already some good blog post about that.

Evaluating LISP

Emacs provides a buffer called *scratch* that can be used as scratchpad and also to evalute LISP expression. I will not discuss any LISP detail topic here. But if there is a need to quickly evaluate lisp expression, you can go to your emacs installation.

To open *scratch* buffer, type C-x C-b and select the *scratch* buffer name. A very simple lisp expression is (+ 2 4) which basically adding 2 and 4. Just write that expression in the buffer and press C-j to make the evaluation result printed in the next line. For an alternative way, select the lisp expression that you want to evaluate and press C-x C-e. For this approach the evaluation result will be printed in the echo area.

I have used golang for sometime but only recently I finally understand how to do object mocking in a golang test. Since I came from Java, the way of how mocking an object in golang was not really clear for me. This post is my self documentation of how I reached to my current understanding. In this post, I am using mocking feature from testify. I would assume that reader will be familiar with basic golang to understand this post.

As example, I will create a very simple service like this:

GreeterService is a service that allows you to give a greeting. There are two greeting methods:

• Greet() will greet you depends on what language you set when creating the service
• GreetDefaultMessage() will greet you using default message and doesn't care of the language

Internally, Greet() will call db.FetchMessage(lang) and GreetDefaultMessage() will call db.FetchDefaultMessage(). In real world we will imagine, DB class is class that calls a real database. Therefore, we need a mock in our test to avoid our test calling the actual database. There is no class in golang but we can consider struct behaviour to be equivalent with class.

Implementation

Let see the implementation that we will write in a package called service. First we define the package.

package service

Then we will create a db struct and its interface that we name as DB.

type db struct{}

// DB is fake database interface.
type DB interface {
	FetchMessage(lang string) (string, error)
	FetchDefaultMessage() (string, error)
}

After that we will create GreeterService interface and greeter struct that implements the interface which has dependency to the DB interface. greeter struct also receives lang parameter in its 2nd argument's constructor.

type greeter struct {
	database DB
	lang     string
}

// GreeterService is service to greet your friends.
type GreeterService interface {
	Greet() string
	GreetInDefaultMsg() string
}

To make db struct implicity implement DB interface, we will add the required methods and set *db as the receiver.

func (d *db) FetchMessage(lang string) (string, error) {
    // in real life, this code will call an external db
    // but for this sample we will just return the hardcoded example value
	if lang == "en" {
		return "hello", nil
	}
	if lang == "es" {
		return "holla", nil
	}
	return "bzzzz", nil
}

func (d *db) FetchDefaultMessage() (string, error) {
	return "default message", nil
}

Next we will need to implement the actual greeter methods, Greet() and GreetInDefaultMsg().

func (g greeter) Greet() string {
	msg, _ := g.database.FetchMessage(g.lang) // call database to get the message based on the lang
	return "Message is: " + msg
}

func (g greeter) GreetInDefaultMsg() string {
	msg, _ := g.database.FetchDefaultMessage() // call database to get the default message
	return "Message is: " + msg
}

Above, the greeter methods is calling DB to get the actual message.

It will be helpful to create a factory function for the Greeter and DB.

func NewDB() DB {
	return new(db)
}

func NewGreeter(db DB, lang string) GreeterService {
	return greeter{db, lang}
}

Last part of the implementation, we will write a main function to run the service.

package main

import (
	"fmt"
	"testify-mock/service"
)

func main() {
	d := service.NewDB()

	g := service.NewGreeter(d, "en")
	fmt.Println(g.Greet()) // Message is: hello
	fmt.Println(g.GreetInDefaultMsg()) // Message is: default message

	g = service.NewGreeter(d, "es")
	fmt.Println(g.Greet()) // Message is: holla

	g = service.NewGreeter(d, "random")
	fmt.Println(g.Greet()) // Message is: bzzzz
}

The output after running that will be as follow.

$ go run main.go
Message is: hello
Message is: default message
Message is: holla
Message is: bzzzz

Test and Mock

After having the implementation above, we will write write a test and mock DB dependency. As stated in the beginning, we want to prevent calling actual database when running the test.

To achieve that goal, we will mock the DB interface. Unfortunately the way how mock is created in golang is not as straight forward as in java. In java using mockito, mocking can be as simple as this:

GreetingService mock = Mockito.mock(GreetingService.class);

But in golang we need to create a new struct and embed a testify mock object in it like this:

type dbMock struct {
	mock.Mock
}

Then to make that mock object to comply with DB interface, we need to implement all the methods of the interface. Also there is a specific call need to be done inside the implemented method. The first one is we need to call method Mock.Called(args) and passing the arguments if the method we want to mock has some arguments.

In the example below, the call is d.Called(lang). Then return value of that call will be used as return value the method that we want to mock. Both method are returning (string, error). Therefore the return statement of the method are return args.String(0), args.Error(1). The pattern of how we should write the return statement in the mocked methods is, args.<ReturnValueType>(<index>). Index is started from zero.

func (d *dbMock) FetchMessage(lang string) (string, error) {
	args := d.Called(lang)
	return args.String(0), args.Error(1)
}

func (d *dbMock) FetchDefaultMessage() (string, error) {
	args := d.Called()
	return args.String(0), args.Error(1)
}

If we want to mock a method with return signature of (int, string, bool), the return statement we need to write is return args.Int(0), args.String(1), args.Bool(2).

If the return signature is not a simple object, the return should be written using type assertion like return args.Get(0).(*MyObject), args.Get(1).(*AnotherObjectOfMine). See testify godoc for some more extra information.

After creating the mocking object, we can use it in our test.

Mocking Method Without Argument

When we want to mock FetchDefaultMessage() which is method without argument we have to use On(<methodName>, args...) method. The args is variadic therefore we can pass no argument or multiple arguments.

func TestMockMethodWithoutArgs(t *testing.T) {
	theDBMock := dbMock{} // create the mock
	theDBMock.On("FetchDefaultMessage").Return("foofofofof", nil) // mock the expectation
	g := greeter{&theDBMock, "en"} // create greeter object using mocked db
	assert.Equal(t, "Message is: foofofofof", g.GreetInDefaultMsg()) // assert what actual value that will come
	theDBMock.AssertNumberOfCalls(t, "FetchDefaultMessage", 1) // we can assert how many times the mocked method will be called
	theDBMock.AssertExpectations(t) // this method will ensure everything specified with On and Return was in fact called as expected
}

Mocking Method With Argument

Previously we mock FetchDefaultMessage() method which doesn't have any argument. Now let see example if we want to mock a method with an argument.

func TestMockMethodWithArgs(t *testing.T) {
	theDBMock := dbMock{}
	theDBMock.On("FetchMessage", "sg").Return("lah", nil) // if FetchMessage("sg") is called, then return "lah"
	g := greeter{&theDBMock, "sg"}
	assert.Equal(t, "Message is: lah", g.Greet())
	theDBMock.AssertExpectations(t)
}

Mocking Method With Argument That We Don't Care

Sometime we want to mock a method but we don't care the actual argument that is passed. For that purpose we can use mock.Anything in the second parameter onward of On() method argument.

func TestMockMethodWithArgsIgnoreArgs(t *testing.T) {
	theDBMock := dbMock{}
	theDBMock.On("FetchMessage", mock.Anything).Return("lah", nil) // if FetchMessage(...) is called with any argument, please also return lah
	g := greeter{&theDBMock, "in"}
	assert.Equal(t, "Message is: lah", g.Greet())
	theDBMock.AssertCalled(t, "FetchMessage", "in")
	theDBMock.AssertNotCalled(t, "FetchMessage", "ch")
	theDBMock.AssertExpectations(t)
	mock.AssertExpectationsForObjects(t, &theDBMock)
}

Mocking Method With Argument Using MatchedBy

There also will be a time we want to mock a method with a complex argument but want to match the mock based on certain property of the argument or calculation from it. For example, we want to mock FetchMessage method but only if the lang argument is started by letter i.

func TestMatchedBy(t *testing.T) {
	theDBMock := dbMock{}
	theDBMock.On("FetchMessage", mock.MatchedBy(func(lang string) bool { return lang[0] == 'i' })).Return("bzzzz", nil) // all of these call FetchMessage("iii"), FetchMessage("i"), FetchMessage("in") will match 
	g := greeter{&theDBMock, "izz"}
	msg := g.Greet()
	assert.Equal(t, "Message is: bzzzz", msg)
	theDBMock.AssertExpectations(t)
}

Mockery

As we can see in the previous section, before touching actual test and mocking the behaviour, we need to manually create the mock struct. Mockery can help us from the need to do the manual work.

First we just need to install mockery:

go get github.com/vektra/mockery/.../

Then generate the mock.

$ mockery -name <interfaceToMock>

A file contains ready to use mock will be generated and we can add it to our test.

Full source of example code in this post is available in this repo.

I have used vagrant since quite long time. With the recent devops movement, I want to revisit my understanding of the tool because it is very useful to use vagrant when you are simulating distributed system in your local machine. Of course the simulation wouldn't be 100% accurate but it is simpler to do than if you have to spawn some new VM machines in the cloud.

Instalation

This installation guide is for Mac OS. Although vagrant is not a GUI apps, but it is only available under homebrew/cask formula.

$ brew install homebrew/cask/vagrant

It is also possible to install using binary but I still prefer to use brew.

If you don't have virtualisation software then we also need to install one. The easy choice will be virtualbox.

$ brew install homebrew/cask/virtualbox

Check the installation with:

$ vagrant --version
$ VBoxManage --version

Running

To run a VM using vagrant we need to define the VM spec inside Vagrantfile. vagrant provides a helper to generate the file filled with documentation without the need for us to write it from scratch.

$ vagrant init ubuntu/bionic64

The argument after init is the VM box that we want to use, which is for above case is Ubuntu 18.08 Bionic Beaver.

It will add this configuration line in the Vagrantfile:

Vagrant.configure("2") do |config|
  config.vm.box = "ubuntu/bionic64"
end

$ vagrant up

After running up, vagrant will try to download the box if it is not available in local machine. Then it will startup the VM operating system.

Run this to check the status of the VM:

$ vagrant status

Run this to get in to the machine:

$ vagrant ssh

Run these to stop or suspend the machine:

$ vagrant halt # stop the machine
$ vagrant suspend 

Networking

Vagrant support different kind of networking setup. To test the setup, after updating the Vagrantfile, run reload to apply the updated config.

$ vagrant reload

Forward Port Mapping

This configuration setup will forward the call from your machine port 8080 to port 80 in our ubuntu/bionic64. Please note that with this config, the port forwarding is also accessible from other computers in your network.

Vagrant.configure("2") do |config|
  config.vm.box = "ubuntu/bionic64"
  config.vm.network "forwarded_port", guest: 80, host: 8080
end

Forward Port Mapping Disable Public Access

Similar like above, but the access now is limitted only from your machine.

Vagrant.configure("2") do |config|
  config.vm.box = "ubuntu/bionic64"
  config.vm.network "forwarded_port", guest: 80, host: 8080, host_ip: "127.0.0.1"
end

Private Network Disable Public Access

Instead of forwarding port, with private network the guest OS will have its own ip address.

Vagrant.configure("2") do |config|
  config.vm.box = "ubuntu/bionic64"
  config.vm.network "private_network", ip: "192.168.33.10"
end

Public Network

With this config the vagrant machine will appear like another physical machine in your network.

Vagrant.configure("2") do |config|
  config.vm.box = "ubuntu/bionic64"
  config.vm.network "public_network"
end

Folder Sharing

We can share files between host machine and vagrant guest OS using this config.

Vagrant.configure("2") do |config|
  config.vm.box = "ubuntu/bionic64"
  config.vm.synced_folder "data_from_my_laptop", "/vagrant_data"
end

To test it just create some files in your machine.

$ mkdir data_from_my_laptop
$ touch data_from_my_laptop/foo
$ echo "hello world" > data_from_my_laptop/bar
$ vagrant reload
$ vagrant ssh
vagrant@ubuntu-bionic $ ls /vagrant_data

Network and folder sharing setup should cover most common use case of using vagrant. For more details please refer to vagrant official documentation.

I totally forgot that I haven't released this post because my recent busy life. I am blessed with a baby early this year and I also move to a new company. But those two will be stories for another day.

To ensure I am not breaking this couple of years tradition where I have been consistently writing my annual resolution, I am releasing this resolution note albeit it has been almost half year late.

Last December I am getting one more year older again. Time to write evaluate last year resolution and making the new year resolution. No, I don't have go to gym resolution.

Resolution Notes from Previous Years

1. 2016 resolution note
2. 2015 personal note
3. 2014 personal note
4. 2013 personal note
5. 2012 personal note
6. 2011 personal note
7. 2010 personal note

Evaluation of last year goals

Same like last year post, here are some of goals I setup last year and I will comment of how its status. The goal ended with (Checked) means the goal is achieved, if it ended (Nay!) means the goal is not achieved and if it ended with (?) means the goal is too vague in the first place.

• Completing at least 6 MOOC courses (Nay!)
• Take a GRE test (Nay!)
• Apply a postgraduate course (maybe in machine learning or applied math?) (Nay!)
• Launch and work consistently on Travelogee project (Checked partially)
• Have kids. I know this is God decision but I want to try better this year (Checked)
• Buy a house (Nay!)
• Reach Tech Lead position in work place (Almost, I got promoted although not to tech lead)
• Weight no more than 65 Kg (Almost, now I am about 67 Kg)
• Read minimum a book per 2 months and make a review on it (I read a lot but abruptly)
• Learn Tennis (Nay!)
• Use Scala to build something (Nay!)
• Write a book (Nay!)
• Speak in a country level technical conference (Nay!)
• Learn and start investing and get 10% profit in one year (Nay!)
• Visit at least one Africa, America and Oceania country (Checked)
• Get Singapore Class 2 Motorbike license (Nay! but I have started the class 2 class last month)
• Touring using big motorbike for at least to distance like from Sydney to Melbourne (Nay!)
• Able to make a good photography (Nay!)
• Speak English fluently to the level of IELTS 8 band score. I will not do another IELTS test again in one year, though will just try to self assessment. (Nay! I took TOEFL iBT but the score still below my expectation)
• Speak German to basic communication level or more (Nay! The best sentence I can speak the best so far is Das wetter heute is schön)
• Speak Arabic to basic communication level or more (Nay! We drop out from our Arabic class because of timing)
• Contribute something to your surround and be impactful person in a positive way (? vague goal)

I have to admit that I am totally failed last year. No much major achievement.

Following are more detail status of the goal.

Completing at least 6 MOOC courses (Nay!)

The goal seems too unrealistic. I will redo this year with more realistic target.

Take a GRE test (Nay!)

Didn't happen.

Apply a postgraduate course (Nay!)

Too busy.

Launch and work consistently on Travelogee project (Checked partially)

We unoffically launched Travelogee last year but still not work consistent enough to write good contents.

Have kids (Checked)

This is a weird goal because to achieve it depends a lot with external factor and mostly the God grace. After a short desperate life episode, we blessed with a beautiful baby girl on 17 January 2018. Life is very different since then with combination of joy and also tiredness. I will write in separate post for the detail.

Buy a house (Nay!)

No. I bought a Nintendo Switch which is nothing remotely related to house at all.

Reach Tech Lead position in work place (Checked partially)

I didn't become tech lead but at least promoted to something else.

Weight no more than 65 Kg (Checked partially)

Although not reaching my goal, my current weight is around 67Kg dropping from about 74Kg last year. Still not healthy weight considering my short body of 165cm but I still quite feel good about it.

Read minimum a book per 2 months and make a review on it (Nay!)

I read abruptly and managed to read and review very few books this year. But it is still under what I aimed.

Learn Tennis (Nay!)

Nope.

Use Scala to build something (Nay!)

No.

Write a book (Nay!)

Still not happening.

Speak in a country level technical conference (Nay!)

Even I am not speaking or doing any presentation at all. I also finally dropped out from Toastmaster after become passive member for so long.

Learn and start investing and get 10% profit in one year (Nay!)

We have very few investment portfolios but we should have done better.

Visit at least one Africa, America or Oceania country (Checked)

We went to New Zealand last year.

Get Singapore Class 2 Motorbike license (Nay!)

But at least I have started the course again.

Touring using big motorbike for at least to distance like from Sydney to Melbourne (Nay!)

Maybe this year.

Able to make a good photography (Nay!)

Didn't manage to learn photography at all. I started a course in Coursera but stopped following long time ago.

Speak English fluently to the level of IELTS 8 band score (Nay!)

I did TOEFL iBT in 2017 but the score is still not good enough.

Speak German to basic communication level or more (Nay!)

Fail.

Speak Arabic to basic communication level or more (Nay!)

Fail.

Contribute something to your surround and be impactful person in a positive way (?)

Super vague goal.

Resolution Note of 2018

• Completing at least 6 2 MOOC courses
• Take a GRE PTE test
• Launch Work consistently on Travelogee project
• Raise a happy, healthy and smart kid. At least focus play with the kid minimum 30 minutes a day on weekday and 1 hour on weekend.
• Reach Tech Lead position in the new work place
• Weight no more than 65 60 Kg
• Read minimum a book per 2 months and make a review on it
• Write a book about golang
• Speak in a country level technical conference
• Long duration travel to uncommon destination country such as Central Asia
• Get Singapore Class 2 Motorbike license
• Touring using big motorbike for at least to distance like from Sydney to Melbourne
• Speak English fluently to the level of IELTS 8 band score
• Speak Resume to study German to basic communication level or more
• Finish marathon sub 4 hours
• Exercise every day
• Do SAVERS every day

So that's it for this year.

To install go, refer to this post.

Installing Atom

Add PPA and install atom.

curl -L https://packagecloud.io/AtomEditor/atom/gpgkey | sudo apt-key add -
sudo sh -c 'echo "deb [arch=amd64] https://packagecloud.io/AtomEditor/atom/any/ any main" > /etc/apt/sources.list.d/atom.list'
sudo apt update
sudo apt install atom

Installing Atom Go Plus

Go-Plus helps to make go development easier in atom. To install, just to Edit -> Preferences -> Install. Search go-plus in Install Packages search bar then click install.