This course introduces you to Assembly language programming using NASM (Netwide Assembler), where you'll learn to write low-level code to directly interact with computer hardware. You'll master essential concepts like registers, memory management, system calls, loops, and conditional statements, enabling you to develop efficient, optimized programs. Ideal for students and professionals looking to understand the fundamentals of how computers execute instructions at the machine level.

Course Outline:

1. Introduction to Intel x86-64 Architecture and NASM Assembly

1. Intel x86-64 Architecture
2. Data Representation, Bits, and Bytes
3. Processor Registers
4. First Program on Linux
5. First Program on Windows
6. First Program on macOS

2. Basics of NASM Assembly

1. MOV Instruction: Copying Data
2. Addition and Subtraction
3. Jumps: JMP Instruction
4. Status Flags and Conditional Jumps
5. Comparison: CMP Instruction
6. Conditional Copy Instructions
7. Loop Instruction and JRCXZ
8. Multiplication: MUL and IMUL Instructions
9. Division: DIV and IDIV Instructions
10. Logical Operations
11. Shift and Rotate

3. Working with Data and Memory

1. Defining Variables and Data Types: .data Section
2. Indirect Addressing
3. Getting the Current Address
4. Constants
5. Symbols
6. Strings
7. Byte Order: Big-endian and Little-endian
8. Structures
9. Stack
10. Copying and Saving to String
11. String Comparison
12. String Search

4. Functions

1. Defining and Calling Functions
2. Saving Registers and Variables During Function Calls
3. Function Parameters
4. Function Result
5. Stack Frame and Local Variables
6. Local Labels
7. Program Organization

5. System Calls

1. System Calls in Linux and the syscall Instruction
2. System Calls and Interrupts

6. Interaction Between Assembly Code and C/C++

1. Calling C/C++ Functions from Assembly on Linux
2. Calling C/C++ Functions from Assembly on Windows
3. Calling Assembly Functions from C/C++
4. Passing Structures Between Assembly and C/C++
5. Working with Files

7. SIMD

1. Floating-Point Numbers
2. SSE and AVX/AVX2 Extensions
3. Data Copying Using SIMD Instructions
4. Converting Floating-Point Numbers to Integers and Back
5. Floating-Point Arithmetic
6. Floating-Point Number Comparison
7. SSE/AVX Shift Operations
8. Logical Operations on Vectors
9. Addition Using SSE/AVX Instructions
10. Subtraction Using SSE/AVX Instructions
11. Multiplication Using SSE/AVX Instructions
12. SSE/AVX Mathematical Instructions
13. Integer Comparison in SSE/AVX
14. Arithmetic Operations with Floating-Point Number Vectors
15. Saving SSE/AVX Register States

8. Preprocessor

1. Preprocessor Directives
2. Preprocessor Conditional Constructs
3. Macros

9. Shared Libraries in Linux

1. Creating Shared Libraries for Linux
2. Position-Independent Code
3. Linking Built-in Linux Libraries
4. Overriding Shared Libraries
5. Programmatic Library Loading

10. Additional Articles

1. Stack, Program Arguments, and Environment Variables in Linux
2. Console and Cursor Manipulations
3. Finite Automaton Implementation

Why Enroll

Enroll in this course to gain a deep understanding of how computers execute instructions and how low-level programming can lead to optimized, efficient code. By learning NASM, you'll sharpen your skills in memory management, performance tuning, and system-level programming—knowledge that is highly valued in fields like embedded systems, operating systems, and reverse engineering. Whether you're looking to strengthen your programming foundation or advance in technical careers, this course will set you apart.