a quick backstory

back when i was in high school, i still remember that first year. and the years before it. i had no real interest in studying what we were learning. naturally, i performed very badly.

truth be told, i just didn’t like it. i didn’t see the point. later on, during the years that actually mattered most — the final two years of high school, it caught up to me.

my idea was: “this stuff is boring and pointless. i don’t care. i’ll just focus during the last two years.”
so after that first year, where i ended up among the last five students in class, i decided over the summer: okay, let’s actually try to study.

once i started watching online lectures, mostly in math and physics, the only two subjects i actually found interesting, i noticed something. the professor would use a technique or reference a concept and just assume it was common knowledge.

that’s when i came to a simple realization: i didn’t have the prerequisites.

so i closed that lecture and opened another one, aimed at younger students. i kept going back as far as i needed to, until i landed on a lecture where i genuinely understood everything the professor was doing. then i built my way back up.

this was such an interesting experience. on the surface, it might look like a lazy student trying to catch up on missed concepts. but it was more than that. it made me realize something deeper.

all this “hard stuff,” all these topics that make you go “i have no fucking idea how people understand this”, they’re not unreachable. you just need the right prerequisites. once you get them, everything clicks. the satisfaction is the same as solving a puzzle.

if you're wondering how this actually ended, i hit the goal.
perfect scores across all three subjects that mattered to me.
24 tests. average: 19 to 20 out of 20. =)

a way to see learning new things

think of learning like recursion. when you don’t understand something, you don’t brute-force your way through it. you recurse. you find the missing base case.

let’s say you’ve built http servers. that already implies a stack of knowledge:
you understand request/response models.
you know what a tcp handshake is.
you’ve parsed headers, serialized json, maybe even dealt with mime types.
you’ve seen how a server binds to a port, how routing works, how a client connects over a socket.
you probably have mental models of status codes, http methods, maybe even idempotency and caching semantics.

this is your context. your foundation.

so when you learn something like grpc, you’re not starting from zero — you already understand that under the hood, it’s still riding http/2, using persistent streams, leveraging headers for metadata, and serializing with protocol buffers instead of json. your mind doesn’t freeze. it maps new abstractions onto known territory.

but try jumping into os-level concepts like virtual memory, page faults, or syscall dispatch without the underlying knowledge, and you’ll drown.
because your stack is broken.
you don’t yet understand what a process is, how context switching works, how the kernel mediates access to hardware, or how memory gets mapped to address space. so you can’t climb. you have to recurse.

you go deeper:
→ what is a syscall?
→ how does user mode transition to kernel mode?
→ what does the int 0x80 instruction do on x86?
→ how are memory pages structured?
→ what even is a page?
etc, follow your curiosity. and never stop asking questions.

at some point, you’ll hit a point where the concepts stop being alien. that’s your base case. from there, you start building back up, one layer at a time.

this is why people say “the beginning is the hardest.”
it’s not hard because the material is hard.
it’s hard because you’re trying to recurse without a base case. (well, except your own logic)
once you find it, the rest is just function calls on top.

why is this mindset useful?

once you shift from awe to analysis, the path becomes clearer. instead of seeing a project and thinking “i could never build that”, you start asking “what does this actually require?” and when you break it down, most of it is just a chain of knowables.

they built a compiler? that means they understand parsing, lexical analysis, maybe intermediate representations. which implies knowledge of data structures, tree traversal, memory layout, and instruction sets. if the compiler targets a vm, they probably understand bytecode execution. if it targets native code, they know assembly and how the cpu works.

what looks like a towering skillset is really a deep chain of connected nodes. and once you see that, you realize you’re not blocked by talent — you’re just blocked by unresolved dependencies.

that’s why this mindset matters. because recursion doesn’t just explain how we learn — it explains why progress feels impossible until it isn’t.
resolve your base cases. the rest unfolds.