Mohammed Efaz

start-here

2026-07-28T13:24:53Z

Where I am now

This is the page I need for ordinary study sessions. I can return to the full route, the 48-book audit, or the rules that keep the plan mine when I need the reasoning behind the next action.

My current stage

I am in Stage 1: C, shell, Python DSA, and Unix context.

1. C Programming: A Modern Approach, 2nd Edition

I am at Chapter 6: Loops. I have implemented and verified all 12 Chapter 6 programming projects. My next job is to review the chapter's ideas and solve the exercises independently before I continue.

While the book is teaching C99-compatible material, I will compile with strict warnings:

cc -std=c99 -Wall -Wextra -Wpedantic -g program.c -o program

When pointers, arrays, or dynamic memory enter the work, I will use sanitizers:

cc -std=c99 -Wall -Wextra -Wpedantic -g \
  -fsanitize=address,undefined program.c -o program

Warnings are part of the lesson. I should be able to explain every one instead of silencing it and hoping for the best.

2. The Linux Command Line, 3rd Edition

I will continue from the beginning or from my current bookmark. I need to type the commands rather than read them passively, and I will use a disposable practice directory while I learn.

The shell is also where the C work becomes real. I will use it to compile, run, inspect, and debug the programmes from King.

3. A Common-Sense Guide to Data Structures and Algorithms in Python, Volume 1

I will continue from Chapter 1 or from my current bookmark. I will implement the important structures and algorithms in Python, test them, and state their time and space complexity.

Learning C elsewhere does not mean I need to drag C's memory-management cost into DSA practice. Python remains my main DSA language.

4. UNIX: A History and a Memoir

This is the lighter book in the stage. I can read it whenever I want a change of pace. It does not need exercises, notes, or a project.

My next session

If I sit down and do not know which book to open, I will do this:

Open King at Chapter 6.
Choose 1 loop concept or exercise.
Predict the programme's behaviour before compiling it.
Implement it without looking at a finished answer.
Compile with warnings enabled.
Test normal, boundary, and invalid input where it matters.
Explain the loop condition, the changing state, and the termination rule.
Leave an exact section, page, or exercise marker for the next session.

If I need a change of pace, I can use The Linux Command Line or DSA Volume 1. Difficulty in the current work is not a reason to escape into a future-stage book.

The study loop

read -> predict -> implement -> compile/run -> test -> inspect -> explain -> continue

Read: I need the explanation before I start copying syntax.
Predict: I should decide what I expect before the compiler gives me an answer.
Implement: I turn the prose into a programme, command, or experiment.
Compile and run: I expose syntax, type, and environment problems.
Test: I check more than the sample input.
Inspect: Later this will include debuggers, sanitizers, traces, disassembly, profilers, and hardware registers.
Explain: I make sure the success was not accidental.
Continue: I leave a precise marker so the next session starts cleanly.

What completion means

For a textbook, I will read the main teaching material, run useful examples, and do enough exercises to use the ideas independently.
For a project book, I will build the projects and make small changes of my own.
For a pocket guide or manual, I will make a structured pass, try unfamiliar material, and keep it for lookup.
For a security book, I will work only inside systems I own or have explicit permission to test.
For a memoir, I will read it normally.

I do not need to complete exercises that repeat an idea I already understand, create elaborate notes, or manufacture proof that I studied. I should not skip an exercise or project that introduces something new.

When I can leave Stage 1

I will move to Stage 2 when all of these are true:

I have completed King's main teaching material from my current position and the non-repetitive projects that introduce new ideas.
I can write, compile, test, and debug small multi-file C programmes from the terminal without copying a template.
I am comfortable with control flow, functions, arrays, pointers, strings, structures, files, scope, storage duration, and the common undefined behaviour covered by King.
I have worked through The Linux Command Line and used the commands rather than only reading them.
I have finished DSA Volume 1 with working Python implementations of its central structures and algorithms.
I have finished the Unix memoir.

When something blocks me

I will give the blocker 1 focused attempt and preserve the exact error message. If it remains unresolved, I can switch to another current-stage book and return later. I will not lose days installing an environment for work that belongs several stages ahead.

Kernel, embedded, Kali lab, CUDA, and model-performance environments can wait until I reach them.

principles

2026-07-28T13:24:53Z

Rules that keep this roadmap mine

This file protects the decisions I made while researching the roadmap. Anyone changing the curriculum, including a future version of me, needs to read it first.

What I am trying to build

I want deep practical ability across:

C and modern C
Python data structures, algorithms, and LeetCode
Linux command-line use, shell scripting, internals, system programming, and kernel programming
modern C++ and asynchronous systems
bare-metal embedded C
Kali Linux, ethical hacking, and Linux hardening
machine learning and deep learning
LLM construction
CUDA, GPU-kernel work, and AI inference and performance engineering
reasoning models, reinforcement learning, and RLHF

Finishing books is not the goal by itself. I want competence backed by implementation, testing, debugging, profiling, and real lab work.

The choices I do not want quietly reversed

1. Teaching style matters to me

I learn best from clear, progressive, practical books with explanations, examples, exercises, and projects. K. N. King's C Programming: A Modern Approach is the closest model for what works for me.

Prestige does not cancel fit. If I dislike the way a famous book teaches, I am not going to make it mandatory because other people treat it as a rite of passage.

2. Computer Systems: A Programmer's Perspective is not mandatory

I dislike the presentation style of Computer Systems: A Programmer's Perspective, and I do not intend to use it as a core textbook.

It must not return as a gate for Stage 3, Linux, C++, kernel work, CUDA, or performance engineering. It remains in the library inventory as an unselected book. I accept that leaving it out creates a gap in formal computer-architecture coverage unless I later choose a different resource.

3. Python is my main DSA and LeetCode language

My DSA route is:

A Common-Sense Guide to Data Structures and Algorithms in Python, Volume 1
A Common-Sense Guide to Data Structures and Algorithms in Python, Volume 2
LeetCode 75 in Python

C is my main systems language, but that does not mean every subject needs to be learnt through C. I chose Python for DSA so I can focus on the algorithms without mixing in manual memory management.

4. Algorithmic Thinking is optional

I may read Algorithmic Thinking, 2nd Edition after Stage 2 if I want more C-based problem-solving practice.

It is not my main DSA book, a stage requirement, a replacement for the 2 Wengrow volumes, or a blocker for Stage 3. I rejected it as the primary text because its selective, problem-first structure does not match the way I want to learn the subject.

5. Owning a book does not make it part of the plan

My Calibre library is a pool of candidates. I choose from it based on:

relevance to the goal,
prerequisite order,
teaching-style fit,
unique value,
overlap,
and whether I am likely to finish the book and practise what it teaches.

I do not need to force every computer-science title I own into the default route.

6. Security and reasoning stay in the main roadmap

I want both offensive and defensive Linux security. I also want reasoning-model and post-training work.

I will not push either subject into an optional list merely to reach CUDA or inference performance sooner.

7. I keep 1 roadmap

This repository contains 1 default curriculum. Git preserves older versions, so parallel active and archived roadmap folders only create confusion.

I will not create another competing roadmap directory unless I deliberately decide that I need one.

8. I do not need artificial lanes

Inside the current stage, I can work through 2 or 3 books and choose based on my energy. The stage order protects the prerequisites, but I do not need permanent lanes, percentage splits, daily page quotas, or equal-progress rules.

9. Different books need different reading modes

I will not force every resource into cover-to-cover reading.

I will follow the main teaching sequence and practise when I use a textbook.
I will build the projects when I use a project book.
I will make a structured pass through manuals and pocket guides, then keep them for lookup.
I will read lighter narrative books normally.
I will leave advanced research texts until I have the stated prerequisites.

10. New books need a reason

If I find a real gap later, I can add a resource. Before I do, I need to:

name the missing capability,
show why the current library does not cover it,
propose the smallest useful addition,
check the latest edition,
and make a deliberate decision rather than adding it on impulse.

11. This repository is only for the learning plan

This repository holds the learning journey, curriculum, library decisions, practice rules, and current position. Content production, branding, publishing plans, and unrelated project management belong elsewhere.

My verified position

Active stage: Stage 1.
Active anchor: C Programming: A Modern Approach, 2nd Edition.
Current position: Chapter 6, Loops.
Completed work: all 12 Chapter 6 programming projects are implemented and verified.
Current companion: The Linux Command Line, 3rd Edition.
Current DSA book: Wengrow Volume 1 in Python.
Lighter reading: UNIX: A History and a Memoir.

Checklist before I change the route

The principle behind the plan

I am not trying to assemble the most academically impressive reading list. I am trying to build the most rigorous route I can sustain, practise, and finish.

overview

2026-07-28T13:24:53Z

My learning roadmap

This is the route I am following. It came from comparing 2 earlier roadmaps, auditing 48 books in my library, and ordering the subjects by dependency. The rules that keep this roadmap mine protect the decisions that must survive future revisions.

The rule

I finish the current stage before moving to the next. Inside that stage, I can keep 2 or 3 books active and choose the one that suits my energy.

read → predict → implement → run → test → inspect → explain → continue

Implementation, debugging, testing, and measurement matter more than finishing pages quickly.

Where I am now

I am in Stage 1 at Chapter 6 of K. N. King's C book. I have completed its 12 programming projects and will review the chapter before solving its exercises independently. The current position page records the next concrete actions.

The route

flowchart LR
    subgraph foundations["Foundations"]
        direction TB
        s1["1. C, shell, Python DSA"] --> s2["2. Repeated building"]
        s2 --> s3["3. Modern C and Linux internals"]
    end

    subgraph systems["Systems"]
        direction TB
        s4["4. C++ and Linux APIs"] --> s5["5. Larger programs and deeper APIs"]
        s5 --> s6["6. Memory, kernel, embedded"]
        s6 --> s7["7. Larger C++ systems"]
        s7 --> s8["8. Linux security"]
    end

    subgraph ai["ML and AI"]
        direction TB
        s9["9. ML and deep learning foundations"] --> s10["10. Build an LLM"]
        s10 --> s11["11. Native ML and CUDA"]
        s11 --> s12["12. AI performance"]
        s12 --> s13["13. Reasoning and post training"]
    end

    s3 --> s4
    s8 --> s9

Stage 1: C, shell, Python DSA, and Unix context

Books: C Programming: A Modern Approach; The Linux Command Line; A Common-Sense Guide to Data Structures and Algorithms in Python, Volume 1; UNIX: A History and a Memoir as a light companion.

Finish with: Small multi file C programs built and debugged from the terminal, comfortable shell use, and working Python implementations of the main Volume 1 structures and algorithms.

Stage 2: Repeated building in C, shell, and Python DSA

Books: Tiny C Projects; The Ultimate Linux Shell Scripting Guide; A Common-Sense Guide to Data Structures and Algorithms in Python, Volume 2.

Finish with: Repeated C project work, useful shell automation, advanced Python DSA implementations, matching practice problems, and LeetCode 75 in Python.

Algorithmic Thinking is optional after this stage and never blocks Stage 3.

Stage 3: Modern C and Linux internals

Books: Modern C, 3rd Edition; How Linux Works, 3rd Edition; Linux Pocket Guide, 4th Edition as a structured reference.

Finish with: An explanation of the important changes through C23 and a practical understanding of Linux boot, devices, processes, filesystems, services, libraries, networking, and virtualisation.

Stage 4: Modern C++, Linux userspace APIs, and security oriented Linux

Books: Introducing C++; Linux System Programming, 2nd Edition; Linux Basics for Hackers, 2nd Edition.

Finish with: A normal multi file modern C++ program, tutorial level use of the main Linux userspace APIs, and security oriented Linux operation.

Stage 5: C++ projects, deep Linux APIs, and Kali methodology

Books: Learn C++ by Example; The Linux Programming Interface; Learning Kali Linux, 2nd Edition.

Finish with: Practical C++ projects, deeper Linux systems programs, and a documented introductory security assessment inside an isolated lab.

Stage 6: Memory, kernel programming, and bare metal execution

Books: C++ Memory Management; Linux Kernel Programming, 2nd Edition; Bare-Metal Embedded C Programming.

Finish with: Clear reasoning about lifetime and allocation, basic kernel modules tested in a recoverable VM, and a small embedded program brought from reset to peripheral operation.

Stage 7: Larger and asynchronous C++ systems

Books: C++ Software Design; Asynchronous Programming with C++.

Finish with: A medium sized C++ application with clear ownership, useful abstractions, asynchronous behaviour, tests, sanitizers, cancellation, and clean shutdown.

Stage 8: Offensive and defensive Linux security

Books: The Ultimate Kali Linux Book, 3rd Edition; Mastering Linux Security and Hardening, 3rd Edition.

Finish with: A permission based lab workflow for finding Linux weaknesses and a matching ability to harden, monitor, and recover systems.

Stage 9: Practical machine learning, statistics, and deep learning

Books: Machine Learning with PyTorch and Scikit-Learn as the main practical text; Understanding Deep Learning for theory; Statistics Every Programmer Needs for mathematical support; Why Machines Learn as an intuition companion; The Little Book of Deep Learning as a compact reference.

Finish with: Sound ML experiments, correct validation and metrics, trained and inspected neural networks, and the ability to diagnose basic statistical, modelling, and implementation failures.

Stage 10: Build a large language model from scratch

Book: Build a Large Language Model (From Scratch).

Finish with: A small working tokenizer, transformer, training loop, checkpoint path, evaluation path, and fine tuning path that I can explain rather than treat as a sealed system.

Stage 11: Native ML, CUDA, and GPU performance

Books: Hands-On Machine Learning with C++, 2nd Edition; CUDA Programming Guide, Release 13.3; Understanding Latency Hiding on GPUs after basic profiling experience.

Finish with: Correct and profiled implementations of vector operations, reductions, scans, tiled matrix multiplication, convolution, softmax, layer normalisation, and 1 fused operation. Every optimisation must start from a verified baseline and end with a new measurement.

Stage 12: AI systems performance engineering

Book: AI Systems Performance Engineering.

Finish with: One model profiled across Python, framework, compiler, runtime, CPU, GPU, memory, batching, caching, quantisation, serving, and distributed layers, plus at least 1 native C++ and CUDA extension or equivalent custom operator.

Stage 13: Reasoning models, reinforcement learning, and RLHF

Books: Mathematical Foundations of Reinforcement Learning; Build a Reasoning Model (From Scratch); Reinforcement Learning from Human Feedback.

Finish with: Small scale reasoning and post training experiments covering evaluation, inference time scaling, verification, search, reward modelling, policy optimisation, distillation, preference data, and RLHF.

Decisions I do not need to reopen

Python remains the main DSA language.
Computer Systems: A Programmer's Perspective is not selected because its teaching style does not work for me.
Algorithmic Thinking remains optional.
Rust and database books remain outside the current goal.
The complete 48 book audit contains the detailed evidence and every other selection decision.

Expected duration

The route represents roughly 2,500 to 4,000 productive hours. A strong working foundation may take 15 to 24 months with near full time study or 3 to 5 years with serious part time study. Tools are installed only when their stage begins.

library-audit

2026-07-28T13:24:53Z

The 48-book audit behind my roadmap

I did not want the roadmap to become a list of every technical book I had collected. I audited all 48 relevant candidates in my Calibre library and gave each one a job, an optional place, or a reason to stay outside the route.

The result

Calibre library root: ~/Documents/pkm/02_Areas/Calibre Library
Calibre database: ~/Documents/pkm/02_Areas/Calibre Library/metadata.db
Books and manuals audited: 48
Selected for the default route: 36
Optional reads: 1
Not selected: 11

These counts describe fit. They are not ratings of the books.

How I made the choices

I considered the goal, the prerequisite order, the teaching style, the book's unique value, its overlap with the rest of the route, and whether I was likely to finish it and use what it taught.

The rules that keep this roadmap mine protect the choices that matter most.

What the labels mean

Default, Stage N: I selected it for a specific stage in the roadmap.
Default, reference or light: I selected it, but I will not treat it as a full technical textbook.
Optional read: I may read it, but it cannot block the next stage.
Not selected: It remains in Calibre but is outside the default route.

The complete inventory

Book	Author	My decision	Why	Formats	Calibre record directory
AI Systems Performance Engineering	Chris Fregly	Default, Stage 12	I will use it as the full-stack performance capstone after ML, C++, and CUDA	EPUB	`Chris Fregly/AI Systems Performance Engineering (361)`
Algorithmic Thinking, 2nd Edition	Daniel Zingaro	Optional after Stage 2	I may use it for extra C problem practice, but its selective structure does not replace my Python DSA route	EPUB	`Daniel Zingaro/Algorithmic Thinking, 2nd Edition (330)`
Algorithms, 4th Edition	Robert Sedgewick and Kevin Wayne	Not selected	It is a strong book, but the Java approach overlaps with the Python DSA sequence I prefer	PDF	`Robert Sedgewick, Kevin Wayne/Algorithms, 4th Edition (332)`
Asynchronous Programming with C++	Javier Reguera-Salgado and Juan Antonio Rufes	Default, Stage 7	I need practical work with concurrency, futures, promises, coroutines, and asynchronous systems	EPUB	`Javier Reguera-Salgado, Juan Antonio Rufes/Asynchronous Programming with C__ (360)`
Bare-Metal Embedded C Programming	Israel Gbati	Default, Stage 6	It gives me practical hardware-near C through registers, startup code, interrupts, and peripherals	EPUB	`Israel Gbati/Bare-Metal Embedded C Programming (366)`
Build a Large Language Model (From Scratch)	Sebastian Raschka	Default, Stage 10	I will implement the tokenizer, attention, transformer, training, and fine-tuning path myself	EPUB	`Sebastian Raschka/Build a Large Language Model (From Scratch) (327)`
Build a Reasoning Model (From Scratch)	Sebastian Raschka	Default, Stage 13	It gives the roadmap an applied endpoint in evaluation, inference-time scaling, RL, and distillation	PDF	`Sebastian Raschka/Build a Reasoning Model (From Scratch) (328)`
C Programming: A Modern Approach, 2nd Edition	K. N. King	Default, Stage 1	This is my main C foundation and the clearest example of the teaching style that works for me	PDF	`K. N. King/C Programming (Second Edition) (323)`
C++ Memory Management	Patrice Roy	Default, Stage 6	I want a deeper treatment of lifetime, ownership, allocation, RAII, arenas, and allocators	EPUB	`Patrice Roy/C__ Memory Management (367)`
C++ Software Design	Klaus Iglberger	Default, Stage 7	I will use its design ideas after I have real C++ projects to apply them to	EPUB	`Klaus Iglberger/C__ Software Design (365)`
Computer Systems: A Programmer's Perspective, 3rd Edition	Randal E. Bryant and David R. O'Hallaron	Not selected	I dislike its textbook style, so I will not turn it into a mandatory Stage 3 gate	PDF	`Randal E. Bryant/Computer Systems_ A Programmer's Perspective (331)`
CUDA Programming Guide, Release 13.3	NVIDIA Corporation	Default, Stage 11	I need the authoritative CUDA programming model and a reference I can return to while profiling	PDF	`NVIDIA Corporation/CUDA Programming Guide (329)`
Data Structures and Algorithms in Python	Michael T. Goodrich, Roberto Tamassia, and Michael H. Goldwasser	Not selected	It is broad but more textbook-like than I want, and it repeats the role of the Wengrow sequence	PDF	`Michael T. Goodrich, Roberto Tamassia, Michael H. Goldwasser/Data Structures and Algorithms in Python (333)`
Domain-Specific Small Language Models	Guglielmo Iozzia	Not selected	It is a narrow later specialisation, and the local record appears to be a personalised or prerelease copy	EPUB	`Guglielmo Iozzia/Domain-Specific Small Language Models (for Catie Robert) (398)`
Grokking Relational Database Design	Qiang Hao and Michail Tsikerdekis	Not selected	Database design is useful, but it sits outside the goal of this roadmap	EPUB	`Qiang Hao, Michail Tsikerdekis/Grokking Relational Database Design (400)`
Hacking and Security: The Comprehensive Guide to Penetration Testing and Cybersecurity	Michael Kofler and collaborators	Not selected	I chose focused Kali and Linux-hardening books instead of another broad security reference	EPUB, PDF	`Michael Kofler, Klaus Gebeshuber, Peter Kloep, Frank Neugebauer, Andre Zingsheim, Thomas Hackne/Hacking and Security_ The Comprehensive Guide to Penetration Testing and Cybersecurity (349)`
Hands-On Machine Learning with C++, 2nd Edition	Kirill Kolodiazhnyi	Default, Stage 11, selective	I will use it as a native C++ bridge after Python ML, with attention on runtime and deployment boundaries	EPUB	`Kirill Kolodiazhnyi/Hands-On Machine Learning with C__ (363)`
How Linux Works, 3rd Edition	Brian Ward	Default, Stage 3	This is the readable Linux-internals book at the centre of Stage 3	EPUB, PDF	`Brian Ward/How Linux Works, 3rd Edition (353)`
Introducing C++	Frances Buontempo	Default, Stage 4	It is a current modern C++ introduction and the bridge I need before CUDA and runtime work	EPUB	`Frances Buontempo/Introducing C__ (356)`
Just Use Postgres!: All the Database You Need	Denis Magda	Not selected	Database specialisation is outside the present goal	PDF	`Denis Magda/Just Use Postgres!_ All the Database You Need (401)`
Learn C++ by Example	Frances Buontempo	Default, Stage 5	I want guided project practice after the C++ introduction	EPUB	`Frances Buontempo/Learn C__ by Example (362)`
Learning Kali Linux, 2nd Edition	Ric Messier	Default, Stage 5	It adds testing methodology, analysis, vulnerability work, evidence, and reporting	EPUB	`Ric Messier/Learning Kali Linux (357)`
Linux Basics for Hackers, 2nd Edition	OccupyTheWeb	Default, Stage 4	It gives me a beginner-friendly transition from ordinary Linux into security-oriented Linux and Kali	EPUB, PDF	`OccupyTheWeb/Linux Basics for Hackers, 2nd Edition_ Getting Started with Networking, Scripting, and Security (348)`
Linux Kernel Programming, 2nd Edition	Kaiwan N. Billimoria	Default, Stage 6	I want practical work with kernel builds, modules, tasks, memory, scheduling, and synchronisation	PDF	`Kaiwan N. Billimoria/Linux Kernel Programming, Second Edition (359)`
Linux Pocket Guide, 4th Edition	Daniel J. Barrett	Default, Stage 3 reference	I will use it for a structured command survey and keep it as a permanent lookup resource	PDF	`Daniel J. Barrett/Linux Pocket Guide (358)`
Linux System Programming, 2nd Edition	Robert Love	Default, Stage 4	It gives me a concise first tutorial before I take on the deeper TLPI treatment	EPUB	`Robert Love/Linux System Programming, 2nd Edition (354)`
Linux: The Comprehensive Guide	Michael Kofler	Not selected	It overlaps heavily with Shotts, Ward, Love, TLPI, shell scripting, and the selected security books	EPUB, PDF	`Michael Kofler/Linux_ The Comprehensive Guide (336)`
Machine Learning with PyTorch and Scikit-Learn	Sebastian Raschka, Yuxi Liu, and Vahid Mirjalili	Default, Stage 9	This is my main practical ML foundation in the ecosystem I will later use for LLM and inference work	EPUB, PDF, TXT	`Sebastian Raschka, Yuxi (Hayden) Liu, Dr. Vahid Mirjalili/Machine Learning with PyTorch and Scikit-Learn (283)`
Mastering Linux Security and Hardening, 3rd Edition	Donald A. Tevault	Default, Stage 8	This is my main defensive Linux security and hardening text	EPUB, PDF	`Donald A. Tevault/Mastering Linux Security and Hardening, Third Edition_ A Practical Guide to Protecting Your Lin (347)`
Mathematical Foundations of Reinforcement Learning	Shiyu Zhao	Default, Stage 13 support	I need the relevant formal RL foundation before reasoning and post-training work	PDF	`Shiyu Zhao/Mathematical Foundations of Reinforcement Learning (337)`
Modern C++ Programming Cookbook, 3rd Edition	Marius Bancila	Not selected	The recipe format overlaps with the structured C++ books already in the route	EPUB	`Marius Bancila/Modern C__ Programming Cookbook, Third Edition (364)`
Modern C, 3rd Edition	Jens Gustedt	Default, Stage 3	It updates King's foundation through C23, modern memory, threads, and atomics	EPUB	`Jens Gustedt/Modern C, Third Edition (320)`
Reinforcement Learning from Human Feedback	Nathan Lambert	Default, Stage 13	I want post-training and RLHF depth after the LLM and RL foundations	EPUB	`Nathan Lambert/Reinforcement Learning from Human Feedback (338)`
Rust Web Programming, 3rd Edition	Maxwell Flitton	Not selected	Rust and web specialisation would split my attention from the systems, security, and AI route I chose	PDF	`Maxwell Flitton/Rust Web Programming_ Third Edition (403)`
Statistics Every Programmer Needs	Gary Sutton	Default, Stage 9 support	It gives me practical statistics for sound ML evaluation and experimentation	PDF	`Gary Sutton/Statistics Every Programmer Needs_ Practical Python Implementations and Quantitative Methods (402)`
The Linux Command Line, 3rd Edition	William Shotts	Default, Stage 1	This is my main shell, command-line, and Bash foundation	EPUB	`William Shotts/The Linux Command Line_ A Complete Introduction, 3rd Edition (339)`
The Linux Programming Interface	Michael Kerrisk	Default, Stage 5 deep reference	I will use it as the authoritative userspace Linux and Unix API treatment after Robert Love	EPUB, PDF	`Michael Kerrisk/The Linux Programming Interface_ A Linux and UNIX System Programming Handbook (352)`
The Little Book of Deep Learning	Francois Fleuret	Default, Stage 9 reference	I want a compact conceptual reference beside the practical and full theory books	PDF	`Francois Fleuret/The Little Book of Deep Learning (340)`
The Rust Programming Language, 3rd Edition	Steve Klabnik, Carol Nichols, and Chris Krycho	Not selected	It is a good language book, but Rust is outside my current route	EPUB	`Steve Klabnik, Carol Nichols, Chris Krycho/The Rust Programming Language, 3rd Edition (399)`
The Ultimate Kali Linux Book, 3rd Edition	Glen D. Singh	Default, Stage 8	It gives me the main practical offensive-security lab progression	EPUB	`Glen D. Singh/The Ultimate Kali Linux Book, Third Edition_ Harness Nmap, Metasploit, Aircrack-ng, and Empire (344)`
The Ultimate Linux Shell Scripting Guide	Donald A. Tevault	Default, Stage 2	It extends Shotts into practical scripting, text processing, interfaces, and debugging	EPUB	`Donald A. Tevault/The Ultimate Linux Shell Scripting Guide (355)`
Tiny C Projects	Dan Gookin	Default, Stage 2	It turns C syntax and exercises into repeated finished programmes	EPUB	`Dan Gookin/Tiny C Projects (319)`
Understanding Deep Learning	Simon J. D. Prince	Default, Stage 9	This is my main rigorous deep-learning theory foundation	PDF	`Simon J.D. Prince/Understanding Deep Learning (341)`
Understanding Latency Hiding on GPUs	Vasily Volkov	Default, Stage 11 advanced	I will use it for deeper latency, occupancy, and GPU-performance reasoning after practical profiling	PDF	`Vasily Volkov/Understanding Latency Hiding on GPUs (342)`
UNIX: A History and a Memoir	Brian W. Kernighan	Default, Stage 1 light	I want the history connecting Unix, C, tools, shells, and the culture around them	EPUB, PDF	`Brian W. Kernighan/Unix_ A History and a Memoir (368)`
Why Machines Learn: The Elegant Math Behind Modern AI	Anil Ananthaswamy	Default, Stage 9 light	It gives me a readable intuition companion for the mathematics behind ML	EPUB	`Anil Ananthaswamy/Why Machines Learn_ The Elegant Math Behind Modern AI (343)`
A Common-Sense Guide to Data Structures and Algorithms in Python, Volume 1	Jay Wengrow	Default, Stage 1	This is the approachable DSA foundation that fits my preferred language and teaching style	EPUB	`Jay Wengrow/A Common-Sense Guide to Data Structures and Algorithms in Python, Volume 1_ Level Up Your Core (351)`
A Common-Sense Guide to Data Structures and Algorithms in Python, Volume 2	Jay Wengrow	Default, Stage 2	It continues the Python DSA route and leads into LeetCode 75	EPUB	`Jay Wengrow/A Common-Sense Guide to Data Structures and Algorithms in Python, Volume 2_ Level Up Your Core (350)`

Edition checks

My King PDF is the 2nd edition and predates C11. Modern C, 3rd Edition supplies the C23 update later.
My copy of The Linux Command Line is the 3rd edition dated 2026.
My Linux Pocket Guide is the 4th edition.
My Introducing C++ is the March 2026 O'Reilly edition.
My Hands-On Machine Learning with C++ is the 2nd edition with 2025 material.
My CUDA guide is Release 13.3, dated 27 May 2026.
My Build a Reasoning Model PDF contains 2026 material.

Decisions I want to preserve

Python remains my main DSA and LeetCode language.
Algorithmic Thinking remains optional.
CS:APP remains unselected because its teaching style does not fit me.
Security and reasoning-model work remain in the default route.
The C++ cookbook and broad Hacking and Security book remain outside the route.
Content-production planning remains outside the curriculum repository.

Keeping the library intact

The Calibre library is read-only during curriculum work. I will open and manage books through Calibre rather than rename, move, or edit its record directories by hand.

history

2026-07-28T13:24:53Z

How I arrived at this roadmap

The current plan came from 2 earlier attempts. Git preserves both versions, but I no longer keep them as competing folders because I want 1 route I can follow without reopening the same decision every week.

The first attempt: a broad 28-book route

My first roadmap tried to hold the full range of subjects that drew me in:

C
Linux command-line work
Python DSA
modern C++
Linux system and kernel programming
embedded C
offensive and defensive security
CUDA
LLMs
reasoning models

It reflected what I wanted to learn. It kept Python DSA, security, and reasoning models in the main sequence, and it let me move among a few books inside each stage.

The gaps became clearer when I looked at the route as preparation for real AI systems work. It did not give me a complete practical ML and deep-learning foundation before LLM and inference work. It also blurred the difference between CPU asynchrony, CPU data parallelism, CUDA kernels, and full-stack inference performance. Some broad references were treated as if every selected book needed the same cover-to-cover reading method.

The second attempt: a low-level performance route

The second roadmap narrowed the route towards C, systems, embedded work, C++, machine learning, CUDA, and AI performance.

This version fixed several technical problems. It added practical ML and deep-learning foundations, improved the dependency chain into CUDA, separated Python orchestration from C++ runtimes and GPU kernels, and treated manuals as references rather than ordinary textbooks. It also forced me to audit all 48 local candidates instead of stopping at the books I had already noticed.

The technical order improved, but the plan stopped fitting the person who had to follow it.

It made Algorithmic Thinking my main DSA route even though I had chosen Python and disliked the book's selective structure as a primary course. It made Computer Systems: A Programmer's Perspective mandatory even though I had already rejected its presentation. It also pushed security and reasoning-model work outside the default path to shorten the route towards performance.

That version optimised the abstract destination and ignored too much of what would keep me moving.

The route I am following now

The current roadmap keeps the useful parts of both attempts.

From the broad route, I kept:

Python DSA through both Wengrow volumes
LeetCode 75 in Python
security in the main sequence
reasoning models and RLHF as the endpoint
a simple stage-based way of working

From the performance route, I kept:

full practical ML and deep-learning foundations
modern C++ before CUDA
a clear separation between userspace, kernel, embedded, CPU async, CUDA, and inference performance
selective use of manuals and references
the full 48-book audit
measurement as the centre of the performance stages

I also corrected the choices that did not fit me:

Algorithmic Thinking is optional.
CS:APP is not selected.
Owning a book does not make it mandatory.
Security and reasoning models remain inside the default route.
The repository contains 1 default roadmap.
Content-production work stays outside this repository.

The shape of the plan

C + shell + Python DSA
-> repeated building
-> modern C + Linux internals
-> C++ + Linux userspace APIs + security Linux
-> C++ projects + deep Linux APIs + Kali methodology
-> memory + kernel + embedded
-> larger asynchronous C++ systems
-> offensive and defensive security
-> ML + statistics + deep learning
-> build an LLM
-> native ML + CUDA + GPU performance
-> AI systems performance
-> reasoning models + RL + RLHF

How I will revise it

I expect the plan to change as I learn more, but I do not want every new book or opinion to send it back to the drawing board. Before changing the route, I will:

read LEARNER_REQUIREMENTS.md,
update the root roadmap rather than create another competing copy,
explain why the existing sequence no longer fits,
preserve my explicit decisions unless I have changed my mind,
update every affected root document together,
and record the revision in Git.

The roadmap can evolve. It still needs to remain 1 plan.

about

2026-07-28T13:24:53Z

About

I use this site to keep a public trail of what I am learning, building, and trying to understand.

Right now, I am following a 13-stage route from C and Linux through machine learning, CUDA, AI systems performance, and reasoning models. The Roadmap records where I am, what I chose, what I left out, and what I expect to build before moving on.

Longer notes and essays appear under Writing.