Notes on AI that go past the demo: how the models work, where they break, and what changes once you put them in production.
Articles
Everything that isn't a tutorial or a lab: explainers, opinions, and notes from building things.
Sub-series
The concepts every language shares: variables, control flow, functions, and syntax. Learn them once and the next language is mostly vocabulary.
Algorithms and data structures are the part of programming you can't skip. They decide whether a solution to a hard problem is fast enough to be worth anything. This series goes through the usual structures and algorithms, what each one costs, and where it earns its place.
Articles
How's JavaScript Doing? The State of JS 2022 Results Are In
The State of JS 2022 survey is out, and the respondent count jumped hard. Which frameworks and build tools actually stole the year?
Make PowerShell More Colorful with Starship
Tired of PowerShell looking black, white, and stiff? Turn your terminal into something interactive, aesthetic, and colorful with Starship!
Things to Consider Before Switching to Linux
Tempted to migrate from Windows to Linux but still unsure? Learn the upsides, the downsides, and the prep you need before you actually switch.
Why Are There So Many Linux Distros?
Were you confused when installing Linux handed you dozens of distro options? You're not alone. Here's why there are so many, and what actually differs.
Using TypeScript with Node.js and Express
Want to build an Express server on Node.js but use TypeScript's nicer features? Here's the complete setup from scratch.
Asynchronous Programming vs Multithreading: What's the Real Difference?
You keep hearing asynchronous and multithreading while coding, but the difference stays fuzzy? Let's take it apart with an instant-noodle analogy you can follow.
React, Angular, or Vue: Which Framework Should You Pick?
Stuck choosing between React, Angular, and Vue for your next web project? Here's a side-by-side look at what each one actually does well.
Static Typing vs Dynamic Typing: What's the Difference?
Ever wondered why Java makes you declare a type while Python just takes the value? Here's the difference between static typing and dynamic typing.
Tailwind v3.0 Is Out: JIT, Arbitrary Values, and Plenty More
Tailwind CSS v3.0 shipped with a pile of performance upgrades that make styling more fun. Which features are worth trying first?
TypeScript: JavaScript with Style and Static Types
Tired of runtime errors in JavaScript? Meet TypeScript, which brings static typing so your code stays tidier and safer.
What's New in Nuxt 3: Nitro Engine, Vite, and Other Sharp Features
Nuxt 3 brings a sweeping architecture change to line up with Vue 3. Here's what got faster and which new features are worth trying.
Why Use FastAPI, and Why Is It So Fast?
You keep hearing about FastAPI but still wonder how it can keep pace with NodeJS and Go? Let's take apart ASGI, the Pydantic magic, and the automatic docs.
Why Do You Need Rate Limiting?
Has your login endpoint ever been hammered by a bot trying thousands of passwords in a single minute? Here is why rate limiting is mandatory, and how to wire it into FastAPI.
Why an Event Queue Keeps Your Backend From Collapsing
You hit Buy Now and the success notice appears instantly, while an invoice, an email, and a push notification still have to be built behind the scenes. The secret is the event queue.
REST API vs gRPC: When Should You Start Moving Off JSON?
Has your microservice system started feeling heavy even though it only shuffles internal data? The server may not be the problem. Here is when REST + JSON still wins, and when gRPC is the answer.
Background Workers & Task Queues: Don't Run Heavy Work Inside an HTTP Request
You tap Create Account and the loading page spins for 15 seconds with no answer? The cause is classic. Here is why heavy work does not belong in an HTTP request.
Taming the N+1 Query Problem: The Hidden Enemy of Backend Performance
You built an endpoint that only lists 50 posts with their author names, and the response takes 2-3 seconds? You may have hit N+1 Query. Here is the cause, and the cure.
Understanding Database Indexing: The Secret to Very Fast Queries
Your queries have gone sluggish even though the data only just crossed a million rows? Before you rush to upgrade the server, check the indexes. Here is how database indexing actually works.
Getting to Know Redis: More Than Just an In-Memory Cache
Still treating Redis as nothing but a cache? It can be a leaderboard, a message broker, even a rate limiter. Let's take apart everything it can do.
Docker Compose for the Relaxed Developer: One Command to Run Every Service
Do you keep retyping docker run just to bring up the web app, the database, and the cache one at a time? Here is how to fold all of them into one file and one command.
Meet RabbitMQ: The Versatile Message Courier
You tap Pay Now and the success notice appears instantly, while the confirmation email only lands a few seconds later? The secret is one invisible courier. Meet RabbitMQ.
Why Does a Backend Need Database Connection Pooling?
Ever hit Too many connections while server CPU is still lounging at 30%? The problem is not your queries, it is how the application talks to the database. Meet connection pooling.
Idempotency Keys: The Secret to No Double Charges in Payment APIs
Ever had your connection stall right as you hit Pay, then panic-clicked three times? If the endpoint is not idempotent, the balance can be cut more than once. Meet the idempotency key.
Stopping the Domino Effect in Microservices With the Circuit Breaker Pattern
Ever had one minor feature go slow and take the checkout page and login down with it? That is a cascading failure. Here is how the circuit breaker pattern saves your architecture.
Why Does a Backend Need Graceful Shutdown? Don't Yank the Server Cable
You deploy the backend and seconds later monitoring floods with 502 Bad Gateway alerts. The balance was cut but the order status never reached the database. Here is why graceful shutdown is mandatory.
Optimistic vs Pessimistic Locking: Handling the Data Fight in a Database
A thousand people tap Buy Now in the same second, fighting over the last ticket. What happens on your server? Here is pessimistic against optimistic locking.
Database Sharding vs Partitioning: When Does Data Need Splitting?
Your transaction table has crossed a billion rows and every report query spikes CPU to 100%? Before splitting data blindly, understand the difference between sharding and partitioning.
Inside Distributed Tracing: Following a Request Through Microservice Chaos
One Checkout click in your backend can trigger dozens of network calls between services, but when one is slow, which service is at fault? Logs alone cannot answer that. Here is distributed tracing.
Modern Log Aggregation With Grafana Loki and Vector: Save Storage Without a Giant Index
Your Elasticsearch cluster is greedy for RAM and wasteful with storage? Not every word in a log needs indexing. Meet the duo of Grafana Loki and Vector, far kinder to your wallet.
Rate Limiting Algorithms: Token Bucket vs Leaky Bucket vs Sliding Window
You already know why rate limiting is mandatory, but the difference between Token Bucket, Leaky Bucket, Fixed Window, and Sliding Window is still fuzzy. Let's put all four algorithms side by side and find the one that fits your API.
Why C Is Being Left Behind: Rust's Safety Philosophy vs Zig's Simplicity
Have you heard that around 70% of critical security holes in modern software come from C? Yes, the language the internet is built on. Let's unpack the philosophy duel between Rust and Zig and see which one fits your project.
How You Use AI Matters More Than Whether You Use AI
The feature is done, the tests are green, and two days later you read the code like a stranger wrote it. It turns out one way of using AI leaves you understanding more than not using AI at all. Here is the data.
At 11 a.m. the AI Quota Runs Out, and the Work Stops There
The panel says the usage limit is reached and the work stops, not because it is finished. Three guesses explain it, and all three are wrong: the limit is shaped like a cliff, and the day is built on top of one tool.
State of JS 2025 Says Developers Use Only 2.6 Frameworks in a Whole Career
Try counting every framework you have ever touched, then cut the list down to what you actually used for work. It comes out far shorter than you would guess. State of JS 2025 asked 13,002 developers, and the average is only 2.6.
When You Pick a Framework Just to Look Different
The last time you chose a new framework or library, was it because your problem needed that tool, or because it sounded cool and few people around you were using it? That question is uncomfortable. Technology decisions are often made for reasons that never appear in any technical document.
Rust Enters the Linux Kernel: A Real Revolution or Just RIIR Euphoria?
For more than 30 years the Linux kernel only wanted C, then Rust officially landed in Linux 6.1. Is that a real revolution, or just the pull of the Rewrite It In Rust meme? Let's look at the data, not the opinions.
Your App Is Slow, and You're Already Thinking About Changing Languages. Wait.
An endpoint spikes every few minutes, and you are thinking of moving from Go to Rust? Discord and Cloudflare really did it, but only after running out of other options and having the data. Let's sort out which symptoms need a rewrite and which only need a profiler.
The Garbage Collector Gets Blamed for Slow Apps. How Fair Is That?
GC is always the prime suspect when an app slows down, and many people believe it runs on a timer every few seconds. Both beliefs are only partly right. Let's open up how GC works inside, plus one exception that made Discord hurt every 2 minutes.
Learning Idempotency from Stock That Got Bought Too Soon
My first task at my first job was a system drowning in webhooks. I decided to build my own pub/sub from scratch, and the lesson that finally landed came from somewhere else: warehouse stock that got bought before the count caught up.
The Secret of Zero-Cost Abstractions in Rust, Opened Up from the Assembly
"Higher abstractions are always slower" is an old assumption. Rust iterators can match a hand-written loop, and the assembly is there for you to read. Let's take it apart.