[Course Launch] Hands-on Introduction to X86 Assembly
A Live, Interactive Course for Systems Engineers
All the seats are filled now, most of them were taken up by the paid subscribers who were given early access. I will plan and announce another one soon.
Recently I announced that we will have some live courses soon, and this is the first course in that line: Hands-on Introduction to X86 Assembly. I’m starting with assembly because this is the foundation and everything in systems engineering builds on top of it, and even the future courses I want to do build on top of this.
Overview of the Course
This will be an introductory course on assembly programming for the X64 hardware for experienced software engineers with expertise in one or more high level programming languages such as C, C++, Rust, Go, Java, C#, Python, JavaScript etc.
The objective of the course is to introduce you to the X86 hardware architecture and the instruction set to a level where you can start to think at assembly level when you read or write code written in a high level language.
This sets up the foundation for you to dive into more advanced topics in systems engineering and will accelerate your learning.
Target Audience
You don’t need to know computer architecture or any other prior familiarity with assembly programming.
But you should be an experienced programmer who is really comfortable solving problems in a high level language. Specifically, you should be:
comfortable writing code in a high level language, such as C, C++, Rust, Java, Python etc.
able to write your own implementation of common data structures, such as linked lists and hash tables in a language of your choice.
know the difference between a value and a reference
comfortable with the idea of recursion.
Last but not the least, you should have curiosity of understanding how code really executes on the hardware.
Course Format
The format will be completely hands-on where you and I will spend most of the time writing and discussing code. Each session will have a structured format:
Concept introduction with practical examples
Pair programming exercises in breakout rooms
Discussions and Q&A
Syllabus
Section 1: Foundations & Basic Operations
Computer architecture essentials: memory hierarchy, registers, addressing modes
Intro to your development environment (assembler, Make, GDB)
Writing your first assembly program
Automating builds using Makefiles
Making system calls
Section 2: Control Flow & Functions
Implementing conditional branches
Building loops in assembly
Function implementation and calling conventions
Understanding the stack frame
Tutorial on debugging assembly programs using GDB/LLDB
Different ways of implementing switch cases
Section 3: Memory & Libraries
Deep dive into memory segments (data, bss, text, stack, heap)
Static vs dynamic memory allocation
Creating and using libraries
Interfacing assembly with C
Understanding linking (static vs dynamic)
Hands-on: Building and using a simple library
Using valgrind to debug memory leaks
Section 4: Real-world Applications
Reading and understanding compiler output
Common compiler optimizations:
Loop unrolling
Function inlining
Register allocation
Analyzing C/Rust code through its assembly
We will look at C and Rust programs and analyze the compiler generated assembly for them.
Take home final project
Learning Outcomes
After completing this course, you will be able to:
Read and Write Assembly
Understand X86 assembly syntax and structure
Read and comprehend compiler-generated assembly
Debug assembly code using GDB
Understand Systems Better
Visualize how high-level code maps to machine instructions
Make informed decisions about performance tradeoffs
Debug issues at the machine level
Build Practical Skills
Interface assembly code with C programs
Create and use shared libraries
Build familiarity with systems programming tools (assembler, linker, debugger)
Gain Foundation for Advanced Topics
Compiler development
Systems programming
Performance optimization
Security analysis
Course Details & Founding Batch Benefits
As this is the first batch, I’m offering special arrangements and benefits:
Course Structure
Duration: 3-4 sessions, each 3 hours long
Dates:
19th-20th April (first two sessions)
26th-27th April (3rd and if required the 4th session)
Batch Size: Limited to 20 students (all seats filled now)
Recordings: Full access to session recordings
Free access to future runs of this course
Founding Batch Pricing
Regular Price: $99 (may go up in future runs)
Annual/Long-term Subscribers (8+ months): $59 (40% discount)
Monthly Subscribers: $74 (25% discount)
Note: As this is the first batch, I’m offering higher subscriber discounts than originally planned. Future courses will follow the standard discount structure (30%/20%).
Interested? Sign Up
As the seats are limited to 20, the registration is on a first-come-first-serve basis. Please submit your details by filling up the following Google form and I will reach out with a payment link to confirm your registration.
If you are not quite sure why learning assembly is important, let me make a case.
Why Learn Assembly in 2025?
That’s a great question to ask. I think the knowhow of assembly programming is even more vital today than it was ten years back. With the arrival of advanced AI models, the exciting opportunities are gravitating towards two extremes:
Research and development of advanced AI models themselves
Then, development of the rest of the systems to power the training, and inference of these models.
This latter category is resulting in the creation of new chips, compilers, runtimes, databases, and large scale distributed systems for training/inference and model serving APIs. Even training these models requires low level knowledge of the GPU architecture, e.g. the DeepSeek engineers went below the CUDA layer and worked with the PTX code (which is a lower level instruction set that CUDA abstracts) to train their latest model.
But No One Writes Assembly?
Yes, most likely you will not have to write assembly by hand. But you still need to think at that level for several reasons:
Reason about the memory layout of your objects and their impact on the CPU cache
When doing performance optimizations, you will need to look at the compiler generated assembly to see where the bottlenecks are
Often when working with existing systems, they already have many optimizations in place. To understand those codebases you need a handle on assembly and CPU microarchitecture details.
You want to write a compiler? First you need to know how to write programs in assembly before you can write a compiler to automate the generation of assembly code. You will appreciate your high level languages even more after this.
Don’t take my word for it, even George Hotz says this:
Frequently Asked Questions
Q: What level of experience do I need?
A: While familiarity with a systems language such as C/C++/Rust etc is useful but not required. The most important requirement is that you should really be comfortable writing production quality code in a language of your choice.
Q: I can’t attend all sessions live. Will recordings be available?
A: Yes, recordings will be available. However, we strongly recommend attending live sessions as the hands-on exercises and peer programming are crucial parts of the learning experience.
Q: How much time should I allocate outside the sessions?
A: Plan for 2-3 hours between sessions to review materials and practice concepts. The more you practice, the more you’ll benefit from the course.
Q: Will we be writing a lot of assembly code by hand?
A: Yes! This is a hands-on course. While in real life you rarely write assembly by hand, writing it is the best way to understand it. This knowledge will help you read and understand compiler-generated assembly.
Q: I use Windows/MacOS. Can I take this course?
A: Yes, but you’ll need to set up a Linux environment (either dual-boot or VM). We’ll provide setup instructions before the course begins.
Q: What happens if I miss a session?
A: While you can catch up using recordings, we recommend attending all sessions live due to the interactive nature of the course. You’ll have access to future iterations of the course if you need to revisit topics.
Q: Will this help me with my day job?
A: If you work in systems programming, performance optimization, debugging, or are interested in compiler development, absolutely! Even if you don’t, understanding assembly deepens your programming knowledge and helps make better architectural decisions.
Q: Do you offer refunds?
A: The syllabus and the learning outcomes are provided above. If after attending the planned sessions and doing the activities, you feel the course did not deliver on those, I will be happy to give you a 100% refund.
Q: I Paid for the course but something came up and I cannot attend the sessions
A: Don’t worry. You can attend any future version of this course free of cost.
Q: What will be the timings of the sessions?
A: I’ve yet to decide. But because I’m based in India (UTC + 5:30), it will most likely be my morning time (e.g. 8 am to 11 am) or night time (10 pm to 1 pm).
If you have any other questions, feel free to reach out to me!