The strongest way to turn this curriculum into a practical systems + AI kernel program is to make every stage produce something executable.
The learner should not just study:
C → Assembly → Linux → Kernel → GPU → CUDA → Transformer
They should repeatedly follow:
Learn → Implement → Inspect → Benchmark → Break → Debug → Optimize → Explain
Below is a practical structure you can add to the curriculum.
Practical Learning Architecture
The entire curriculum can use this progression:
1Concept 2 ↓ 3Small Program 4 ↓ 5System Observation 6 ↓ 7Low-Level Implementation 8 ↓ 9Debugging 10 ↓ 11Benchmarking 12 ↓ 13Optimization 14 ↓ 15Real Project
Every major module should answer three questions:
11. What is happening? 22. How can I see it? 33. How can I implement it myself?
01. C Internals — Understand Memory First
The learner should begin by becoming comfortable with what C actually does in memory.
Practical Programs
Build progressively:
101. Hello Memory 202. Pointer Explorer 303. Array Address Visualizer 404. Struct Memory Layout 505. malloc/free Tracker 606. Custom Memory Allocator 707. Memory Leak Detector 808. Stack vs Heap Experiment 909. Buffer Overflow Demonstration 1010. Mini Memory Debugger
Example: Pointer Exploration
1#include <stdio.h> 2 3int main() { 4 int x = 42; 5 int *p = &x; 6 7 printf("value = %d\n", x); 8 printf("address = %p\n", (void*)&x); 9 printf("pointer = %p\n", (void*)p); 10 printf("*pointer = %d\n", *p); 11 12 return 0; 13}
Then inspect it:
1gcc -g pointer.c -o pointer 2gdb ./pointer
The learner should physically observe:
1Variable 2 ↓ 3Address 4 ↓ 5Pointer 6 ↓ 7Memory
Capstone
Build:
Mini malloc allocator
1malloc() 2 ↓ 3Free List 4 ↓ 5Memory Blocks 6 ↓ 7split() 8 ↓ 9free() 10 ↓ 11coalesce()
This provides the foundation for understanding allocators, heaps, fragmentation, and memory management.
02. Assembly — See What C Becomes
The goal is not to memorize assembly instructions.
The goal is to understand:
1C Code 2 ↓ 3Compiler 4 ↓ 5Assembly 6 ↓ 7Machine Instructions 8 ↓ 9CPU
Practical Programs
101. C → Assembly 202. Function Calling Convention 303. Register Explorer 404. Stack Frame Explorer 505. Recursive Function Assembly 606. Loop Optimization 707. Struct Access 808. Pointer Arithmetic 909. Inline Assembly 1010. Mini Assembly Program
Compile:
1gcc -S -O0 program.c
Then compare:
1gcc -S -O2 program.c
The learner should answer:
1What changed? 2 3Which instructions disappeared? 4 5Where are variables stored? 6 7Which registers are used? 8 9How did the compiler optimize the loop?
Practical Experiment
Write:
1int add(int a, int b) { 2 return a + b; 3}
Then inspect:
1Arguments 2 ↓ 3Registers 4 ↓ 5ADD instruction 6 ↓ 7Return register
This creates the connection between:
1C 2↓ 3Registers 4↓ 5Instructions
03. CPU Architecture — Build a Mental CPU
Before moving into GPUs, build a small CPU simulator.
Practical Project
Create:
8-bit CPU Emulator
1 ┌───────────┐ 2Program ────►│ CPU │ 3 │ │ 4 │ Registers │ 5 │ ALU │ 6 │ PC │ 7 │ Flags │ 8 └─────┬─────┘ 9 ↓ 10 Memory
Implement:
1LOAD 2STORE 3ADD 4SUB 5JUMP 6CMP 7HALT
Example instruction format:
1LOAD R1, 10 2LOAD R2, 20 3ADD R1, R2 4STORE R1, 100 5HALT
Now the learner understands CPU execution instead of only reading about it.
04. Linux — Understand Processes
Now connect CPU concepts to operating systems.
Practical Programs
101. fork() 202. exec() 303. wait() 404. pipe() 505. signal() 606. shared memory 707. mmap() 808. threads 909. process monitor 1010. mini shell
Build a Mini Shell
The learner implements:
1myshell
Supporting:
1ls 2pwd 3cd 4echo 5cat
Then:
1Command 2 ↓ 3fork() 4 ↓ 5exec() 6 ↓ 7Program
This creates the connection between:
1Process 2↓ 3Syscall 4↓ 5Kernel 6↓ 7CPU
05. Syscalls — Cross the User/Kernel Boundary
Build a syscall tracer.
First observe:
1strace ls
Then understand:
1User Program 2 │ 3 │ syscall 4 ▼ 5Linux Kernel 6 │ 7 ▼ 8Hardware
Practical Projects
101. File syscall explorer 202. Process syscall tracer 303. mmap() experiment 404. read/write benchmark 505. custom syscall investigation 606. mini strace-like tool
The learner should understand why:
1read(fd, buffer, size);
is not simply a normal function call.
06. ELF — Understand Executables
Create a practical ELF investigation lab.
Use:
1file program 2readelf -h program 3readelf -S program 4readelf -s program 5objdump -d program
Build a visualization:
1ELF 2├── Header 3├── Program Headers 4├── Sections 5├── .text 6├── .data 7├── .rodata 8├── .bss 9└── Symbols
Practical Project
Build:
Mini ELF Analyzer
It should print:
1Architecture 2Entry point 3Sections 4Symbols 5Program segments 6Executable permissions
Now:
1C 2 ↓ 3Compiler 4 ↓ 5Assembly 6 ↓ 7Object File 8 ↓ 9ELF 10 ↓ 11Process
becomes concrete.
07. Virtual Memory — Build a Page Table Simulator
This should be one of the most important practical modules.
Build:
Virtual Memory Simulator
Input:
1Virtual Address
Output:
1Virtual Address 2 ↓ 3Page Number 4 ↓ 5Page Table 6 ↓ 7Physical Frame 8 ↓ 9Physical Address
Example:
1Virtual Address: 0x12345 2 3Page Number → 0x12 4Offset → 0x345 5 6Page Table 70x12 → Frame 0x87 8 9Physical Address 100x87345
Then implement:
1Page Table 2TLB 3Page Fault 4Page Replacement
Experiments
Compare:
1Without TLB 2vs 3With TLB
Measure:
1Average memory access time
This makes the MMU/TLB concept measurable rather than theoretical.
08. Linux Kernel — Build Real Kernel Components
Move from userspace into kernel programming.
Practical Labs
101. Kernel module hello world 202. Module parameters 303. Kernel logging 404. procfs entry 505. sysfs entry 606. character device 707. ioctl 808. kernel memory allocation 909. workqueue 1010. kernel thread
Example architecture:
1User Program 2 │ 3 │ ioctl() 4 ▼ 5Character Driver 6 │ 7 ▼ 8Kernel 9 │ 10 ▼ 11Hardware
Capstone
Build:
Simple Character Device Driver
Userspace:
1write(fd, data, size);
Kernel:
1write() 2 ↓ 3driver_write() 4 ↓ 5kernel buffer
This provides real understanding of drivers.
09. GPU — Build a GPU Mental Model
Before writing serious CUDA kernels, make the learner understand:
1GPU 2├── SM 3│ ├── CUDA cores 4│ ├── Tensor cores 5│ ├── Registers 6│ └── Shared memory 7├── L2 Cache 8└── VRAM
Then connect:
1CPU 2 ↓ 3CUDA Launch 4 ↓ 5GPU 6 ↓ 7Grid 8 ↓ 9Block 10 ↓ 11Warp 12 ↓ 13Thread
Practical Experiment
Write a CUDA program that prints:
1threadIdx 2blockIdx 3blockDim 4gridDim 5warp ID
Example:
1__global__ void inspect() { 2 int tid = threadIdx.x; 3 int bid = blockIdx.x; 4 5 printf( 6 "block=%d thread=%d\n", 7 bid, 8 tid 9 ); 10}
Then launch:
1inspect<<<2, 32>>>();
The learner can directly observe the hierarchy.
10. GPU Memory — Benchmark Everything
Do not only explain:
1Register 2Shared Memory 3L1 4L2 5VRAM
Make students benchmark them.
Practical Labs
101. Global memory bandwidth 202. Coalesced access 303. Uncoalesced access 404. Shared memory 505. Shared-memory bank conflicts 606. Register pressure 707. Occupancy 808. L2 cache behavior
Compare:
1Thread 0 → element 0 2Thread 1 → element 1 3Thread 2 → element 2
against:
1Thread 0 → element 0 2Thread 1 → element 1024 3Thread 2 → element 2048
Then measure the difference.
The student learns:
Memory layout is part of algorithm design.
11. CUDA Kernels — Build From Naive to Optimized
Every important kernel should be implemented in multiple versions.
For example, GEMM:
1Version 1 2Naive GEMM 3 ↓ 4Version 2 5Coalesced GEMM 6 ↓ 7Version 3 8Shared Memory GEMM 9 ↓ 10Version 4 11Tiled GEMM 12 ↓ 13Version 5 14Vectorized GEMM 15 ↓ 16Version 6 17Tensor Core GEMM
Benchmark:
1Naive CUDA 2 ↓ 3Tiled CUDA 4 ↓ 5cuBLAS
Report:
1Latency 2GFLOPS 3Memory bandwidth 4Speedup
This is much more educational than presenting only a final optimized kernel.
12. Neural Network Kernels — Implement the Building Blocks
Now begin the AI track.
Implement:
1Vector Add 2 ↓ 3Bias 4 ↓ 5ReLU 6 ↓ 7GELU 8 ↓ 9SiLU 10 ↓ 11Softmax 12 ↓ 13LayerNorm 14 ↓ 15RMSNorm 16 ↓ 17SwiGLU
Each should have:
1CPU Reference 2 ↓ 3Naive CUDA 4 ↓ 5Optimized CUDA 6 ↓ 7Benchmark 8 ↓ 9Numerical Validation
For example:
1PyTorch result 2 vs 3CUDA result
Check:
1torch.allclose(reference, custom)
This teaches the critical engineering principle:
A fast kernel that produces incorrect results is not an optimized kernel.
13. Transformer Kernels — Build the Transformer From Kernels
Instead of jumping directly to Transformer architecture, construct it from GPU operations.
1Embedding 2 ↓ 3Q/K/V Projection 4 ↓ 5Attention Score 6 ↓ 7Softmax 8 ↓ 9Attention × V 10 ↓ 11Output Projection 12 ↓ 13RMSNorm 14 ↓ 15SwiGLU 16 ↓ 17Residual
Implement each operation.
Then combine them.
14. Attention — Build It Three Times
This should be a major practical project.
Version 1 — Naive Attention
1Q × Kᵀ 2 ↓ 3Softmax 4 ↓ 5× V
Version 2 — Tiled Attention
Use:
1Shared Memory 2+ 3Tiling 4+ 5Coalesced Loads
Version 3 — Fused Attention
Avoid materializing the complete attention matrix.
1Q 2↓ 3K tile 4↓ 5Score 6↓ 7Softmax 8↓ 9V tile 10↓ 11Output
Then compare:
1Naive Attention 2vs 3Optimized CUDA 4vs 5FlashAttention-style implementation
This becomes one of the strongest projects in the entire curriculum.
15. Transformer Systems — KV Cache
Now move from kernels to inference systems.
Build a small KV-cache implementation.
1Request 2 ↓ 3Transformer 4 ↓ 5K ───────► KV Cache 6V ───────► KV Cache 7 ↓ 8Next Token
Measure:
1Without KV cache 2vs 3With KV cache
Then implement:
1Paged KV Cache
Conceptually:
1Request A 2 ├── Page 0 3 ├── Page 1 4 └── Page 2 5 6Request B 7 ├── Page 3 8 └── Page 4
Now GPU memory management becomes directly connected to LLM inference.
16. Quantization — Build the Math
Do not treat quantization as a library-only feature.
Implement:
1FP32 2 ↓ 3INT8 4 ↓ 5INT4
Build:
1Quantize 2Dequantize
Then benchmark:
1Memory 2Speed 3Accuracy
For example:
1FP16 Model 2 ↓ 3Quantization 4 ↓ 5INT8 Model 6 ↓ 7Less Memory 8 ↓ 9Higher Throughput
17. Multi-GPU — Build Communication Experiments
Start with:
1GPU 0 2 GPU 1
Then measure:
1GPU-to-GPU transfer
Implement experiments around:
1cudaMemcpyPeer
Then study:
1NCCL 2├── AllReduce 3├── AllGather 4├── Broadcast 5└── ReduceScatter
Build a benchmark:
1Message Size 2 ↓ 3Communication 4 ↓ 5Latency 6 ↓ 7Bandwidth
This teaches that distributed AI is:
1Compute 2+ 3Memory 4+ 5Communication
18. Cybersecurity Track — Practical Progression
The cybersecurity branch should use the same philosophy.
1C 2 ↓ 3Memory Bugs 4 ↓ 5Assembly 6 ↓ 7ELF 8 ↓ 9Syscalls 10 ↓ 11Linux 12 ↓ 13Kernel 14 ↓ 15Driver 16 ↓ 17Security Boundary 18 ↓ 19Fuzzing 20 ↓ 21Vulnerability Analysis
Practical Projects
101. Stack overflow lab 202. Heap corruption lab 303. Use-after-free demonstration 404. ELF analyzer 505. Syscall tracer 606. Linux permission analyzer 707. Capability inspector 808. Namespace isolation lab 909. seccomp sandbox 1010. Kernel module lab 1111. Kernel fuzzing lab 1212. Defensive vulnerability analysis
The goal is controlled laboratory experimentation, followed by understanding how to prevent the same class of bug in real systems.
19. AI Kernel Track — Practical Progression
The AI branch should become progressively more demanding:
1C/C++ 2 ↓ 3CUDA Basics 4 ↓ 5Memory 6 ↓ 7Warp 8 ↓ 9Shared Memory 10 ↓ 11GEMM 12 ↓ 13Tensor Cores 14 ↓ 15Fused Kernels 16 ↓ 17Normalization 18 ↓ 19Softmax 20 ↓ 21Attention 22 ↓ 23FlashAttention 24 ↓ 25KV Cache 26 ↓ 27Quantization 28 ↓ 29LLM Inference 30 ↓ 31NCCL 32 ↓ 33Multi-GPU
20. The Final Frontier Project
The final project should combine the entire AI track.
Build a Mini LLM Inference Engine
Architecture:
1 Model 2 │ 3 ▼ 4 Weight Loading 5 │ 6 ▼ 7 GPU Memory 8 │ 9 ▼ 10 ┌──────────────┐ 11 │ Transformer │ 12 └──────┬───────┘ 13 │ 14 ┌─────────────┼─────────────┐ 15 ↓ ↓ ↓ 16 RMSNorm Attention MLP 17 │ │ │ 18 │ Flash-style │ 19 │ Kernel │ 20 │ │ │ 21 └─────────────┼─────────────┘ 22 ↓ 23 KV Cache 24 ↓ 25 Next Token
Implement progressively:
1Phase 1 2CPU inference 3 4Phase 2 5CUDA vector kernels 6 7Phase 3 8CUDA GEMM 9 10Phase 4 11GPU Transformer 12 13Phase 5 14Custom attention 15 16Phase 6 17KV cache 18 19Phase 7 20Quantization 21 22Phase 8 23CUDA Graphs 24 25Phase 9 26Multi-request batching 27 28Phase 10 29Multi-GPU inference
Practical Assessment System
Every module should end with a measurable challenge.
Level 1 — Understand
1Explain the concept. 2Draw the architecture. 3Identify the bottleneck.
Level 2 — Implement
1Write the program/kernel yourself.
Level 3 — Inspect
1GDB 2objdump 3readelf 4strace 5perf 6Nsight 7CUDA profiling tools
Level 4 — Benchmark
1Measure latency. 2Measure bandwidth. 3Measure throughput.
Level 5 — Optimize
1Baseline 2 ↓ 3Profile 4 ↓ 5Hypothesis 6 ↓ 7Optimization 8 ↓ 9Benchmark
Level 6 — Explain
The learner must be able to answer:
1Why is version B faster than version A? 2 3Which hardware resource is limiting performance? 4 5What happens in memory? 6 7What happens at the warp level? 8 9What happens at the CPU/GPU boundary?
The Most Important Practical Rule
Every major topic should have this structure:
1┌────────────────────────────────────────┐ 2│ THEORY │ 3│ Understand the architecture │ 4└──────────────────┬─────────────────────┘ 5 ↓ 6┌────────────────────────────────────────┐ 7│ OBSERVE │ 8│ Inspect what the machine actually does │ 9└──────────────────┬─────────────────────┘ 10 ↓ 11┌────────────────────────────────────────┐ 12│ IMPLEMENT │ 13│ Build a small working version │ 14└──────────────────┬─────────────────────┘ 15 ↓ 16┌────────────────────────────────────────┐ 17│ DEBUG │ 18│ Find and explain failures │ 19└──────────────────┬─────────────────────┘ 20 ↓ 21┌────────────────────────────────────────┐ 22│ BENCHMARK │ 23│ Measure real performance │ 24└──────────────────┬─────────────────────┘ 25 ↓ 26┌────────────────────────────────────────┐ 27│ OPTIMIZE │ 28│ Improve the actual bottleneck │ 29└──────────────────┬─────────────────────┘ 30 ↓ 31┌────────────────────────────────────────┐ 32│ PROJECT │ 33│ Combine multiple concepts │ 34└────────────────────────────────────────┘
That structure makes the curriculum much more valuable than a collection of theoretical tutorials. The learner continuously moves from source code → machine behavior → operating system → hardware → GPU kernels → AI workloads → complete AI systems.
The final mental model becomes:
1 SOFTWARE 2 │ 3 ▼ 4 C/C++ 5 │ 6 ▼ 7 Assembly 8 │ 9 ▼ 10 CPU 11 │ 12 ▼ 13 Linux 14 │ 15 ▼ 16 Virtual Memory 17 │ 18 ▼ 19 Kernel 20 │ 21 ▼ 22 CUDA 23 │ 24 ▼ 25 GPU 26 │ 27 ▼ 28 CUDA Kernels 29 │ 30 ▼ 31 Neural Kernels 32 │ 33 ▼ 34 Transformer Kernels 35 │ 36 ▼ 37 LLM Inference 38 │ 39 ▼ 40 Multi-GPU Systems 41 │ 42 ▼ 43 Frontier AI
That is the core practical identity of the curriculum: understand the machine, build the machine-level component, measure it, optimize it, and finally use it inside a real AI or systems project.