Chapter 1: Introduction to Assembly Language
- Lesson 1: What is Assembly Language?
- Lesson 2: History of Assembly and its Evolution
- Lesson 3: Why Learn Assembly? Use Cases and Applications
- Lesson 4: Overview of CPU Architectures (x86, x86-64, ARM, RISC-V)
- Lesson 5: Basics of Low-Level Programming
- Lesson 6: Setting Up an Assembly Programming Environment
- Lesson 7: Writing and Running Your First Assembly Program
- Lesson 8: Understanding the Role of Assemblers, Linkers, and Debuggers
Chapter 2: Assembly Language Basics
- Lesson 1: Understanding CPU Registers (General-Purpose and Special Registers)
- Lesson 2: Memory Segmentation and Addressing Modes
- Lesson 3: Instruction Set Architecture (ISA)
- Lesson 4: Understanding Opcodes and Mnemonics
- Lesson 5: Syntax Differences: Intel vs. AT&T Assembly
- Lesson 6: Using an Assembler (NASM, MASM, GAS, etc.)
- Lesson 7: Understanding Execution Flow in Assembly
Chapter 3: Data Representation and Variables
- Lesson 1: Understanding Data Storage in Memory
- Lesson 2: Declaring and Using Variables
- Lesson 3: Data Types in Assembly (DB, DW, DD, DQ)
- Lesson 4: Working with Constants
- Lesson 5: Endianness: Big-Endian vs. Little-Endian
- Lesson 6: Working with Signed and Unsigned Numbers
- Lesson 7: ASCII and Unicode Representation in Assembly
Chapter 4: Assembly Instructions and Operations
- Lesson 1: Arithmetic Instructions (ADD, SUB, MUL, DIV)
- Lesson 2: Logical Instructions (AND, OR, XOR, NOT)
- Lesson 3: Bitwise Operations and Bit Manipulation
- Lesson 4: Shift and Rotate Instructions (SHL, SHR, ROL, ROR)
- Lesson 5: Conditional and Comparison Instructions (CMP, TEST)
- Lesson 6: Stack Operations (PUSH, POP)
- Lesson 7: Jump and Loop Instructions (JMP, JZ, JNZ, LOOP)
Chapter 5: Control Structures
- Lesson 1: Conditional Execution (IF-ELSE Equivalent in Assembly)
- Lesson 2: Implementing Loops (FOR, WHILE, DO-WHILE in Assembly)
- Lesson 3: Nested Loops in Assembly
- Lesson 4: Implementing Switch-Case in Assembly
- Lesson 5: Breaking and Continuing Execution Flow
Chapter 6: Functions and Procedures
- Lesson 1: Understanding Procedures in Assembly
- Lesson 2: Declaring and Calling Procedures
- Lesson 3: Passing Parameters to Procedures (Stack and Register Methods)
- Lesson 4: Local and Global Variables in Procedures
- Lesson 5: Function Call Optimization and Recursion
Chapter 7: Input / Output in Assembly
- Lesson 1: Handling Keyboard Input
- Lesson 2: Displaying Output on Console
- Lesson 3: String Handling and Manipulation
- Lesson 4: Printing Numbers and Characters
- Lesson 5: Reading and Writing Files in Assembly
Chapter 8: Stack, Heap, and Memory Management
- Lesson 1: Understanding Stack in Assembly
- Lesson 2: Stack Frames and Stack Operations
- Lesson 3: Dynamic Memory Allocation in Assembly
- Lesson 4: Working with Heap Memory
- Lesson 5: Memory Optimization Techniques
Chapter 9: Assembly and C Integration
- Lesson 1: Calling Assembly Code from C
- Lesson 2: Calling C Functions from Assembly
- Lesson 3: Using Inline Assembly in C
- Lesson 4: Memory Layout and Calling Conventions
- Lesson 5: Passing Parameters Between C and Assembly
Chapter 1: Advanced Assembly Instructions
- Lesson 1: Floating-Point Operations (FPU, SIMD, SSE, AVX)
- Lesson 2: Advanced String Operations (SCAS, CMPS, STOS)
- Lesson 3: Using Macros in Assembly
- Lesson 4: Working with System Calls
Chapter 2: Debugging and Profiling Assembly Code
- Lesson 1: Introduction to Debugging Assembly
- Lesson 2: Using GDB for Assembly Debugging
- Lesson 3: Understanding Breakpoints and Memory Inspection
- Lesson 4: Analyzing Performance with Profiling Tools
Chapter 3: Preprocessor in Assembly
- Lesson 1: Understanding Preprocessor Directives
- Lesson 2: Conditional Compilation
- Lesson 3: Macros and Inline Code Expansion
- Lesson 4: Using Include Files
Chapter 4: Signal Handling in Assembly
- Lesson 1: Introduction to Signal Handling
- Lesson 2: Handling Interrupts in Assembly
- Lesson 3: Software Interrupts vs. Hardware Interrupts
- Lesson 4: Using BIOS and System Interrupts
Chapter 5: Working with Operating System Services
- Lesson 1: Interfacing with Windows API
- Lesson 2: Interfacing with Linux System Calls
- Lesson 3: Writing Assembly Code for Device Drivers
Chapter 6: Multithreading and Concurrency
- Lesson 1: Implementing Multithreading in Assembly
- Lesson 2: Synchronization and Locks
- Lesson 3: Performance Optimization in Multithreading
Chapter 7: Security and Exploitation in Assembly
- Lesson 1: Understanding Buffer Overflow and Exploits
- Lesson 2: Writing Shellcode
- Lesson 3: Reverse Engineering with Assembly
- Lesson 4: Malware Analysis Using Assembly
Chapter 8: Networking and Socket Programming
- Lesson 1: Low-Level Network Programming
- Lesson 2: Implementing TCP and UDP Sockets in Assembly
- Lesson 3: Writing a Simple HTTP Client in Assembly
Chapter 9: Cryptography and Encryption in Assembly
- Lesson 1: Implementing Basic Cryptographic Algorithms
- Lesson 2: Hashing and Digital Signatures
- Lesson 3: Secure Coding Practices in Assembly
Chapter 10: Writing and Deploying Assembly Libraries
- Lesson 1: Creating and Linking Assembly Libraries
- Lesson 2: Exporting Assembly Functions for Other Languages
- Lesson 3: Optimizing Assembly Libraries for Performance
Chapter 11: Reverse Engineering and Assembly Analysis
- Lesson 1: Understanding Disassembly
- Lesson 2: Using IDA Pro and Ghidra for Reverse Engineering
- Lesson 3: Analyzing Executable Files
Chapter 12: Building GUI Applications with Assembly
- Lesson 1: Windows GUI Programming in Assembly
- Lesson 2: Creating a Basic GUI Window
- Lesson 3: Handling User Input in GUI Applications
Chapter 13: Embedded Systems and Firmware Development
- Lesson 1: Writing Assembly for Embedded Devices
- Lesson 2: Interfacing with Microcontrollers
- Lesson 3: Bootloaders and Bare-Metal Programming
Chapter 14: Virtualization and Emulation with Assembly
- Lesson 1: Writing Code for Virtual Machines
- Lesson 2: Working with Emulators (QEMU, Bochs)
- Lesson 3: Assembly for BIOS and UEFI Programming
Chapter 15: Assembly Code Optimization Techniques
- Lesson 1: Loop Unrolling and Pipelining
- Lesson 2: Efficient Use of CPU Cache
- Lesson 3: Reducing Instruction Count for Performance