Learning in Public · C++ · Systems Programming · Software Engineering

A Journey to Low-Level Programming

Rediscovering the joy of programming through C++, Rust, and a deeper understanding of how computers really work.

Rediscovering the joy of programming through C++, Rust, and a deeper understanding of how computers work.

This is my first blog post, and the beginning of something I’ve wanted to document for a while: my journey into systems programming.

I’m a software engineer with over five years of experience, primarily working with PHP, TypeScript, and C#. Over the past couple of months, I’ve been exploring C++ and Rust, following a growing curiosity about what happens beneath the abstractions I use every day.

Somewhere along the way, I realized I was having fun programming again.

Simplicity Beneath the Abstractions

One of the things drawing me toward lower-level programming is, strangely enough, its simplicity.

Coming from someone with a TypeScript background, that probably sounds questionable. C++ and Rust certainly have their share of complexity. What appeals to me is being closer to the mechanics: how memory is managed, how data is laid out, and what the machine actually has to do to execute my code.

Much of my work has involved abstractions that let me build software without thinking about those details. There are good reasons for that. We shouldn’t need to understand every layer of a computer just to ship a useful application.

But over time, I’ve found myself increasingly interested in the details those abstractions hide. I can use a tool, follow its conventions, and get the result I need, yet still feel unsatisfied because I don’t understand how it works.

That gap is what I want to explore.

Magic is the Absence of Knowledge

Redis is the perfect example for this.

For a long time, I found it intimidating. I understood where I might use it, but its internals felt like a black box. It was fast, powerful, and a little too magical for my liking.

I’ve started to think of “magic” as a name for something I don’t understand yet. A trick feels impossible while its mechanism is hidden. Once someone shows you how it works, you can begin to appreciate the decisions behind it.

Learning about Redis’s sorted sets gave me that feeling. One of the structures used to implement them is a skip list, paired with a hash table. Redis also has a compact representation for smaller sorted sets. (Redis documentation, implementation)

If you’re wondering what the hell a skip list is, and whether it might appear in your next LeetCode interview, I share your concern.

The basic idea is approachable: start with a sorted linked list, then give some nodes extra links that skip over intermediate entries. Searching starts with those larger jumps and moves down to finer steps as it approaches the target. Those layers let you find an entry without visiting every node along the way. (Redis skip-list implementation)

Suddenly, I had something concrete to reason about. Redis hadn’t become trivial, but a piece of it had become understandable.

For an illustrated walkthrough, see Deep Dive into Redis ZSet Internals. Its discussion of ziplists reflects an older encoding; newer Redis versions use listpacks for compact sorted sets. (Redis implementation)

That experience captures much of what motivates me: learning enough about a system to replace a vague sense of mystery with an understanding of its parts.

Beyond the Syntax

C++ and Rust are my starting points, but my curiosity extends beyond the languages themselves. I want to understand computer systems and learn what it takes to write efficient software.

I’m particularly interested in low-latency programming and how implementation choices affect performance on modern hardware. Some of the topics I want to explore include:

  • Concurrency and multithreading: Synchronization, mutexes, and lock-free programming.
  • Computer architecture: CPU caches, cache locality, and cache coherency.
  • Operating systems: Unix, virtual memory, and how programs interact with the OS.
  • Performance optimization: Measuring what makes software slow and understanding why a change makes it faster.

I want to get better at explaining why an approach works, recognizing its tradeoffs, and knowing when to question it.

To build that foundation, I’m currently working my way through several books:

They cover different parts of the picture, from computer architecture and operating systems to writing modern, expressive C++.

Use of AI

Learning all of this in a world increasingly shaped by AI can feel a little strange. When generating code is so accessible, spending an evening struggling with a concept might seem unnecessarily difficult.

For me, working through that difficulty is part of the appeal.

I’ll use AI here and there to help explain concepts that haven’t clicked, ask follow-up questions, and challenge my understanding. I want to be able to explain what I’ve learned in my own words before building on it.

For the code I write as part of this journey, though, I’ll be doing the work myself. I want to suffer. (Kidding, kind of..)

Writing, debugging, and revisiting my own mistakes gets the cogs turning again. It also helps me discover the difference between an explanation that sounds convincing and something I actually understand.

What’s Next?

I don’t have a strict roadmap or a particular destination in mind. For now, I want to keep reading, building small experiments, and following the questions that arise.

This blog will be a place to document that process: what I learn, what confuses me, and what eventually makes sense. Hopefully, some of those explanations will help someone else along the way.

If you’re exploring similar topics, I’d love to hear what you’re learning and where your curiosity has taken you.

There’s a lot I don’t understand yet. I’m looking forward to making a little more of it feel less magical.

AN OPEN CHANNEL

Have something in mind?

Let’s build it.