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.

Subscribe now

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:

1. Concept introduction with practical examples

2. Pair programming exercises in breakout rooms

3. 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:

1. Read and Write Assembly

   1. Understand X86 assembly syntax and structure

   2. Read and comprehend compiler-generated assembly

   3. Debug assembly code using GDB

2. Understand Systems Better

   1. Visualize how high-level code maps to machine instructions

   2. Make informed decisions about performance tradeoffs

   3. Debug issues at the machine level

3. Build Practical Skills

   1. Interface assembly code with C programs

   2. Create and use shared libraries

   3. Build familiarity with systems programming tools (assembler, linker, debugger)

4. Gain Foundation for Advanced Topics

   1. Compiler development

   2. Systems programming

   3. Performance optimization

   4. 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.

I'm Interested

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:

Sign me up!

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!