The Long Climb
There are no shortcuts here, and this plan refuses to pretend otherwise. Most 'learn it in 30 days' paths keep you moving while quietly teaching you to repeat instead of reason — you finish with the feeling of knowing and none of the substance. This is the opposite. You build the machine from the switch upward, derive every number yourself, and write a great deal of real code, because understanding is a side effect of building and fluency is a motor skill. Year one lays an unshakable foundation across five interlocking paths. It is the base camp of a multi-year climb — and it is real.
Computers, x86-64 assembly and C, learned as one thing — to the bone.
prove it: Build a working program in C from nothing and read its every instruction in disassembly.
The language of everything: proof, linear algebra, calculus, probability — in code.
prove it: Derive linear regression from probability, then code it — least squares as maximum likelihood.
Fluency forged by volume: data structures and algorithms built from scratch.
prove it: Design and build a non-trivial program from spec to tests, entirely your own.
From the math up: gradients, classical ML, a neural net and autograd you write yourself.
prove it: Train a real model end to end — after building the neural net and autograd engine by hand.
The machine, weaponized — binary exploitation, web, network, reverse engineering.
prove it: Exploit a vulnerable program you understand completely, from overflow to shell.
Your 42 cursus projects — libft, ft_printf, get_next_line, push_swap and beyond, each taught and specced.
prove it: ft_transcendence — a full-stack, real-time web app, the end of the 42 core.
How the universe actually works — motion, energy, waves, fields, heat, relativity, and quantum, built on your math.
prove it: Simulate a real physical system from the equations of motion up.
The endgame of offense — total takeover: privilege escalation to root, ring-0 rootkits, weaponized documents, DoS/DDoS, advanced C2. Unlocks only after Offensive Security is complete. Your own lab, CTF & authorized engagements only.
prove it: Chain everything: breach an isolated lab, escalate to root, and own the whole network.
They aren't five separate courses — they're one understanding with five faces. You meet the stack building the spine; you own it overwriting a return address in hacking. Linear algebra is dry until it's the forward pass of a net you wrote. Nothing is taught in isolation because nothing is isolated.
The same loop, every day. This — not the module list — is what actually makes you good.
- 1One spine lesson, to the bone
Not skimmed. You leave able to predict a case the lesson never showed you.
- 2Write real code
Fingers on keys. You implement it, you don't watch someone implement it. This is where fluency is actually built.
- 3One hard problem
Math or algorithms, attempted with no hints first. The daily rep that builds the problem-solving muscle.
- 4Close the loop
Read back what you built, log what you learned, and name what you'll predict tomorrow. Spaced review keeps nothing decaying.
Real hours, not thirty-minute snacks. The paths run in parallel and spiral — you don't finish one to start the next.
| When | Center of gravity | Also running | Daily |
|---|---|---|---|
| Months 1–3 | Spine — bits → logic → architecture → assembly → C from the metal | Math (proof & discrete) · the daily problem | 2–3 hr/day |
| Months 4–6 | Spine — memory, the heap, the OS · Hacking begins (binary exploitation) | Math (linear algebra) · Code (data structures) | 3 hr/day |
| Months 7–9 | Hacking — exploitation & systems · AI — ML from scratch | Math (calculus, probability) · Code (algorithms) | 3–4 hr/day |
| Months 10–12 | AI — deep learning & autograd · Hacking — advanced · capstones | Everything, deeper | 3–4 hr/day |
Not “familiar with.” Able to do it, from nothing, and defend every layer.
Read a small binary's disassembly and explain each instruction. Write C that compiles in your head.
Reason fluently about memory — stack, heap, pointers. Implement any core data structure from scratch. Prove a theorem by induction.
Exploit a vulnerable program you fully understand. Derive and code gradient descent. Implement classical ML by hand.
Build a neural network and an autograd engine from nothing. Own a return address on a program you wrote. Read any small binary. The foundation is complete.
Never use a layer before you understand the one beneath it. Pointers after memory. Functions after the stack. Neural nets after gradients.
You construct the thing — an adder from gates, an allocator, an autograd engine, a shell — instead of watching someone use one. Understanding is the side effect.
Every number comes from reasoning you can redo. You are never told 'the offset is 72'; you derive 72 from the frame, every time, until it's obvious.
A lesson's goal is a mental model that predicts what happens next — not a sequence of commands that worked once.
Nothing is taught 'for later.' Learn a register, use it the same sitting. Motivation is structural, not decoration.
The three deep ideas — representation, memory, abstraction — return again and again at greater depth, from the first bit to the last exploit.
Tasks make you assemble the answer from what you were just taught. Never a step you weren't given; the reach lives in 'stretch.'
You write a lot of real code. You cannot read your way to fluency any more than you can read your way to playing piano.
Year one is the foundation, not the summit. Real mastery is a three-to-five year climb — that's the honest number, and you're here for it. What comes after the foundation is specialization, chosen once you know enough to choose well: kernel internals, advanced binary exploitation, research-grade AI, compilers, cryptography, or a domain that pulls you. Those are deliberately parked. Depth first. Breadth is earned, never front-loaded.
start the climb — day one of the spine