Posts 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.

Nobody Will Read This

Mon, 22 Jun 2026 00:05:00 +0530

There is a funny truth in software engineering: almost nobody reads the docs.

We spend hours writing careful comments in our code. We build personal websites. We write plain text files and push them to live servers. But if we check the stats, we know the truth. The audience is basically zero.

So why do we do it?

My day is full of loud noise. It is filled with heavy backend logic, endless tasks, and the crushing weight of non-stop engineering. The pressure is always on. The systems never sleep. It is exhausting.

What is DRY? (And Other Things We Say at 3 AM)

Mon, 22 Jun 2026 00:00:00 +0530

There is a famous programmer joke that always gets me:

“What is DRY? Well, at the risk of repeating myself…”

It is funny, but it also hurts a little because it is so true. We all know the rule: Don’t Repeat Yourself (DRY). We learn it from day one. You write a piece of code once, put it in a clean function, and never type it again.

But let’s be honest. It is the middle of the night. You are staring at your screen, your eyes hurt from the light, and you just need the server to stop crashing. What really happens? You copy that block of code from another file. You paste it right where you need it. You change one variable, save the file, and quietly hope nobody looks too closely.

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.

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.

Internet Graveyard

Mon, 27 Apr 2026 00:00:00 +0000

Filter by Era/Domain:

Google Reader

2005 - 2013 Services

Cause of Death

Strategic shift towards Google+; lack of direct monetization. Proved that RSS was for power users, not the masses.

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.

My Reading List

Thu, 02 Apr 2026 00:00:00 +0000

Design

Knitting Bullshit by Kate Davies

Kate Davies' blog.

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?

Introducing Quark

Tue, 23 Sep 2025 02:02:23 +0530

Quark: A Minimal Note-Taking System

A few months ago, I was in a meeting where the conversation was moving at lightning speed. Updates, critical decisions, all flying around the room. I opened my laptop, ready to take notes in Notion, but within minutes I was lost. Too many clicks, too much formatting, and many annoying boxes. By the time I found the right template. I had already missed half of the discussion.

Why Your Password Habits Will Get You Hacked

Wed, 13 Aug 2025 00:00:00 +0000

The Real Cost of Digital Laziness

We’ve built our entire lives on top of fragile passwords.
Most people treat them like they treat dental checkups, ignore it until something hurts. By then, it’s too late.

The numbers are not on your side. Every password you’ve ever created has probably been leaked in some breach you’ve never heard about. It doesn’t matter that the breach was from a forgotten forum you joined in 2012; attackers don’t forget. They run automated “credential stuffing” attacks across every major platform, testing your old passwords against your bank, your email, your cloud storage. One lazy reuse, and they’re in.

Stealth VPN with Outline over HTTPS

Tue, 12 Aug 2025 00:00:00 +0000

What We Are Doing

If you are somewhere that blocks VPNs through deep packet inspection (DPI), SNI filtering, or crude port blocking, the goal is to make your VPN traffic look as boring as possible.
The quick win is to put it on port 443, the same port used by HTTPS. That is the lifeline of the modern web, so most firewalls are reluctant to block it.

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.

Bitmasking In Go

Thu, 17 Apr 2025 02:20:00 +0000

Bitmasking in Go

Bitmasking is one of those computer science tricks that feels like wizardry, until you realize it’s just some clever shifting and binary math. This blog explores the idea, shows how we use it in Go, and why it’s surprisingly useful when working with databases like Couchbase.

What’s Bitmasking?

A bitmask is just an integer where each bit (0 or 1) represents a flag or state. Instead of storing multiple booleans in a slice or map, you cram them into a single int. Fast to compute, fast to store, and great for indexing.

Docker Volume Backup: The 1-Line Command You Should Be Using (Instead of tar)

Sun, 13 Apr 2025 07:14:00 +0000

How to Backup and Restore Docker Volumes Between Machines

When working with Docker, persistent data is often stored in volumes. Unlike container filesystems, volumes survive restarts and recreations. But what if you need to move this data from one machine to another?
Here’s a quick and reliable way to back up a Docker volume on one computer and restore it on another.

Testing Types

Tue, 11 Mar 2025 09:32:00 +0000

Understanding different types of software testing is crucial for delivering a reliable application. Smoke Testing checks basic stability after a new build, while Sanity Testing verifies specific bug fixes or minor updates. Functional Testing ensures that features work as expected based on business requirements. Regression Testing prevents new changes from breaking existing functionality. End-to-End (E2E) Testing simulates real-world user workflows, and Performance Testing checks system speed, load handling capacity, and responsiveness. Implementing these (some or all) test types helps maintain software quality and prevent critical failures.

Tools I Use on My Mac

Mon, 10 Mar 2025 16:44:00 +0000

Tools I Use on My Mac

As a new Mac user, it has been a tough journey getting used to limitations of macOS compare to linux based os. I rely on a set of carefully chosen tools to improve productivity, streamline workflows, and make my overall experience less frustrating. Here’s a look at top 20 essential apps I use daily:

System & UI Enhancements

1. Scroll Reverser

Allows me to reverse the scrolling direction for trackpads and mice independently, making navigation more intuitive.

Understanding T and *T method receivers in Go

Sun, 23 Feb 2025 04:33:00 +0000

In Go, method receivers determine whether a method acts on a copy of a value or a reference to it. This choice isn’t just about performance; it affects correctness and behavior, especially when dealing with synchronization primitives (mutex, wait group, etc), slices, and embedded types.

In this post I explore when to use T (a value receiver) vs. *T (a pointer receiver) and why, in most cases, pointer receivers should be the default and preferred.

Analysis Paralysis in Engineering Teams

Mon, 10 Feb 2025 22:54:00 +0000

Analysis Paralysis in Engineering

In engineering, progress is key. However, sometimes teams get stuck in endless discussions, over-planning, and constant changes, delaying actual work. This situation is called “Analysis Paralysis.” It happens when people focus too much on making perfect decisions instead of moving forward with practical solutions.

Go Clean Code Guidelines

Sun, 22 Sep 2024 15:22:00 +0000

Go Clean Code Guidelines for Code Quality and Maintainability.

When it comes to writing clean, maintainable code, there are a few fundamental rules that can help improve the overall structure and quality of your codebase. As engineers, our goal should be to keep things simple, clear, and scalable. With this in mind, here are some guidelines which prioritize code readability, functional clarity, and the overall maintainability of a project. These guidelines are based on principles from clean code, SOLID, and functional programming while emphasizing simplicity over unnecessary complexity.

SOLID and Functional Programming Principles in Go

Sun, 22 Sep 2024 00:03:00 +0000

Let’s go through the SOLID principles and functional programming principles that can apply to your Go codebase. I’ll provide simple Go examples along with brief explanations to show how each principle can improve code quality.

SOLID Principles

Single Responsibility Principle (SRP)

Description: A class or function should have only one reason to change, meaning it should only have one job or responsibility.

Example:

 1// Good: Separate responsibilities into two functions
 2type EmailSender struct{}
 3
 4
 5func (e *EmailSender) SendEmail(to, subject, body string) {
 6 // logic for sending email
 7}
 8
 9
10func formatEmailBody(template string, data map[string]string) string {
11 // logic for formatting the email body
12 return ""
13}
14
15
16// Avoid: Single function doing multiple jobs
17func sendFormattedEmail(to, subject, template string, data map[string]string) {
18 body := formatEmailBody(template, data)
19 // email sending logic mixed with formatting
20}

Open/Closed Principle (OCP)

10 Essential Tips for Beginners Starting in IT

Fri, 23 Feb 2024 18:59:55 +0000

Are you new to IT? Feeling a bit overwhelmed? Don’t worry, I’ve got you covered! In this article, I’ll share 10 essential tips to help you get started on your journey in Information Technology. From mastering the basics to gaining hands-on experience and staying curious, these tips will set you on the right path. Let’s dive in and start the IT adventure!

NGINX: Building from Source and Installation on Linux (Updated)

Fri, 02 Feb 2024 18:28:00 +0000

NGINX is a web server that can also be used as a reverse proxy, load balancer, mail proxy and HTTP cache. NGINX is a free and open source software licensed under 2-clause BSD.
You can easily download and use NGINX in Windows, macOS, Linux and other operating systems link read NGINX installation instructions from the official docs and install on your operating system for free.

But, in this blog we are going to build NGINX from source code. And we will configure NGINX’s settings, paths, and add or remove modules.

How to Install Docker Desktop on Another Drive in Windows

Sat, 27 Jan 2024 13:11:47 +0000

Docker Desktop on Windows installs to your C: drive by default. When you pull large images (often 1.5GB each), add build layers, and stack containers, the ext4.vhdx file that holds all your container data bloats fast. This guide shows you how to route Docker to a secondary drive entirely, using CLI flags instead of the GUI.

Quick Start

Uninstall any existing Docker first. Then open PowerShell as admin and navigate to your Downloads folder where the installer is. Run:

Build a URL redirector application with Cloudflare Workers and Cloudflare D1

Sun, 07 Jan 2024 09:04:43 +0000

In today’s fast-paced digital world, where attention spans are short, optimizing website performance and user experience is crucial. Imagine asking someone to visit a lengthy URL (https://lorbic.com/setting-up-llama-2-with-docker-on-your-gaming-laptop-using-ollama/) – their reaction might be a disappointed face (🙁). Typing such URLs can lead to errors, resulting in users landing on a dreaded 404 page.

Setting Up Llama 2 with Docker on Your Gaming Laptop Using Ollama

Sat, 02 Dec 2023 13:40:01 +0000

This article is simple guide on setting up Llama 2, a powerful large language model, on your gaming laptop using Docker and the Ollama platform. Ollama makes it very easy to run many LLMs locally. In this detailed article, I’ll cover each step, such as Ollama installation and ease of interaction through a Chat GPT-like UI. Before we go into the technical details, let’s understand what a large language model is.

AWS - Host Static Website With S3 + Cloudfront + Route53

Sun, 07 May 2023 15:14:24 +0000

In this blog I’ll discuss how to host a static website on AWS with S3, CloudFront and Route 53. We will secure our website with SSL certificate generated from Certificate Manger, enable HTTP/2 and HTTP/3 and redirect insecure http traffic to https version of the website. We will also make our bucket private and add policy to allow access from CloudFront.

Simplifying Search Activation: A Quick Guide with JavaScript

Sat, 01 Apr 2023 08:28:39 +0000

Learn how to enhance user experience by activating the search input field with a simple key press on your website. This quick guide provides a code snippet and easy-to-follow steps.

1. HTML Markup for Search Input:

html

 1<form>
 2 <input type="text" id="search-input" placeholder="$ grep...">
 3</form>
 4
 5<!-- If you have a button to activate the search field like in this website -->
 6<li class="search-icon">
 7 <a href="javascript:void(0)" id="search-button">
 8 <i class="fa fa-search"></i>
 9 </a>
10</li>

2. JavaScript Functionality:

Activate the search input field by pressing a key (in this example, the ‘/’ key). Modify the key binding according to your preferences.

Setting Up a PostgreSQL Container: A Quick Guide

Sat, 01 Apr 2023 06:41:46 +0000

Learn the simple and fast process of creating a PostgreSQL container using Docker. This guide provides both the command and a detailed explanation of the container and PostgreSQL database configuration.

1. Create the PostgreSQL Container:

shell

1docker run -d --name postgres \
-e POSTGRES_PASSWORD=RunningFlying2 \
-e PGDATA=/var/lib/postgresql/data/pgdata \
-v postgres_data:/var/lib/postgresql/data \
-p 5432:5432 \
postgres:latest


2. Explanation:

The above command initiates the creation of a container with the latest version of PostgreSQL. Here’s a breakdown of the parameters used:

Learn Dart Programming

Wed, 12 May 2021 16:28:00 +0530

Good Evening, Here are the Hands-on notes for Dart Programming Language. I created these notes when I was learning Dart Language. So, these notes might help you too. You can use these notes as a quick reference to Syntax and Demo. I’ve covered almost every fundamental concept of Dart in this article.

Photo by Birmingham Museums Trust

1. Basics

1.1 The Main Function

Every Dart program starts execution from main() functions.

Types of Pointers in C/C++

Wed, 12 May 2021 16:16:41 +0530

Photo of Hyacinth macaw by Roi Dimor on Unsplash

Types of Pointers in C / C++

1. Null Pointer

It is a pointer pointing to nothing. NULL pointer points to the base address of the segment.

-EXAMPLE-

1int * ptr = (int) * 0;
2float * fptr = (float) * 0;
3double * dptr = (double) * 0;
4char * chptr = (char) * 0;

Other ways of initializing NULL pointer

1int * ptr = NULL;
2char * chptr = '\0';

NULL also means 0 in macro
c
1#define NULL 0

2. Dangling Pointer

A pointer pointing to the memory address of any variable (or object) which has been deleted from memory.
When a pointer points to a deleted memory address, the pointer is called as a dangling pointer.

Avoid Memory Leaks In C++

Tue, 04 May 2021 01:24:39 +0530

Instructions

Things You’ll Need

Proficiency in C++
C++ compiler
Debugger and other investigative software tools

Part 1

Understand the operator basics. The C++ operator new allocates heap memory. The delete operator frees heap memory. For every new, you should use a delete so that you free the same memory you allocated:

cpp

1char* str = new char [30]; // Allocate 30 bytes to house a string.
2delete [] str; // Clear those 30 bytes and make str point nowhere.

Part 2

Reallocate memory only if you’ve deleted. In the code below, str acquires a new address with the second allocation. The first address is lost irretrievably, and so are the 30 bytes that it pointed to. Now they’re impossible to free, and you have a memory leak:

Operators in Bash Shell Programming

Tue, 04 May 2021 01:16:10 +0530

Photo by NASA on Unsplash

If you want to learn bash bash scripting please read this article.
Learn complete Linux bash (shell) scripting in one article

Operators help us perform various types of operations such as addition, multiplication etc.
There are following types of operators present in bash:

Arithmetic,
Relational,
Boolean,
File Test,
String Test

1. Arithmetic Operators

All the arithmetic operators present in bash are discussed below with examples.
These operators work with integers.

Learn Complete Linux Bash Scripting in One Article

Tue, 04 May 2021 00:59:14 +0530

– Photo by Iván Rivero from Pexels

In this article I’ll be discussing about linux bash scripting (shell scripting) and I will cover every fundamental concept that you need to get started with bash scripting under linux environment.
Bash scripting is a critical skill for every programmer.

First of all you will need a linux machine to execute these scripts.
You can use any of the below techniques to get a linux machine:

Access Wsl Filesystem From Windows 10 File Explorer

Tue, 04 May 2021 00:52:26 +0530

If you want to get Linux environment in your Windows system there are some solutions that provide the opportunity.
For example MYSYS, CYGWIN and a Virtual Machine (If you want complete linux machine) or Multiple Boot.
But some of them aren’t much powerful and some are resources hungry like Virtual Machine.
So, the solution is WSL (Windows Subsystem for Linux).
You can learn how to setup WSL from here.