Launching Live Courses on Systems Programming
Modern software development has created a paradox: we build increasingly complex systems, yet fewer engineers understand how these systems work under the hood. It's time to change that.
For the past two years, I've been writing unique, deep-dive articles on systems engineering, showing you how real-world systems work at the source code level. This work has driven curiosity and understanding in software engineers wanting to go deeper into systems engineering.
Many of you have asked for a more structured, ground-up approach to these topics. That's why I'm launching a series of hands-on courses that will provide the framework you need to level up your systems engineering expertise.
As a self-taught engineer, I understand the challenges of learning systems programming. While there's no shortage of resources - Udemy courses, YouTube playlists, books - piecing together a coherent learning path is overwhelming. More importantly, maintaining motivation through self-study is incredibly difficult.
Having a guide and a community can dramatically accelerate your learning journey. Together, we'll systematically bridge the knowledge gap - building your systems engineering expertise from fundamentals up.
Initial Roadmap of the Courses
My focus is on systems engineering, which you’ve seen reflected in my writing about compilers, kernels, performance engineering, and computer architecture. The roadmap I’ve planned creates a natural progression that builds your expertise layer by layer.
Here’s how we’ll build up your systems knowledge:
1. Intro to Programming in X86 Assembly
This is our foundation. You’ll learn to read and write X86 assembly, understanding how your programs actually execute on the CPU. By the end, you’ll be able to look at C/Rust/Java code and visualize its assembly equivalent, which is a critical skill for everything that follows.
2. Building a Compiler for X86 Architecture
Compilers automate the generation of assembly code and when you can write assembly by hand, you can also think of ways to automate its generation, which is what compilers do. So the next step is learning how compilers work by building one.
3. Building a Bytecode Compiler
Although native compilers directly target hardware, many modern languages (Java, Python, JavaScript) use bytecode compilers. Designing the instruction set of a virtual machine, and implementing the virtual machine itself is a dark art and a specialised skill-set. So we will also get our hands dirty by building a bytecode compiler.
Future Directions
Looking ahead, I envision deeper courses on systems engineering, exploring how everything fits together - from CPU architecture through operating systems to high-performance applications. However, I believe in taking one step at a time.
For now, I’m focusing on the foundation: The X86 Assembly course is ready to launch, and the compiler courses are under progress. These initial courses will give you the core knowledge needed for deeper systems work.
Course Format
Each course will be hands-on:
Live, interactive sessions with real-time coding
Pair programming exercises
Projects
Small group discussions
Discussing the implementation details of real-world systems
However, these are topics that require practice and patience. While the courses will provide the structure, explanations and ideas, you will still have to work hard to grasp them. Eventually, you learn only with your own struggle with the ideas. A teacher can only show you the path.
Prerequisites
The prerequisite for all the courses is going to be:
A genuine interest in systems engineering
Few years of experience programming in a high level language such as C, C++, Java, Python, Rust.
Experience implementing common data structures, such as hash tables, lists, binary trees etc.
Recursion
Thank you to My Subscribers
My writing is openly available, and many of you have upgraded to support this work. While I keep most content free, I periodically find ways to thank the paid subscribers, such as giving away the Linux Context Switching Internals book for free.
As a thank you to the paid subscribers, I am also happy to offer you a lifetime discount on all the courses that I run and early access to book your spot because the seats are always going to be very few. Here is my way of expressing gratitude towards you:
Annual and long-term monthly subscribers (8+ months): 30% off all courses
Monthly subscribers: 15% off all courses
These discounts easily offset your subscription cost.
What’s Next
I will soon announce the first course in this roadmap, which is an introduction to programming in X86 assembly.
It will run over the first two weekends of April, consisting of 3-4 sessions of about 3 hours each.
Seats will be limited to 30-32 so that we can have high-quality discussions. Paid subscribers will get exclusive early access to claim their spot before public enrollment begins.
I will share the detailed course outline and the concrete dates in an upcoming email. Stay tuned!
If you have questions, feel free to reach out to me!