Oliver Nguyen

Working with Stacked PRs using jj

Fri, 17 Apr 2026 00:00:00 +0000

A while back I wrote about working with stacked PRs using git-branchless, git-autofixup, and git-pr. It worked well. But since then I switched to jj — and I’m not going back.

jj is a new version control system that is compatible with git. It can use an existing git repo as its backend. I started using it as a drop-in replacement for git and expected it to feel roughly equivalent. Instead, it made the stacked PRs workflow feel so natural that I wonder how I ever worked without it.

Game theory: A quick introduction

Tue, 23 Dec 2025 00:00:00 +0000

I have recently read a book called “Game Theory in Everyday Life” by Len Fisher. It is a great book that explains concepts of game theory in a simple and easy to understand way. It opens up a new perspective on how to look into familiar situations.

Let’s start with a very usual story from our software engineering work.

A Flaky CI Test

You submit a PR.
Most checks pass, but one CI job fails: some unrelated test.
You re-run it. Green. A classic flaky test.

TIL: Quick note on introduction to group theory (vietnamese)

Thu, 20 Nov 2025 00:00:00 +0000

Hôm nay tôi xem kỹ hơn một video về group theory của tác giả 3b1b.

Và thử diễn đạt lại theo cách hiểu của mình.

Bắt đầu từ symmetry (đối xứng)

Hiểu nôm na thì nó là nói về tính chất của một vật (entity)
(hiểu là một cái gì đấy trừu tượng của toán học, có thể xuất phát từ việc trừu tượng hoá những vật cụ thể trong cuộc sống thực hoặc không).

TIL: Dim white pages to not burn eyes

Sat, 11 Oct 2025 00:00:00 +0000

I’m using dark mode everywhere. But many websites, including Google Docs, Apple Support, etc. still have white background without any option to turn on dark mode.

This is a simple Tampermonkey script to dim white pages a bit, so it won’t burn my eyes.
Basically, it applies an overlay div with background rgba(20, 10, 0, 0.12).The page will be a bit yellow.
If you prefer gray, you can change the overlay color to rgba(0, 0, 0, 0.10).

Commit your code in style with git.emoji 🎉

Tue, 31 Dec 2024 00:00:00 +0000

Have you ever get bored with the same old commit messages, all starting with “update”, “fix” or “feat”? Do you know that emojis are the latest advancement in human language and communication? They can convey emotions and ideas in a single character and make your messages alive! Think about it, even when aliens come to Earth, they will quickly understand the meaning of these little characters! 😎

New year, new you! Let’s leave boring commits in the past and embrace the magic of emojis to make every commit a celebration! 🥳✨

The power of diff in testing - Part 1: SQL queries and mocks

Thu, 26 Dec 2024 00:00:00 +0000

A new day at work

Suppose that you, a good software engineer, just got hired by an e-commerce business. And you are joining a team to work on the profile service to manage customers and their addresses.

There are a Customer and an Address struct, with a couple of gorm tags for the database schema:

type Customer struct {
    ID         uuid.UUID `gorm:"type:uuid;primaryKey" json:"id"`
    Name       string    `json:"name"`
    Age        int       `json:"age"`
    Gender     string    `json:"gender"`
    Email      string    `gorm:"uniqueIndex" json:"email"`
    Phone      string    `json:"phone"`
    Occupation string    `json:"occupation"`
    Addresses  []Address `gorm:"foreignKey:CustomerID" json:"addresses"`
    Languages  []string  `gorm:"type:text[]" json:"languages"`
}

type Address struct {
    ID          uuid.UUID `gorm:"type:uuid;primaryKey" json:"id"`
    CustomerID  uuid.UUID `gorm:"type:uuid;not null;index" json:"customer_id"`
    HouseNumber int       `json:"house_number"`
    Street      string    `json:"street"`
    City        string    `json:"city"`
    Country     string    `json:"country"`
    ZipCode     string    `json:"zip_code"`
}

You look at the method UpdateCustomerWithAddress() which to update a customer and their associated addresses:

ezpkg.io/conveyz: Understanding the Implementation of FConvey

Fri, 20 Dec 2024 00:00:00 +0000

The FConvey function is a standout feature of ezpkg.io/conveyz, designed to simplify focused testing in Go. Unlike the original smartystreets/goconvey framework, which requires developers to set FocusConvey at every nested block level, FConvey is smarter. It ensures that focusing on a single block propagates to all relevant nested and parent blocks, streamlining the debugging process.

In this article, we dive deep into the implementation of FConvey, why the original FocusConvey does require manual setting at every level, and how FConvey solves the problem.

iter.json: A Powerful and Efficient Way to Iterate and Manipulate JSON in Go

Thu, 12 Dec 2024 00:00:00 +0000

Have you ever needed to modify unstructured JSON data in Go? Maybe you’ve had to delete password and all blacklisted fields, rename keys from camelCase to snake_case, or convert all number ids to strings because JavaScript does not like int64? If your solution has been to unmarshal everything into a map[string]any using encoding/json and then marshal it back… well, let’s face it, that’s far from efficient!

What if you could loop through the JSON data, grab the path of each item, and decide exactly what to do with it on the fly?

Errors, Errors Everywhere: How We Centralized and Structured Error Handling

Fri, 06 Dec 2024 00:00:00 +0000

Handling errors in Go is simple and flexible – yet no structure!

It’s supposed to be simple, right? Just return an error , wrapped with a message, and move on. Well, that simplicity quickly turns into chaotic as our codebase grows with more packages, more developers, and more “quick fixes” that stay there forever. Over time, the logs are full of “failed to do this” and “unexpected that”, and nobody knows if it’s the user’s fault, the server’s fault, buggy code, or it’s just a misalignment of the stars!

Welcome to my blog!

Wed, 27 Nov 2024 00:00:00 +0000

Hi! I’m Oliver Nguyen, a software engineer working with Go & JS. 👋

I enjoy writing code and building tools to make writing code even faster! I love working in start-up environments, where I get to build everything from the ground up and improve them as companies grow.

Along the way, I share my knowledge and write about best practices in software development, covering topics like tooling, architecture, and coding practice. Learning something new every day is exciting. Writing helps me dive deeper into topics. And sharing makes the journey more meaningful and memorable!

Implement a Distributed State Machine with Redis to Migrate Billions of Records

Sun, 20 Oct 2024 00:00:00 +0000

As a start-up company, we started with a simple architecture: All data were stored in a single centralized Postgres instance, shared by a few services. It has been working well and allows us to move fast, deliver features, enter the market, acquire clients, and grow exponentially.

Fast forward a couple of years, today we have thousands of clients and billions of records, it’s time to migrate the top tables from Postgres to a better solution. We choose DynamoDB, a key-value datastore by AWS, with high availability, low-latency performance, and see the queries reduce to single-digit milliseconds.

How to live on 24 hours a day – by Arnold Bennett

Wed, 31 Jul 2024 00:00:00 +0000

“How to Live on 24 Hours a Day” is a classic self-help book written by Arnold Bennett, first published in 1910. The book is a practical guide on time management and personal development, emphasizing the importance of making the most out of each day.

Bennett argues that time is the most valuable resource we have and that many people waste it without realizing it. He suggests simple but effective ways to structure your day to include both work and personal development activities, such as reading, reflecting, and improving oneself. The book is written in a straightforward and engaging style, making it accessible to a wide audience.

Upgrade your scripts using 'direnv' and 'run' script

Wed, 24 Jul 2024 00:00:00 +0000

In JavaScript/Node world, we usually store scripts in package.json and run them using npm. In other worlds, we use Makefile or create a directory and put all our scripts there. But there is a better way to manage and run scripts for your team. No, I’m not talking about Warp or other ~~pricey~~ fancy tools.

I will share about direnv and our old friend bash: How we are using them to effectively write and manage scripts as a team.

Refactor: GoroutineTracker with unnecessary usage of reflect

Tue, 02 Jul 2024 00:00:00 +0000

Today, I encountered this code in my company codebase (the code and comments are rewritten for demo purpose and do not include any proprietary code):

type GoroutineTracker struct {
  wg sync.WaitGroup
  // ... some other fields
}
// Go starts a new goroutine and tracks it with some metrics.
func (g *GoroutineTracker) Go(ctx context.Context, name string, f any, args ...any) {
	fn := reflect.TypeOf(f)
	if fn.Kind() != reflect.Func { panic("must be function") }
	if fn.NumIn() != len(args) { panic("args does not match fn signature") }
	if fn.NumOut() > 0 { panic("output from fn is ignored") }
	
	g.wg.Add(1)
	id := g.startCaptureTime()
	go func() {
		defer func() {
			r := recover()
			// ... some panic handling code
			g.wg.Done()
			g.endCaptureTime(id)
		}()
		
		input := typez.MapFunc(args, func(arg any) reflect.Value {
			return reflect.ValueOf(arg)
		})
		_ = reflect.ValueOf(f).Call(input)
	}()
}
// Wait for all goroutines to finished.
func (g *GoroutineTracker) Wait() { g.wg.Wait() }

The GoroutineTracker is used for tracking usage of goroutines in the codebase, for example, number of goroutines, time taken by each goroutine, etc. The Go method is used to start a new goroutine and track it. The Wait method is used to wait for all goroutines to finish.

ezpkg.io - Collection of packages to make writing Go code easier

Wed, 26 Jun 2024 00:00:00 +0000

As I work on various Go projects, I often find myself creating utility functions, extending existing packages, or developing packages to solve specific problems. Moving from one project to another, I usually have to copy or rewrite these solutions. So I created ezpkg.io to have all these utilities and packages in one place. Hopefully, you’ll find them useful as well.

The logo is Gopherz - which I created using DALL-E

Let’s look at some problems that these packages are solving.

GitHub PRs on MacOS Menu Bar

Thu, 28 Sep 2023 00:00:00 +0000

I usually push a lot of PRs in form of stacked PRs to GitHub. It’s quite annoying to go through each PR to see the check status. So I created this plugin to show my PRs on the menu bar. — Now, everything is just a click away!

Features

1. Top PRs section

List of your chosen PRs, sorted by your order.
You can customize the list of PRs in this section by updating the file github.swiftbar/__/.prs.txt. It contains a list of PRs that you want to show in this section. The app will try extracting PR numbers from the file, ignoring text. You can create a command to update the file automatically when you push a stacked PRs.
If you do not have any PRs in the list, it will fallback to display your most recent PRs, sorted by updated time (last 3 days for open PRs, and last 1 day for merged PRs).

2. My recent PRs section

List of your recent PRs, sorted by number.
Last 7 days, include both open and merged PRs.

3. Other PRs section

List of PRs from other people, sorted by number.
Last 7 days for all PRs with comments.
Last 3 days for all PRs without comments. If you want to keep a PR that you find interesting up to 7 days, just add a comment to it.

TIL: String type with a specific length in TypeScript

Sat, 26 Aug 2023 00:00:00 +0000

We’ll declare a Phantom Type:

type StringN<N> = string & {
  length: N;
  readonly X: unique symbol;
}

const isStringN = <N extends number>(length: N, s: string):
  s is StringN<N> => s.length == length;

export const stringN = <N extends number>(length: N, s: string): StringN<N> => {
  if (!isStringN(length, s)) throw new Error(`input must have length ${length}`);
  return s;
}

Then we can use it as below:

export type MicroUuid = StringN<4>;
export const microUuid = () => stringN(4, newUuid().slice(0, 4)) as MicroUuid;

let s4: MicroUuid  = microUuid();     
let s5: StringN<5> = stringN<5>(5, 'hello');

s4 = 'any string'; // invalid
s4 = s5;           // invalid

We can extend it further to make a specific type for our MicroUuid:

type MicroUuid = string & {
  readonly X: unique symbol;
}

const isMicroUuid = (s: string): s is MicroUuid => /[a-f0-9]{4}/.test(s);

const asMicroUuid = (s: string) => {
  if (!isMicroUuid(s)) throw new Error('invalid input');
  return s;
}

const newMicroUuid = () => newUuid().slice(0, 4) as MicroUuid;

We can use the same declaration readonly X: unique symbol in multiple type, and they are still different:

TIL: console.log with color

Tue, 15 Aug 2023 00:00:00 +0000

We can use this pattern to output log with color in browser by adding CSS:

const logger = (name) => ({
  info: console.info.bind(console, `%c${name}: %s`, 'color: #56d74b'),
  verbose: console.debug.bind(console, `%c${name}: %s`, 'color: #70818e'),
})

Building flow compiler for sending campaigns and auto reply

Thu, 10 Aug 2023 00:00:00 +0000

At work, I’m working on the flow compiler, which compile from flow documents into ETA flow descriptors. The use cases are to provide our users the ability to automatically response to their customers’ messages. Users can define their own flow and customize auto reply behaviours. This article gives a look into my work. Also see related article.

Package flow implements the flow document compiler and runtime controller. The compiler is responsible for parsing the flow document and compiling it into a specific format for that flow document type, and can be executed by a runtime engine. Currently, there are two compiler engines: auto reply and campaign. The compilation process is divided into five phases: scanner, parser, analyzer, generating ir, and generating output.

TIL: Auto-reload a command when files changed using entr

Mon, 15 May 2023 00:00:00 +0000

While working with Go and JavaScript, we have tools available for auto reloading the server when the code changes. For JavaScript, we even have hot reload which reloads part of the page without reloading the whole page. But for Python, we don’t have such tools, I tried livereload, but it does not work well for nested directories. So I decided to do it myself. And there is a tool called entr which helps run a command when some file changes.

Pull data from HackerNews API and dump to JSON files

Mon, 20 Mar 2023 00:00:00 +0000

I wrote a simple script to download the HackerNews data from HackerNews API. It downloads the data in JSON format and stores it as a collection of files. The first time it runs, it will create the directory data to store the data. Subsequent runs will update the data in the directory.

At the time of this writing, the HackerNew database has about 35 million items.

Usage

git clone https://github.com/iOliverNguyen/hackernews-dump
cd hackernews
direnv allow
go run . sync --concurrent=30 --update-back=1

# for debugging
go run . sync --debug

Install direnv if necessary.

Visualize flow documents and ETA flow descriptors

Wed, 15 Mar 2023 00:00:00 +0000

At work, I’m working on the flow compiler, which compile from flow documents into ETA flow descriptors. You can read more details in this article.

Flow documents are a collection of nodes and edges, which are JSON objects. They are used to describe the flow of an automation chatbot. The flow compiler takes a flow document and compile it into an ETA flow descriptor, that is used by the ETA engine to run the flow. ETA is short for “Event-Action-Trigger”, a programming paradigm that is used to describe how to react (“action”) with each event matching a specific condition (“trigger”).

Working with Stacked PRs using git-branchless, git-autofixup, and git-pr

Sun, 19 Feb 2023 00:00:00 +0000

I usually work with stacked PRs. It is a great way to organize my work and keep my commits small. This empowers separation of concern and limit scope of each PR. Reviewers can go through each PR and review them one by one. Smaller changes, better feedback!

I was using sapling. It worked really well in the first month, but the honeymoon ended too soon. Read more...

Using sapling, I can view stacked commits with sl smart logs, edit many files and make changes to many commits at the same time with sl absorb, have the stack automatically rebase after each change, and push these commits as multiple stacked GitHub PRs with a single sl pr command. It’s great! In the first month, I was very happy with sapling. You can read more about it in my last article.

TIL: Where does Github CLI store its credentials?

Sat, 07 Jan 2023 00:00:00 +0000

When using sapling, it can access my github with my credentials by asking me to gh auto login. I was wondering where it stores these credentials: in the keychain, in a file, in the environment? It’s here:

$ cat ~/.config/gh/hosts.yml
github.com:
    user: iOliverNguyen
    oauth_token: gho_████████████████████████████
    git_protocol: https

Make goconvey work with gomega assertion

Sun, 25 Dec 2022 00:00:00 +0000

At work, we use gomega for testing. It works well, until one day it becomes too verbose and goconvey becomes a better fit. To prevent the repository from using two different sets of assertion functions, I decided to write an adapter to make goconvey work with gomega assertion functions.

gomega

gomega is a testing framework for Go. Here’s what it looks like:

package example_test

import (
    "fmt"
    "testing"

    . "github.com/onsi/ginkgo"
    . "github.com/onsi/gomega"
)

func Test(t *testing.T) {
    RegisterFailHandler(Fail)
    RunSpecs(t, "Example Suite")
}

var _ = Describe("PathTraversal", func() {
    var s string
    BeforeEach(func() {
        s = "Start"
    })
    AfterEachfunc(func() {
        fmt.Println(s)
    })
    Describe("Executing test 1", func() {
        BeforeEach(func() {
            s += " -> test1"
        })
        It("Test 1.1:", func() {
            s += " -> test1.1"
            Ω(s).To(Equal("Start -> test1 -> test1.1"))
        })
        It("Test 1.2:", func() {
            s += " -> test1.2"
            Ω(s).To(Equal("Start -> test1 -> test1.2"))
        })
    })
    Describe("Execute test 2", func() {
        BeforeEach(func() {
            s += " -> test2"
        })
        It("Test 2.1:", func() {
            s += " -> test2.1"
        })
        It("Test 2.2:", func() {
            s += " -> test2.2"
            Ω(s).To(Equal("Start -> test2 -> test2.2"))
        })
    })
})

gomega/ginkgo uses a DSL to describe the test cases. Ω() is an alias of Expect(). The execution order is:

Make sapling work with direnv

Tue, 20 Dec 2022 00:00:00 +0000

In the last post, I shared my experience with Sapling, Meta’s new Git client. It requires some workaround with direnv. This post explains the change in details.

At work, we are using direnv for quickly managing environment variables on our repository. When we cd into a directory, or a subtree, it automatically detects the file .envrc in the current directory (or the nearest parent directory), loads environment variables, and execute predefined commands.

My first impressions of Sapling — Meta’s new Git client

Fri, 16 Dec 2022 00:00:00 +0000

Sapling is a new source control system developed by Meta. Recently, it gains the ability to work with GitHub. I’m curious about how it works, so I decided to give it a try and end up using it daily on my company’s repositories. If you want to try it out, check their documentation here.

Stacked PRs

When developing, I usually create a single commit for each PR and stack them together.

The Immune System: What happens when you get a small cut?

Thu, 01 Dec 2022 00:00:00 +0000

We know that our blood contains white blood cells. And we probably heard of macrophages and T-Cells. But the immune system has so much more. The book Immune from Philipp Dettmer, the author of Kurzgesagt channel, will provide insights into the beautiful mechanisms of our immune system. This article is my summary of our immune system, what they are and how they protect our body.

The immune system can be divided into the Innate immune system and the Adaptive immune system.

TIL: Packing web app as desktop app on Mac without Electron

Wed, 30 Nov 2022 00:00:00 +0000

gluon

Recently, I found gluon. It is a framework for building desktop applications using web technologies. Unlike Electron, it uses the System installed Chromium or Firefox instead of the bundled Chromium. This makes it possible to use the same version of Chromium or Firefox as the one used by the user’s browser. This also makes the application significantly smaller. At the time of this TIL, the gluon framework is only a few weeks old.

Latest JavaScript features in 2022

Thu, 15 Sep 2022 00:00:00 +0000

JavaScript is changing fast with a lot of new and exciting features to help us - developers write code better and better. These features have been released for a while. Let’s check them out!

1. Private fields

Previously, all class fields must be defined in the constructor. And there is no private fields. All fields can be accessed from outside. Of course, there are tricks with scope to make some variables inaccessible. But let’s not talk about them.

TIL: File descriptor 3

Sun, 03 Jul 2022 00:00:00 +0000

Linux

There are three standard file descriptions, STDIN, STDOUT, and STDERR. They are assigned to 0, 1, and 2 respectively.

File descriptor 3, 4 and so on can be accessed at:

/proc/12345/fd/3

I found it when looking at this Patchset. Chromium open --remote-debugging-pipe at file descriptor 3 for output and file descriptor 4 for input.

Windows?

TIL: git am

Thu, 30 Jun 2022 00:00:00 +0000

TIL: Git

How to apply a patch from github into the current repository

gh pr diff --patch 4 | git am

git am

Apply a series of patches from a mailbox.

TIL: 10 most relaxing songs to reduce anxiety, according to neuroscientists

Sat, 18 Jun 2022 00:00:00 +0000

According to neuroscientists, music can reduce anxiety and stress. They suggested a list of the ten most relaxing songs to reduce anxiety:

“Weightless,” by Marconi Union
“Electra,” by Airstream
“Mellomaniac (Chill Out Mix),” by DJ Shah
“Watermark,” by Enya
“Strawberry Swing,” by Coldplay
“Please Don’t Go,” by Barcelona
“Pure Shores,” by All Saints
“Someone Like You,” by Adele
“Canzonetta Sull’aria,” by Mozart
“We Can Fly,” by Rue du Soleil (Café Del Mar)

The top song is especially designed to reduce anxiety. The group that created “Weightless”, Marconi Union, did so in collaboration with sound therapists. Its carefully arranged harmonies, rhythms, and bass lines help slow a listener’s heart rate, reduce blood pressure and lower levels of the stress hormone cortisol.

TIL: Run Go tests inside WASM

Fri, 17 Jun 2022 00:00:00 +0000

Browse the source files:

TIL: WASM with Go and run it inside browser

Tue, 14 Jun 2022 00:00:00 +0000

Enter 1-10 in the above box. It should output UUIDs.

Writing Go code

func main() {
  done := make(chan struct{}, 0)
  js.Global().Set("wasmGenerateUUIDs", js.FuncOf(generateUUIDs))
  <-done
}

func generateUUIDs(this js.Value, args []js.Value) any {
  if len(args) == 0 {
    return uuid.NewString()
  }
  count, err := strconv.Atoi(args[0].String())
  if err != nil {
    return "ERROR: invalid number"
  }
  if count > 10 {
    return "ERROR: too many"
  }
  uuids := make([]string, count)
  for i := 0; i < count; i++ {
    uuids[i] = uuid.NewString()
  }
  return strings.Join(uuids, "\n")
}

And compile to WASM:

TIL: Ultralearning, by Scott Young

Thu, 09 Jun 2022 00:00:00 +0000

Ultralearning is a book from Scott Young. He spent time learning a lot. Like spending 1 year in 4 non-English countries, each country in 3 months, to learn speaking foreign languages.

Make a metalearning map

Design your goals and scopes. Determine exactly what you want at the end. Spend the first 10% of time to answer:

What concepts do I need to understand?
What facts do I have to memorize?
What procedures do I need to practice?

Draw 3 columns on paper: Concepts to understand. Facts to memorize. Procedures to practice.

TIL: Include HTML file in a post with Hugo

Mon, 06 Jun 2022 00:00:00 +0000

Shortcode are simple snippets inside your content files calling built-in or custom templates.

Include HTML file in a post

Create layouts/shortcodes/include-html.html:

{{ $file := .Get 0 }}
{{ (printf "%s%s" .Page.File.Dir $file) | readFile | safeHTML }}

Then use it in your content files:

{{< include-html "embedded.html" >}}

TIL: Better Memory

Thu, 02 Jun 2022 00:00:00 +0000

Memory tips by BigThink.com

Chronic stress is really bad for our memory. It make us tired and loose attention. Stress hormones mobilize your brain and body to respond, to fight, to flee, to react quickly - not to think.
Get enough sleep. If you don’t get enough sleep, your hippocampus might not have enough time to consolidate memories.
You remember when you pay attention. Don’t multitask.
Repetition is good.
Self testing. Recall information. Test yourself with flash cards.

TIL: Beware of Nil UUID when updating database with gorm!

Wed, 30 Mar 2022 00:00:00 +0000

WHERE conditions required

At work, we are using gorm for dealing with database. It’s a popular SQL manipulation library in Go.

But recently, we got a scary error:

can not update row: id=00000000-0000-0000-0000-000000000000
WHERE conditions required

Which happened from this code snippet:

db, _ := gorm.Open(...)

paper := &Paper{
	ID:   updateID,
	Name: "new name",
}
db.Update(paper)

The above code will generate the following SQL statement:

UPDATE "paper" SET "name" = $1, "updated_at" = $2
WHERE "paper"."deleted_at" IS NULL AND "id" = $3

Everything looks fine, right? The correct SQL statement is generated. The paper with given id is updated. Unit test passes. The code was deployed to production. Customer is happy. And we can sleep well.

Compare and swap in Redis

Tue, 29 Mar 2022 00:00:00 +0000

Compare and swap

Compare and swap is a familiar concept of atomic operation, for dealing with race condition. Suppose we want to build a lock for multiple instances to execute some command, and only one can be executed at a given time. An instance must wait for the lock to be released before it can take.

Instance 1: Current value is empty, set it to 1 and take the lock.
Instance 2: Current value is not empty, wait.
Instance 1: Done, set it to empty and release the lock.
Instance 2: Current value is empty, set it to 2 and take the lock.

In Go, this can be implemented by sync/atomic package:

Validate zero enum value in Protocol Buffer

Tue, 01 Mar 2022 00:00:00 +0000

How to validate that a Protobuf message does not contain enum fields with zero value? Turn out that is not supported directly by Protobuf! We need to look into how protojson package is implemented.

More and more companies are adopting gRPC with Protobuf for communication between internal services. It has the benefits of high performance, supporting multiple programming languages, and being backed by Google with a great ecosystem around.

For communication with front-end and external services, Protobuf can be marshaled to JSON format. The browser only understands JSON format, and we can not expect other companies to consume Protobuf directly from us. (Of course, you can, if you are big enough!)

Eventual consistency and cache

Tue, 22 Feb 2022 00:00:00 +0000

What is it?

Eventual consistency is a fancy name of doing something and only expecting the changed state after a while. And there is a guarantee that you will eventually get the expected state. Hence, consistency.

But that won’t work well with caching. And I had to deal with that recently when working with WhatsApp API.

When querying for a list of message templates from WhatsApp, we’ll cache the response for use later. It’s because message templates are not something that changes so frequently. Just cache it to reduce unnecessary API calls.

Create an emoji ball-drop game with Matter.js

Sat, 22 Jan 2022 00:00:00 +0000

You can’t connect the dots looking forward; you can only connect them looking backwards. So you have to trust that the dots will somehow connect in your future.

⸺ Steve Jobs

Sometimes, stepping outside of your comfort zone and taking some side projects is a great way to improve as a developer. The more skills you acquire, the more you can do. And you may need them someday in the future.

Front-End development without node_modules using Skypack and Snowpack

Tue, 02 Feb 2021 00:00:00 +0000

Once upon a time, we could simply put an HTML and a script file into an FTP server, quickly have a working website and call it a day.

Today, we have to jump through many hoops just to get the right things in the right places. Suppose Alice wants to spend her weekend making a simple to-do app or whatever little idea she enjoys. First, she has to install a big heap of 10k npm packages files. Then she spends a few hours searching how to get this week’s js bundler working with the latest typescript with the latest trending UI framework. And a lot frustrating when things don’t work or those articles have just outdated. Once she has actually started building the first feature for her little fun app, the weekend has mostly gone!

µjson - A minimal JSON parser and transformer in Go

Sat, 09 Jan 2021 00:00:00 +0000

µjson is a minimal JSON parser and transformer that works on unstructured (and trusted) JSON. It works by parsing input and calling the given callback function when encountering each item.

Motivation

Sometimes we just want to make some minimal changes to a JSON document or do some generic transformations without fully unmarshalling it. For example, removing blacklisted keys from response JSON. Why spend all the cost on unmarshalling into a map[string]interface{} just to immediately marshal it again. The following code is taken from StackOverflow: