Kailun's Blog

Visualizing Go Scheduler Events at Runtime

Mon, 01 Dec 2025 09:10:16 +0800

Being a Go dev for some time, my curiosity in Go’s runtime has been gradually built up to the point where I long for more mental grasp than roughly knowing a concept or two. With this in mind, I spent the past few months building go-slowmo, some simple visualization around Go’s GMP scheduling model, which hopefully provides myself and others another way to look into that part of the Go runtime.

Index Fundamentals of Relational Database

Sun, 21 Feb 2021 19:45:34 -0800

Knowledge of database systems is essential to software engineers, and it’s unfortunate that I don’t have much exposure to databases (especially relational ones) at work. Luckily, there’s this highly rated database course from CMU with quite a lot of learning materials, which provides me with a good chance to catch up on this area.

My current plan is to go over indexing and transactions first and this particular post will be grouping some index related notes. The major reason behind this this is that I have recently just gain some high-level understanding of these 2 topics by reading Designing Data-Intensive Applications book, and going over them in more details again could facilitate my understanding of them.

Very Brief Q&A on Raft

Fri, 29 Jan 2021 11:09:50 -0800

Introduction

A year ago (how time flies!) I got to learn Raft when trying to finish a distributed system course made by MIT. It’s overall a consensus algorithem targeting strong consistency, and it’s designed for understandability and the ease for implementation. Recently there’s a need to review it again and I’m making this post so that I don’t forget as fast in the future.

Resources

Pictures used for illustration in this post are gratefully borrowed from the resources above.

Wrapping up Fundamentals of Go Interface: Representation, Reflection and More

Fri, 31 Jul 2020 21:21:33 -0700

Interface is, in many’s opinion, the shiniest part of the design of Go, and it adds flexibility to this statically typed language. As a noob gopher, I feel that leveraging interfaces does help deliver elegant and maintainable code. However, when not fully understood, interface might also be a great source of confusion. In this post, we will target some fundamental yet a bit complex part of Go interface, namely, its representation, its metaprogramming in reflection, and the role it plays in the new proposal of Go generics.

Docker Network and Linux Network Namespace

Sat, 23 May 2020 19:29:09 -0700

In Docker we can create a new network using docker network create with several options. In this post we will take a look at some Linux networking concepts that are used, the basic Docker networking concepts, and how we can use these to construct a custom container network.

Network Namespaces

Docker leverages Linux network namespaces for network isolation, like the way it uses other namespaces (e.g. process namespaces, user namespaces). A network namespace provides a shared set of network interfaces, routing table, and firewall rules. Each Docker container has its own network namespace.

Quick Review of KMP Algorithm

Sat, 02 May 2020 23:40:40 -0700

Published in 1977, the Knuth-Morris-Pratt algorithm can search substring pattern in time linear to the total string length. Recently I encountered 2 Leetcode questions (1367, 1392) that can be effectively solved by KMP, and therefore want to use this post as a quick refresher and go through the basic mechanism and some concrete examples of this algorithm. (A nice video explanation of KMP can be found here

Intuition

In a naive substring search approach, when we find a mismatch between the pattern and the string, we shift the pattern by 1 character to start a new round of comparison (in the example below, we shift the starting B to index 1 after we detect the mismatch at index 4). But we already know the portion before C in the pattern, and we know that we’re gonna compare BAAAA against AAACB.... This means we are doing some kind of “backup” after a mismatch. KMP avoids this backup by using deterministic finite state machine, which will be shown in detail in next section.

Revisit Concurrent Programming in Java -- Threads and Locks

Sat, 28 Dec 2019 12:38:25 -0500

Not long ago I went through the “Concurrent Programming in Java” course on Coursera. Though the contents involved are very fundamental, I felt it’s necessary to give them a revisit since they are building blocks of more advanced contents in concurrent world.

Overview

Overall, I figured this course followed a bottom-up approach. It first introduces low-level Java concurrent primitives, and then go through some of the higher-level approaches that solve some of the problems when programming with the low-level concepts. From that end, it discussed some of the concurrent data structures, and formally introduced linearizability, which is the correctness requirement of any concurrent data structure.

Blog Set Up

Sun, 15 Dec 2019 16:18:54 -0500

Framework

This blog is set up using Hugo framework. It’s a fast and flexible framework written in Golang, and is a popular static site generator. There are various types of themes that are avaiable for use in Hugo, and the one I’m using is called m10c.

Hugo is fairly easy to get started with, and the basic use of it might only involve a few CLI command. Most of the configurations and contents can be edited by adding key-value pairs in the config.toml file. More flexible content management done through Hugo variables and functions in extra HTML files. I’m yet very new to Hugo, so hopefully I can dive deeper later while mataining this blog and share more of it here (stay tuned!).