Golang on Ou David | Systems Engineer

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.

Go Language Case Studies

Sat, 13 Jun 2026 00:00:00 +0000

This is where I keep small Go case studies that support the technical writing on this site. Each topic is built as a runnable example with tests or benchmarks, so the discussion can point to code instead of relying only on explanation.

Public repo: gitlab.vvivid.dev/showcase/go-lang-case-study.

The first case study compares normal string concatenation with strings.Builder, including benchmark output and allocation counts.

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.

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.