Technical Deep Dives on Ou David | Systems Engineer

The Process API Behind Every Shell Command

Mon, 15 Jun 2026 13:31:48 +0700

I’ve been reading Operating Systems: Three Easy Pieces, and today I went through chapter 05, the interlude on the Process API. It is a short chapter, but it clarified something important about how processes actually work.

If you want to see the same idea in practical Go code, I put a small runnable example in the public case-study repo: go/process-api-shell. It uses Go’s standard os/exec package to run commands, redirect output, build a simple pipeline, and wait for the processes to finish.

String Concatenation vs strings.Builder in Go

Sat, 13 Jun 2026 10:34:19 +0700

I often leave the same comment when I see string concatenation inside a loop:

If you build a string in a loop, use strings.Builder.

That comment sometimes gets pushback from the team: the two operations probably will not matter much. Today, I want to show a simple benchmark to demonstrate why strings.Builder is superior to doing += inside a loop.

The runnable code and raw benchmark output are available in the public repo: gitlab.vvivid.dev/showcase/go-lang-case-study.

The Trap of Vibe Coding for Juniors

Tue, 27 Jan 2026 12:00:00 +0700

Today I want to write about something different: vibe coding.

My honest opinion is that vibe coding is risky for junior developers. Not because AI is bad at writing code. The real problem is that juniors often do not have enough experience yet to judge whether the generated solution is correct, maintainable, or safe under production pressure.

That is where the trap starts. The code works once, the demo looks good, and the feature feels finished. But working code is not always good code.

Handling Fractional Cents in Integrations

Wed, 21 Jan 2026 08:48:01 +0100

I’m back with another story about a “silent error” in our systems. In my previous post, I talked about how implicit timezone conversions can bite you. Today, let’s talk about a different type of error: a design flaw when dealing with money.

The Real Problem

We are building a Central Reservation System (CRS) for a tourist park. One of our golden rules when dealing with money is simple: always use integers. We convert everything to cents before pushing it to our cash-register API.

The Silent Timezone Mismatch: Go vs MongoDB

Fri, 16 Jan 2026 18:33:20 +0100

I recently encountered a subtle bug that cost more time than I’d like to admit. It’s a classic example of how implicit defaults in our tools can lead to unexpected behavior in distributed systems.

The Real Problem

I was implementing a validation function, isValidCiaoPayment. The logic was simple: check if a payment record from MongoDB matches a specific check date (e.g., “2026-01-15”).

Here is the logic:

// Convert payment time to string YYYY-MM-DD
paymentUpdatedAtDate := payment.UpdatedAt.Time().Format(time.DateOnly)

// Compare with the target date
if paymentUpdatedAtDate != checkDate {
 return false
}

The function kept returning false even when the data looked correct in the database.

Building a JSON-RPC Server in Go: Complete Implementation Guide

Sat, 30 Aug 2025 10:00:00 +0000

Last week, I posted about JSON-RPC and the Model Context Protocol. Today, we’re going to see an example of how we can create a simple application following the JSON-RPC standard. We’ll build a simple JSON-RPC calculator together, and I hope you’ll enjoy it.

Request Flow Overview

flowchart LR A[Client Request] --> B[Parse JSON] B --> C{Valid?} C -->|No| D[Error Response] C -->|Yes| E{Type?} E -->|Request| F[Match Method] E -->|Notification| G[Execute & End] F --> H{Method Found?} H -->|No| I[Method Not Found] H -->|Yes| J[Execute Method] J --> K[Build Response] I --> K K --> L[Send Response] D --> L L --> M[End] G --> M

Message Parsing and Validation

Let’s recap JSON-RPC message types. We have 3 types of messages: Request, Response, and Notification. For request and response types, we can send them in batches, and responses must be returned in a batch matching the request IDs in any order. We can distinguish between a request and a notification by checking the ID field. If there’s an ID, it’s a request; if not, it’s a notification.

Understanding JSON-RPC: The Protocol Behind MCP

Sun, 24 Aug 2025 00:00:00 +0000

I’ve been diving into the Model Context Protocol (MCP) lately. Honestly, it’s the most exciting thing happening in AI infrastructure right now. But here’s the thing: to really understand MCP, you need to understand JSON-RPC first. That’s what MCP is built on.

So let me break down JSON-RPC for you. Once you get this, MCP will make way more sense.

First, let’s talk about how JSON-RPC is different from the REST APIs we’re all used to. REST is stateless and unidirectional where each request is independent. Check this out:

The HTTP Request Journey in Go: From Network to Handler

Fri, 08 Aug 2025 10:00:00 +0000

As a backend guy, I’ve been tasked with building various APIs for different projects, and most of them I built using Go. For the majority of the time, what most people do is write a handler or middleware to process and respond to requests. Today, we’re going to do something different. We’ll go down a rabbit hole together into the abstractions that Go has taken away from us. We’ll see all the interesting things that Go does before handing us the request and response objects in our handler. After this deep dive, we’ll understand how to parse requests, how routing matching works, middleware execution, and finally the architecture that Go uses to handle each request.