[Course Launch] Hands-on Introduction to X86 Assembly

A Live, Interactive Course for Systems Engineers

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.

I am sharing this announcement with the paid subscribers first to give you early access. After 2 days, I will open this up to the rest of the public.

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

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