Loading...
Insights, tutorials, and deep dives into the world of technology.
How I got past the fear of my first pull request, found projects worth contributing to, and learned to read unfamiliar codebases without drowning.
What edge computing actually means beyond the marketing, the latency math that makes it matter, and when Cloudflare Workers beats Lambda at its own game.
Why grepping through log files stops working at scale, the real difference between logs, metrics, and traces, and how OpenTelemetry ties them together.
Local forwarding, remote forwarding, dynamic SOCKS proxies, jump hosts, and the SSH config shortcuts that replaced half my VPN usage.
What WebAssembly actually is under the hood, why calling it fast JavaScript misses the point, and the Rust-to-WASM pipeline I use in real projects.
Forget the Gang of Four textbook. These are the patterns I see in production JavaScript and TypeScript codebases every week — observer, factory, strategy, and the ones nobody names but everyone uses.
The protocol running a third of the web that most developers haven't thought about. Connection migration, 0-RTT handshakes, and why switching from TCP to UDP was the only way forward.
The debugging features hiding in plain sight that took me years to discover. Performance profiling, memory leak hunting, network simulation, and the snippets panel I now use daily.
Why I stopped reaching for Postgres by default and started shipping production apps with SQLite. WAL mode, embedded analytics, and when it genuinely beats the big databases.
My honest take on unit vs integration vs e2e testing after years of writing tests that caught nothing and missing tests that would have caught everything.
Not a Vim-vs-VSCode argument. Just the motions, macros, and habits that made me genuinely faster at editing text after years of resisting modal editing.
The thing nobody explains well: what actually happens between typing a URL and getting an IP address, and why 'DNS propagation' is a misleading term.
Learning regex properly changed how I handle text processing. Named groups, lookaheads, and real-world patterns I actually use in production.
Practical naming, function size, and abstraction decisions I've changed my mind about after years of writing production code.
What I learned after six months of building with the App Router: when server components shine, when client components are the right call, and why caching will waste your afternoon.
The steps I take on every new Linux server before it faces the internet: SSH lockdown, firewall rules, fail2ban, automatic updates, and the security that actually matters.
How I went from confused by terminology to building useful models with scikit-learn, which algorithm to reach for first, and why feature engineering matters more than model choice.
The system design concepts I actually use at work: load balancers, caching layers, message queues, and why picking the right trade-off matters more than knowing the right answer.
Why I switched from polling to WebSockets, the reconnection logic nobody warns you about, and what happens when you try to scale beyond one server.
How I built CI/CD workflows that actually work, including the secrets management mistakes and caching tricks that took me months to figure out.
Why OAuth2 is confusing on first encounter, what the authorization code flow actually does step by step, and the implementation mistakes I've seen in production.
What actually moves the needle on real user experience: fixing LCP, CLS, and INP with changes that users notice, not just scores that improve.
When the document model actually helps, when relational wins, and the real project stories behind the decision.
After running Lambda in production for two years, here's what the marketing pages don't tell you about cold starts, billing surprises, and where serverless falls apart.
The concurrency model that finally clicked for me, the pitfalls that didn't show up until production, and when to reach for sync.Mutex instead of channels.
The Zsh, tmux, and Git configs I use daily. Annotated so you can understand what each block does and take what's useful.
Our team's actual decision-making process for whether to break up a Rails monolith. Spoiler: we didn't go full microservices.
Reference definitions for the 12-factor app methodology, containerization, infrastructure as code, and CI/CD pipelines.
Authentication, authorization, rate limiting, and input validation security mechanics.
I sat down with our caching server to talk about cache stampedes, missing TTLs, and the things backend developers keep getting wrong.
How to track down and fix multi-second query delays when your API starts timing out.
The 'prompt whisperer' industry is mostly a grift, but there are three techniques that actually help when working with language models.
A walkthrough of how we went from recurrent neural networks to ChatGPT, and where things stand now.
What neural networks actually do under the hood. Code included. No analogies about brains.
Practical constraints for code integration that actually work. Less about naming conventions, more about not breaking production.
Evaluating whether the overhead of Kubernetes is worth it for your team, and what the migration actually looks like.
Addressing misconceptions about containerized local setups, configuration pain points, and why volume mounting behaves the way it does.
How our team debated and resolved the Tailwind vs CSS Modules question. We didn't pick just one.
A practical guide for deciding between Rust and Go for backend services. No fanboy energy.
A pragmatic debate on data fetching, over-fetching, N+1 queries, and caching complexities.
The most frequent accessibility violations I encounter in code reviews, why they matter, and the specific fixes.
Notes from migrating our SPA to the Next.js App Router and React Server Components. What improved, what broke, and what surprised us.
Tracing the migration path from traditional React SPAs to the Next.js App Router, addressing routing mechanics, caching layers, and server action boundaries.
Walking through async JavaScript to show how the Event Loop decides what runs when.
Addressing the most common points of confusion regarding CSS Grid, Flexbox, Container Queries, and logical properties.
Discriminated unions, template literal types, conditional type extraction, and the satisfies operator. Production patterns, not interview trivia.
Four Python scripts I actually use. Bulk renamer, downloads folder organizer, duplicate finder, and a website change detector.
A detailed breakdown of a force-push incident that deleted two days of work, and the strict git branching policies established in the aftermath.
Why most Docker tutorials fail beginners, the critical difference between images and containers, and what actually happens when you run a container.
A collection of bash commands and shortcuts I reach for constantly, organized by what I'm trying to do rather than by category.
Walk through a simulated breach to understand which skills actually matter in real-world incident response.
New articles and tutorials sent to your inbox. No spam, no fluff, unsubscribe whenever.
I send one email per week, max. Usually less.