Engineering on Lorbic

How Go Channels Actually Work

Thu, 13 Aug 2026 18:00:00 +0530

A single unbuffered channel send without an active receiver is enough to silently lock up a production worker pool, leaking memory until your service gets killed by the OS kernel.

On the surface, Go channels look simple: they synchronize concurrent execution without manual mutex management. But under heavy load, a minor oversight in channel sizing or worker coordination blocks the scheduler, leaks memory, or crashes processes with runtime panics.

Part 6: Simulating a Living Facility: Room Derivation, Sunlight Spillover, and Positional SFX

Mon, 10 Aug 2026 10:00:00 +0530

Generating a raw matrix of integer tiles gives you a map layout, but it doesn’t give you a living environment. When I loaded my first level into Derelict Facility, the engine had no concept of what a “Laboratory” or a “Reactor Room” was. It just saw a flat array of walls and floors.

If a player flipped a power terminal inside a room, I had no clean way to know which room lights or doors to toggle without scanning the whole map grid on every frame. If an alarm fired down the hall, it played at full volume regardless of where the player was standing.

Designing a Distributed Job Scheduler in Go: Partitioning, Locking, and Backpressure

Sun, 09 Aug 2026 14:00:00 +0530

Linux crontab is one of the most elegant pieces of software ever written for single-host automation. It is simple, clear, and has kept Unix systems running reliably since 1975.

The problem starts when we take a single-host tool and deploy it across a multi-node cloud setup.

In Relay, a multi-tenant AI API gateway system design, background jobs power core operations: every top of the hour, a job rolls up raw API usage tokens into tenant billing metrics; every 15 minutes, another job scans for expired API keys and purges them from cache; every 30 seconds, a health checker pings upstream LLM provider endpoints.

Part 5: From Terminal Cells to Sprite Maps: Font Fallbacks and Auto-Tiling

Sun, 09 Aug 2026 10:00:00 +0530

Building a terminal-based engine in pure ASCII looks cool for about five minutes. Then you try rendering a complex facility map with corners, T-junctions, and status icons, and raw character cells start feeling incredibly limiting.

Two specific problems hit me immediately when I tried switching to Raylib for graphics. First, drawing wall tiles manually by hand in level files meant placing 16 different corner variations by hand. Second, when I tried rendering a 🚨 warning emoji alongside FiraCode monospace text, Raylib just rendered a missing glyph box (? or □).

Part 4: Refactoring to SoA ECS: Bitmasks and Flat Component Arrays

Sat, 08 Aug 2026 10:00:00 +0530

When I started building Derelict Facility, my initial instinct for game actors was standard Object-Oriented design: create an Entity struct, add pointers for position, sprite, and stats, and store them in a slice ([]*Entity).

It worked fine for five entities. But as soon as I added automated doors, save terminals, and active power grids across a 1000-tile map, keeping track of separate heap pointers became a headache. My Go profiler showed GC pauses spiking while the CPU spent more time chasing heap pointers across non-contiguous memory than actually updating game state.

Designing a Usage-Based Billing Pipeline for SaaS

Sat, 01 Aug 2026 17:26:52 +0530

In How Multi-Tenant SaaS Actually Works, I left one major promise unfulfilled at the end: “Billing is an entire system design on its own. The billing pipeline gets its own post.”

Couchbase Index Best Practices and Query Performance Tuning

Fri, 31 Jul 2026 23:00:00 +0530

Most Couchbase performance tickets I have seen end the same way: someone adds more nodes, the dashboard looks a little better for a week, and the same query shows up in the slow log a month later. The node count was never the problem. The index was.

This is a working reference, not an essay. I already wrote the reflective version of what indexing in Couchbase teaches you about systems in general. This post skips the reflection and gets straight to the decisions: which index type to reach for, how to order composite keys, how to tell if a query is actually using what you built, and which four or five mistakes account for most of the slow queries you will ever debug. Couchbase’s own documentation is the primary source for the recommendations below. Every example runs against travel-sample, the sample bucket Couchbase ships with every install, so you can paste these into your own cluster and see the plan yourself.

API Design for Backend Systems

Sun, 26 Jul 2026 19:00:00 +0530

A few weeks ago I designed Relay, a multi-tenant AI API gateway, as a system design exercise. That post covered the database, the auth, the billing. It did not cover the thing every one of those systems is sitting behind: the API itself.

Here is the question that post left open. When someone builds GET /v1/requests to list a tenant’s API call history, what should that endpoint actually look like? Offset or cursor pagination? What does the response envelope contain? What happens when Relay needs to add a filter that does not fit in a query string? What does a webhook payload look like when Relay tells a tenant “your batch job finished”? None of that is specific to AI gateways. It is the same decisions every backend API makes, made badly often enough that “REST API” has become a phrase that means “JSON over HTTP, structure unspecified.”

Cache-Driven Development: Saving Your Database From Itself

Wed, 22 Jul 2026 12:00:00 +0530

There is a moment in every backend engineer’s life when their database starts refusing connections.

Picture 2 a.m. on a Tuesday. The app is operating under normal traffic, nothing unusual. But the database connection pool is saturated. Queries are timing out. The monitoring dashboard shows 50,000 database operations per second, far beyond what the system should be handling.

When someone pulls the slow-query logs, the pattern is immediately clear. The same query appears thousands of times:

Designing a Distributed Rate Limiter with Redis

Tue, 07 Jul 2026 17:00:00 +0530

There is a class of bugs that only happen at midnight.

Your API has a rate limit: 1000 requests per minute. A client hits 999 at 11:59:59 PM, then fires another 999 at 12:00:00 AM. Two windows, two clean counters, all 1998 requests allowed. Your database gets a spike it was never designed to handle, and you spend the next hour wondering how your rate limiter let this through.

It did let it through. You just did not know it.

How Multi-Tenant SaaS Actually Works

Wed, 01 Jul 2026 00:00:00 +0530

For the past month I have been reading about multi-tenant SaaS architecture. Not as an academic exercise. I kept running into the same questions on every project I looked at: where exactly does tenant data go, how do you stop one customer’s bug from becoming every customer’s problem, how does billing actually work at the database level. The blog posts I found were either too abstract or skipped the hard parts entirely.

So, We Are Writing Efficient Software Again

Wed, 17 Jun 2026 20:00:00 +0530

I wanted to upgrade the RAM in my PC.

Nothing fancy. I bought 32GB in 2024 and I wanted to double it. I opened a tab, checked the price, and closed the tab. Then I sat quietly for a moment.

The same 32GB kit I bought in 2024 now costs more than double. DDR5 prices have gone up roughly 400% since mid-2025 [1]. DDR4 is not much better. A kit that cost $60–$90 in late 2025 now sells for $150–$180 [2].

Constructing Concurrent Inverted Indexes in Go

Tue, 16 Jun 2026 22:00:00 +0530

I spent a Saturday afternoon benchmarking a concurrent inverted index and discovered that a single sync.RWMutex starts to break down at roughly 4 concurrent readers. The degradation is not linear. It is not graceful. It is a cliff.

The inverted index is one of the oldest data structures in information retrieval. It maps terms to the documents that contain them, forming the backbone of every search engine from Elasticsearch to Lucene to Google’s earliest prototypes. The data structure itself is simple. Making it fast under concurrent load is not.

A Love Letter to the L1 Cache

Mon, 15 Jun 2026 19:00:00 +0530

I recently spent four hours staring at a benchmark that didn’t make sense.

It started while working on Derelict Facility, my grid-based game engine in Go. I was trying to tighten the main update loop, specifically the part that iterates over every entity on the map each frame. I pulled out a small benchmark to isolate the cost, and something looked wrong.

I had two Go structs. They held the exact same data: two booleans and a 64-bit integer. I was iterating over a slice of 10 million of these structs, doing a simple addition. They should have been identical in performance.

Wireless ADB When Your Network Fights You

Mon, 15 Jun 2026 10:00:00 +0530

Wireless ADB keeps timing out if you run a VPN or something like Cloudflare WARP. The issue is that these tools route all traffic through a tunnel and block direct peer-to-peer connections on your local network.

The fix is a one-time USB handshake to tell the device to listen on TCP before you go wireless.

Step 1: USB handshake

Connect your device via USB (USB debugging must be on). Then run:

Why Explaining Technical Difficulty is Hard

Thu, 14 May 2026 01:00:00 +0530

“Can we just add a real-time visitor counter to the homepage? It’s just a query, right”?

Every engineer has heard some variation of this. On the surface, the logic is sound. You have data, you have a UI, and you want to connect them. In the world of business requirements, this is a solved problem. You write a line of code, and the feature exists.

But your database doesn’t care about business logic. It cares about Infrastructure Constraints.

Just About Go Time

Sun, 10 May 2026 22:00:00 +0530

Time is an illusion. Or more accurately, time is a political consensus poorly masquerading as physics.

If you’ve ever seen Dylan Beattie’s “Plain Text” talk, you know that humans have spent centuries making data storage as complicated as possible. But text encoding has nothing on time zones.

As engineers, we like to pretend that time.Now() returns an objective truth. It doesn’t. It returns a snapshot of a highly contested, historically unstable set of political boundaries. In 2011, the island nation of Samoa decided they wanted to align their workweek with Australia rather than the United States. To do this, they didn’t just change their clocks; they completely skipped Friday, December 30th. At 11:59 PM on Thursday, the clock ticked over, and it was suddenly Saturday.

Building a Poor Document Store inside PostgreSQL

Sat, 09 May 2026 22:00:00 +0530

The marketing for “schemaless” architecture was brilliant. It promised speed, agility, and a life free from the tyranny of ALTER TABLE migrations. When PostgreSQL introduced JSONB in version 9.4, many developers saw it as a green light to treat Postgres like MongoDB.

I’ve seen this pattern in dozens of codebases. It starts with a single metadata column, but within months, the entire business logic is buried inside a 2MB JSON blob.

PostgreSQL Migrations in Go: Production Schema Patterns with Goose

Fri, 08 May 2026 22:00:00 +0530

Application code is stateless. You can tear down a container and spin up a new one in milliseconds without losing data. Databases are stateful. When you deploy new application logic that requires a new column, an index, or a table, you must transition the physical storage schema from state A to state B without destroying the underlying data or locking the system.

This process is a database migration. Working with databases is the kind of thing I will gladly skip dinner for (:

Migrating Cloudflare to Terraform

Tue, 28 Apr 2026 14:00:00 +0530

A while back, I was tinkering in the Cloudflare dashboard and accidentally fat-fingered a DNS configuration. I didn’t realize the impact immediately, but I ended up taking down lorbic.com for an hour.

When I scrambled to fix it, I hit a wall: there was no “undo” button. There was no Git history to tell me what the record used to point to, and no review to catch the mistake before I blew it.

Critical Rendering Path Optimization: 8 Proven Strategies to Boost Web Performance

Sat, 11 Apr 2026 16:00:00 +0530

TL;DR: The Critical Rendering Path (CRP) is how browsers convert code into pixels. Optimizing it means reducing bottlenecks at five stages: Network, Parsing, Tree Building, Layout, and Paint. Use this guide to reduce First Contentful Paint by 40-60%, improve Lighthouse scores, and master the eight optimization strategies that separate fast sites from slow ones.

To master web performance, stop guessing and start engineering. View the browser as a single-threaded virtual machine that must convert raw text into pixels 60 times per second. Every performance delay is a bottleneck in the Critical Rendering Path (CRP).

A Tale of Web Vitals

Sat, 11 Apr 2026 14:30:00 +0530

TL;DR: I achieved 95+ Lighthouse scores by removing abstractions and automating browser fundamentals. This guide details how to solve LCP network discovery, main thread congestion, and third-party accessibility traps using Hugo pipelines and vanilla JavaScript.

“Why is the LCP 4.2 seconds? It’s just a static site”.

I was staring at a Lighthouse report that felt like an insult. Lorbic.com is a zero-dependency Hugo site. No React, no heavy frameworks, just vanilla CSS and minimal JS. Yet, the mobile performance was tanking.

Why Your Goroutines Need a Speed Limit: Bounded Concurrency in Go

Fri, 10 Apr 2026 10:00:00 +0530

TL;DR: Spawning go func() without a limiter is a recipe for system collapse. This guide details how to use Semaphores and Worker Pools to prioritize predictable stability over absolute speed, protecting downstream dependencies from the thundering herd.

It’s a rite of passage for every Go developer. You receive a list of 10,000 URLs to fetch or 50,000 rows to process. You wrap the workload in an unbounded go func() loop, achieving maximum throughput in milliseconds.

Part 3: Casting Shadows Without Trigonometry: The Beauty of Integer Math

Tue, 07 Apr 2026 10:00:00 +0530

At the end of generating a procedural map for the Derelict Facility engine, I had a sprawling interconnected maze of rooms and corridors. But there was a devastating problem: I could see everything.

The entire map was rendered at once. It looked like a top-down blueprint, not a dark, atmospheric facility. I needed to implement Fog of War. I needed to treat the player character like a lighthouse in the dark.

Part 2: Decoupling the Renderer: Terminal to Raylib in One Interface

Mon, 06 Apr 2026 10:00:00 +0530

The biggest architectural mistake you can make when building a game engine is letting the game know how it is being drawn.

When I started building the Derelict Facility engine, the output target was a raw ANSI terminal. The engine calculated A* paths, resolved line-of-sight, and then spewed escape codes (\033[31m) to os.Stdout.

Eventually, I hit the physical limits of terminal emulators: inconsistent character widths (especially for emojis), slow double-buffering, and a hard cap on frame rates. I needed to move to a real, hardware-accelerated graphics library like Raylib.

Part 1: Data-Oriented Design in Go: Why [][]Tile Destroyed My Game Engine

Sun, 05 Apr 2026 10:00:00 +0530

Most game development stories start the same way: install Unity, drag some sprites onto a canvas, and press Play.

I wanted to understand the metal. I set out to build Derelict Facility, a systems-level game engine from scratch in pure Go. No SDL, no OpenGL wrappers, no Ebiten. The goal wasn’t just to ship a game; the goal was to learn the memory layouts and I/O pipelines that modern engines hide behind friendly APIs.

10 years of lorbic.com architecture

Thu, 02 Apr 2026 12:00:00 +0530

This post tracks four architectural rewrites of my personal site over ten years: moving from managed platforms (Blogger) to dynamic backends (Django), static site generators (Jekyll/Hugo), and finally to a custom, zero-dependency architecture built for absolute control and performance.

Technical Context

For an engineer, a personal site is the only project where you have absolute authority over the stack. There are no product managers, no legacy constraints, and no enterprise technical debt: you own the metal.

Kubernetes on WSL2 and the macOS tunnel

Wed, 01 Apr 2026 22:00:00 +0530

TL;DR: I run k3s on a Windows gaming PC via WSL2 to master Kubernetes networking without cloud costs. This guide details a secure access model using SSH and kubectl port-forward to bypass NAT boundaries and maintain technical sovereignty.

This guide omits Kubernetes feature tutorials. Instead, it details how to architect an environment where Kubernetes can exist without auxiliary hardware, idle cloud bills, or hidden networking realities.

I wanted to learn Kubernetes properly, which meant understanding how scheduling, access paths, and network boundaries behave under real constraints. The problem was simple: I lacked a reasonable execution environment.

ClickHouse data masking with regex

Tue, 31 Mar 2026 22:30:00 +0530

If you’re running a production observability stack, you’ve already leaked PII. An engineer forgot to redact an email in a log line, or a JWT token ended up in a stack trace.

In most databases, the only fix is to DELETE the data—killing your metrics along with the sensitive info. But ClickHouse has a more elegant approach: Data Masking Policies.

By defining a policy at the role level, you can use regex to swap sensitive patterns with [REDACTED] in real-time, before the query results even leave the server.

Understanding CPU Caches in Go

Tue, 31 Mar 2026 22:15:00 +0530

When you’re building Go services that handle millions of operations per second, the hardware beneath your abstractions starts to matter. Specifically, the CPU cache hierarchy, and whether your data fits in it.

The Hardware Context: It’s Not Just “RAM”

Your server has 32GB or 64GB of RAM, but the CPU avoids touching it whenever possible. Instead, it works through a chain of caches:

ClickHouse vs. Postgres: When to Move Your Logs Out of a Relational DB

Mon, 30 Mar 2026 22:45:00 +0530

Postgres is the most reliable tool in my stack. It handles users, configurations, and complex relations without breaking a sweat. But databases, like any physical system, have a “design limit”. For Postgres, that limit usually appears when you try to use it as a dumping ground for high-velocity logs and metrics.

When your ANALYZE commands start taking minutes and your indexes consume more RAM than your data, you aren’t facing a Postgres bug; you’re facing an architectural mismatch.

WSL2 Is Slow? Fix /mnt/c/ File System Performance & Go Latency

Sun, 29 Mar 2026 22:30:00 +0530

WSL2 (Windows Subsystem for Linux) has been a godsend for developers who love Linux tools but need/have a Windows environment. But for Go developers, WSL2 isn’t just a “transparent layer”. If configured incorrectly, it becomes the bottleneck that can slow down builds by 3x and introduce mysterious latency in networked services.

This isn’t a failure of WSL2; it’s a failure of understanding the 9p boundary.

Glossary // What is the 9P Boundary?

WSL2 is a Virtual Machine. To let that VM see your Windows files, Microsoft uses the 9P protocol (Plan 9).

AI Coding in 2026: Productivity Multipliers vs. Skill Replacements

Sat, 28 Mar 2026 23:00:00 +0530

“Write a REST API with authentication”.

I hit enter. Thirty seconds later, Claude spat out 400 lines of perfectly formatted Go code. JWT middleware, password hashing, error handling, even rate limiting. It looked professional. It looked production-ready.

It took me three hours to figure out why the token refresh logic had a race condition.

This is AI-assisted coding in 2026. It’s not magic. It’s not a replacement. It’s a very fast junior developer that never gets tired, never complains, and confidently makes mistakes you won’t catch unless you actually understand the architectural nuances of what you’re building.

Fast Docker CI: Stop Rebuilding Container Images on Every Commit

Sun, 15 Feb 2026 02:30:00 +0530

I used to rebuild my Docker image every time I fixed a typo. A one-line change meant waiting 2-3 minutes for Docker to rebuild layers, reinstall dependencies, and restart the container. I thought this was just the cost of containerized development.

Then I discovered runtime containers. Same isolated environment, same reproducibility, but code changes reflect instantly. No rebuilds. No waiting. The runtime lives in the container, the code lives on the host.

Python Background Workers: Architecture, Queues, and Retry Strategies

Sun, 01 Feb 2026 13:00:00 +0530

I thought processing audio in the background was simple: spawn a thread, run the script, save the file. Then I hit 200 concurrent requests, and it failed epically.

The CPU spiked to full usage because of pydub’s processing. The TTS API didn’t rate-limit me but, it was horribly slow. Then the jobs started failing. Half the jobs died silently. The other half wrote corrupted files because of race conditions I didn’t know existed. And when I deployed a little fix? The deployment killed in-flight jobs, leaving orphaned audio segments scattered across cloud storage directory.

Go Struct Field Alignment: How Memory Padding Wastes Your RAM

Sat, 24 Jan 2026 10:00:00 +0530

You write a struct to represent a database entity. Maybe 10 fields, maybe 20. What could possibly go wrong?

Nothing, according to your tests. But somewhere in production, your heap is 30% larger than it should be, your Garbage Collector is working overtime, and your L1 cache is not used properly. The reason? Invisible padding bytes silently inflating every instance of your struct.

This is the story of struct field alignment: a memory optimization that costs nothing to implement but can significantly improve performance.

I Added Session Management to Aider

Thu, 15 Jan 2026 20:30:00 +0530

I’ve been using aider as my primary AI coding assistant for a while now. It’s the one tool that actually fits my workflow: terminal-based, Git-native, and it works directly on my local files. No copy-pasting into web forms. No context windows that forget everything. And not waiting for agents to keep thinking.

But it was missing one thing that drove me crazy.

The Problem: Context Evaporates

Here’s the scenario. I’m deep into a complex refactor. I’ve added 15 files to the chat, built up tons of context with the model, and we’re making real progress.

Can ClickHouse Replace Vector Databases? HNSW, Benchmarks & SQL Setup

Wed, 14 Jan 2026 20:00:00 +0530

Everyone’s building AI apps now. And every AI app needs a place to stash embeddings. The instant your data grows beyond “fits in memory”, you need a vector database. Or do you?

If you’re already running ClickHouse for analytics, here’s some good news: you might not need another database. ClickHouse can hold its own as a vector store. Not because it was built for it, but because it’s built to be fast at everything.

Memory Mechanics In Go - Stack vs Heap

Mon, 12 Jan 2026 00:10:00 +0530

We often talk about “fast” code in terms of Big O notation or algorithmic complexity. But in systems programming languages like Go, “fast” is often a function of where your data lives in memory.

When optimizing for high throughput, efficient loops and database indexes are only part of the story. Eventually, you have to talk about the Stack and the Heap.

Understanding the difference isn’t just trivia. It is the difference between a service that hums along at 100k OPS with flat latency, and one that chokes on Garbage Collection (GC) pauses every few seconds.

OLTP vs OLAP - Why You Need Two Databases

Sun, 11 Jan 2026 21:00:00 +0530

At a recent ClickHouse conference in New Delhi, I attended this Saturday. There were many interesting sessions, but one that stood out was a talk on multi-tenant analytics at scale. I was reminded of a fundamental truth in backend engineering: “The database that runs your app cannot be the database that analyzes your app”.

Early in a startup’s life, we shove everything into one database. User profiles, session data, logs, and analytics events all live in the same Postgres, Mongo, or Couchbase instance. It works, until it throttles.

Go Garbage Collector Mechanics: Pacer, GOGC, and Allocation Latency

Wed, 07 Jan 2026 00:21:12 +0530

In the world of high-throughput backend services, we often obsess over the usual suspects of performance: database indexing, network latency, and algorithmic complexity. But recently, while debugging our core gateway service (backend-gw), I encountered a bottleneck that defied standard logic.

The service was CPU-bound, yet active heap usage was surprisingly low (~200MB). P99 latency was spiking at random intervals, but database queries were returning in milliseconds.

The culprit was not the business logic. It was memory management. I was effectively running a Denial-of-Service attack on my own runtime.

Introducing CouchLens: A Query Analysis Tool for Couchbase

Sun, 28 Dec 2025 20:00:00 +0530

CouchLens is a client-side web application for analyzing Couchbase N1QL query performance. You feed it JSON exports from system:completed_requests, system:indexes, and schema inference results. It parses execution plans, computes metrics, detects inefficiencies, and generates a report showing where your queries are slow.

Everything runs in the browser. No data leaves your machine. The tool is a Progressive Web App, so you can install it and use it offline. The goal is to give database administrators and developers a way to understand query behavior without writing custom scripts or debugging raw JSON.

What Couchbase Taught Me About System Thinking

Tue, 18 Nov 2025 02:20:06 +0530

Couchbase Internals: Indexes, Queries, Consistency, and Performance

Introduction

Over the last few years I’ve lived deep inside backend systems, and for the past year and a half Couchbase has been my daily companion. Working with Go services that depend on Couchbase taught me that the real lessons aren’t in the marketing slides or quick‑start guides. They’re in the internals: how indexes are built, how queries are planned, how consistency flags change the story, and how durability levels quietly decide whether your system survives a failure or not.

Understanding Private-Public Key Encryption

Thu, 06 Nov 2025 22:01:23 +0530

In today’s digital world, where secure communication, authentication, and data integrity are non-negotiable, private-public key encryption (also called asymmetric cryptography) plays a foundational role. From HTTPS in your browser to SSH logins, cryptocurrency wallets, and email encryption, this elegant cryptographic system enables trust without prior shared secrets.

In this blog, we’ll dive into:

The core concepts behind asymmetric encryption
How it differs from symmetric encryption
The mathematics (intuitively explained) behind popular algorithms like RSA and ECC
Real-world examples and code snippets
Common use cases and pitfalls

Whether you’re a curious beginner or a seasoned developer brushing up on fundamentals, you’ll find something valuable here.

The 5-Minute Refactor

Tue, 28 Oct 2025 02:01:23 +0530

The 5-Minute Refactoring Guide

As experienced software engineers, we often face a dilemma: our codebases, like all physical systems, trend toward entropy. The gap between “getting it done” and “getting it right” grows, leading to sluggish feature delivery and inevitable technical debt. The solution isn’t a massive, heroic rewrite; it’s the disciplined, humble practice of Kaizen, or continuous improvement.

For Golang engineers, this translates to the 5-Minute Refactor: a daily commitment to making one tiny, tangible, quality improvement to any code you touch. This practice leverages Go’s philosophy of simplicity to prevent decay and sharpen your engineering judgment, all in less time than it takes to make coffee.

I Built My Own Google Drive

Wed, 01 Oct 2025 02:02:23 +0530

Why Bother?

Whenever I want to download a folder from Google Drive, it starts zipping it for what feels like minutes, and then it downloads the whole zip. There’s no incremental download, and I can’t add it as a network drive for obvious reasons. These limitations are frustrating, but they also got me thinking: what if I could have a solution that’s more flexible, more customizable, and truly mine?

How to Resolve Huge Git Merge Conflicts Without Losing Your Mind

Thu, 17 Jul 2025 20:56:00 +0000

How to Resolve Huge Git Merge Conflicts Without Losing Your Mind

If you’ve ever been knee-deep in a long-lived branch merge and thought, “this can’t be what version control was meant for”, you’re not alone. Git gives us powerful tools, but resolving large merge conflicts, especially during major migrations or rewrites can feel like surgery without anesthesia.

In this post, we’ll walk through how to approach and resolve massive merge conflicts systematically. Not with hand-wavy advice, but with actual steps, real mental models, and clear visual understanding.

What Facebook's Memcache Taught Me About Systems Thinking

Mon, 07 Jul 2025 14:03:00 +0000

What Facebook’s Memcache Taught Me About Systems Thinking

“The probability of reading transient stale data is a tunable parameter”. - Scaling Memcache at Facebook (NSDI, 2013)

There’s a moment in every engineer’s life when a seemingly simple component like a cache, suddenly becomes the most complex piece in the stack. For me, that moment arrived reading Facebook’s paper on scaling Memcache. I didn’t expect a key-value store to challenge my understanding of systems architecture. But this paper wasn’t about cache keys or TTLs. It was about what happens when infrastructure hits the limits of scale, physics, and human reliability.
What follows isn’t a summary. It’s a set of systems insights that stayed with me, principles that go deeper than code and that I now see everywhere.