009 · Articles

All posts

Browse every published article on Manul X — in-depth engineering essays on Next.js architecture, distributed systems, web performance, and developer tooling.

Newest Most read

Artificial intelligence8 min

Where Does Real Knowledge Come From in the Age of AI?

AI answers everything with the same confident tone, whether right or wrong. The only way to catch its errors is to already know the domain. This essay maps six knowledge sources—books, primary documents, vetted updates, courses, people, and practice—and argues that cross-referencing them is the…

Aug 11, 2026Read

System design17 min

Six Stations, Six Ways to Die: A Request's Journey for Survival

Technical notes & reflection — on the road every request must travel, and why it travels that way.

Jun 14, 2026Read

System design14 min

I Built a DNS Server to Understand the Thing I'd Blindly Trusted for Ten Years

There are technologies you use every single day without ever looking them in the eye. For me, DNS was one of them. I'd been typing domain names for a decade. Buying domains, pointing records, waiting for "propagation," cursing when it didn't come up, rejoicing when it did — without really understanding why it came up. DNS, to me, was like the light switch on the wall: flip it and the room lights up; if it breaks, call an electrician. Until one deploy night, the site went down. ping to the IP was fine. curl straight to the IP returned the page. Only the domain name sat there in silence. I stared at it and realized something a little humiliating: I didn't know where to even start fixing it, because I had never truly understood the thing that was broken. So I did what probably only an engineer would find reasonable: instead of skimming the docs, I sat down and wrote an entire DNS server in Rust. The project is called mini-dns. This post is what a black box told me once I finally opened it up.

Jun 13, 2026Read

Software Engineering13 min

Nginx Isn't Acting Up — You're Just Reading the Config Wrong

There's a funny paradox among developers: we'll happily argue for a week about whether the backend should be written in Rust, Go, or Node.js — but when it's time to ship to production, 90% of us quietly type apt install nginx and stick it out front. Nginx is everyone's go-to gatekeeper — and also the thing that has people debugging until 2 a.m., still unable to figure out why one simple request keeps returning a 404. Here's the interesting part: the bug is almost never in Nginx. It's that we read the config file like a script that runs top to bottom — when that's not how Nginx works at all. This isn't a listicle of "common Nginx errors" for you to copy-paste onto your server. The goal is to hand you a mental model: to understand how Nginx thinks, so the seemingly magical traps below become predictable instead of leaving you staring blankly at the screen.

Jun 11, 2026Read

Software Engineering20 min

The Silent Convergence: Why Go, Rust, and Kotlin Are Headed in the Same Direction — And Why It Matters

It’s not that Rust is objectively better than Java. Nor is it that Go will replace C. Rather, the way we think about writing code has silently shifted over the past fifty years — and you are standing right in the middle of that transformation.

Jun 8, 2026Read

System design4 min

5 Years Ago: A Mid-Level Engineer’s Shock Upon Inheriting a Monorepo "Anchor"... Powered by Bazel

Five years ago, I was a mid-level engineer comfortably settled in my tidy, little world of simple repositories. Out of nowhere, the outbound team handed over a massive "anchor" of a Monorepo—powered entirely by Bazel. That initial culture shock, triggered by a tangled web of configuration files, completely shattered my worldview. Yet, looking back, it was the exact trial by fire that transformed me from a local "code-writer" into a true systems engineer. Let’s flip back through the pages of my tech diary to revisit this grueling yet invaluable experience.

Jun 1, 2026Read

Software Engineering7 min

Breaking the Rules Safely: When a Tech Lead Purposefully Violates the Liskov Substitution Principle (LSP)

SOLID is not a religion, and design principles are not immutable commandments. From the perspective of a battle-tested Tech Lead, sometimes deciding to bend the Liskov Substitution Principle (LSP) is a mature choice to keep the system alive. Let’s analyze 4 classic trade-off scenarios and the art of safely isolating the 'toxic code'.

May 28, 2026Read

Software Engineering7 min

The Black Charter of Oil & Gas: When Code Architecture Dictates Survival

"What if a software design flaw didn't just cause a bug, but cost human lives? Step onto a semi-submersible oil rig to discover why the Open/Closed Principle (OCP) and Dagger 2 aren't just textbook theories—they are a survival guide for mission-critical architecture." Length: 254 characters Best for: Medium, Dev.to, or LinkedIn articles where you want to hook the reader immediately with a story.

May 27, 2026Read

Software Engineering6 min

Less Greedy Code, Less Misery: The Power of SRP Through a Battle-Tested Lens

Most critical production bugs don't come from bad algorithms—they come from cramming too many responsibilities into one place. This is a deep dive into the Single Responsibility Principle (SRP) from a pragmatic, real-world perspective: how the "convenience trap" breeds God Objects, why a typical order-processing function becomes a maintenance landmine, and how a Senior refactors it into clean, testable layers. Clean architecture isn't free—but when your project scales to 100 features, it's the very thing that keeps it from collapsing.

May 24, 2026Read