Welcome! I’m thrilled to finally launch this project—something I’ve been thinking about for almost a decade.
What This Is All About
For over 10 years, I’ve been giving talks at conferences about how things work under the hood. I started in the Python community, exploring topics like the object model, garbage collection, and the CPython interpreter internals. Later, I expanded into other communities—Go, PostgreSQL, and beyond—always with the same goal: making complex internals approachable.
The thing is, I’ve always believed that understanding how systems work internally doesn’t require you to be an expert or have years of low-level programming experience. You don’t need to know every greedy detail or spend months reading source code. What you need is someone to guide you through the general concepts—the “how it ticks” part—so you can build a mental model of what’s actually happening when you run your code, execute a query, or commit to Git.
That’s what this blog (and newsletter) is about.
Who This Is For
If you’ve ever wondered:
- What happens when you run
go build? - How does PostgreSQL execute a query?
- What does Git actually do when you commit?
- How does the Linux kernel schedule processes?
…but felt overwhelmed by technical documentation or thought you didn’t have enough background to understand—you’re exactly who I’m writing for.
This isn’t about exhaustive references or diving into every corner case. It’s about giving you that “aha!” moment where suddenly the system makes sense. I want you to walk away with a clear vision of how these complex projects work, even if you’ve never touched their source code before.
Why Now?
I’ve wanted to do this for almost 10 years. The problem was always time and resources. Creating content at the quality level I wanted—deep dives that are both accurate and approachable—takes enormous effort. Between my other responsibilities, I could never dedicate the time needed to make it happen.
But now, thanks to AI, I can speed up the process significantly. AI helps me research faster, draft clearer explanations, and refine my writing without sacrificing quality. It’s not about replacing the human element—it’s about amplifying what I can do, so I can finally share this knowledge the way I’ve always envisioned.
What to Expect
I’ll be publishing one post every week, diving into different aspects of software internals. Each post takes a concrete example (like a “hello world” program or a simple SQL query) and walks through what happens internally—step by step, concept by concept.
Some topics you can expect:
- Go compiler phases: lexer, parser, type checker, SSA, code generation
- PostgreSQL query execution: parsing, planning, execution, storage
- Git internals: objects, refs, the commit graph, merge strategies
- Linux kernel: process scheduling, memory management, system calls
- Python internals: the object model, garbage collection, the bytecode interpreter
Each post will focus on the general concepts and mental models you need, not the exhaustive implementation details. My goal is to make complicated internals look simple.
Join the Journey
If this sounds interesting to you—whether you’re a student, an intern, or a seasoned developer who’s just curious about the systems you use every day—I hope you’ll stick around.
You can subscribe to the newsletter to get new posts delivered straight to your inbox, or just check back here every week for the latest deep dive.
I’m excited to finally share this with you. Let’s dive into the internals together.
— Jesús