When I first started studying computer science, I underestimated how much writing things down could help me learn to code. I thought: “Why bother with a notebook when everything’s online and can just make notes in Notion anyway?” But then I realized... computers remember syntax, I have to remember logic.
I like the idea that keeping a notebook while learning programming is old-fashioned, but... it’s also a tool for developing what computers don’t have: understanding.
I liked those black and white marble composition notebooks my father had when I was little, it looked so college-level, so interesting... Here's where you can find it though.
This is not advertisement, by the way.
Let’s go!
Writing forces you to think in algorithms, not just code
When you’re taking notes by hand (or even digitally, but intentionally) you’re translating information.
If you write:
for i in range(n):
sum += arr[i]
you might also note:
“This iterates n times -> linear time O(n). Used for aggregations like sum or count.”
That small reflection helps your brain move from syntax to semantics, from “how to write” to “why it works.” You start thinking like a compiler and a mathematician: step-by-step, deterministic and analytical, which is the core skill of a computer scientist.
A notebook builds a second brain for debugging
When debugging, patterns emerge. Maybe you forgot to close parentheses in Python. Maybe your Java variable went out of scope again. You can note it like this:
“Common bug: off-by-one error when iterating to len(arr) instead of len(arr)-1.”
After a few weeks, your notebook becomes a personal bug database tailored to your weaknesses and growth areas; and when something breaks, you consult your own mind with your own notes! This is where you learn AGAIN! How cool is that?
That’s what separates a student from a developer: debugging from memory.
It trains long-term retention (apart from short-term recognition)
Reading code online gives you recognition memory: “I’ve seen that before.”
Writing gives you recall memory: “I can explain that from scratch.”
This matters because programming is cumulative. If you forget recursion when you hit data structures, or pointer arithmetic before operating systems, you’ll constantly rebuild foundations instead of expanding them.
A notebook acts like spaced repetition in disguise, each review session strengthens your mental model.
You start building mental models
Mathematics is about structure. Programming is obviously related too (don't forget to study mathematical thinking when studying programming though).
When you write notes, you can visualize relationships between ideas:
Stack <-> Function calls
Heap <-> Dynamic memory allocation
API <-> Interface between abstraction layers
Drawing diagrams, mapping flowcharts, or writing your own version of a concept like “how the OS handles threads” creates internal architecture. And plus, it kinda makes you look cool. Sometimes. As long as nobody understands your hand-writing.
You stop thinking in terms of “what’s the correct command?” and start thinking, “what’s the mechanism?”
That’s computer science.
You can version-control your knowledge
Here’s the fun part: treat your notebook like a repository.
Each date or concept = a commit
Each correction = a refactor
Each realization = a pull request from your future self
Some people even use markdown + GitHub to version-control their notes (I do too). Others go analog with pen and paper, which, by the way, reduces distractions and helps focus deeply. Either way, the principle stands: your knowledge deserves versioning and insights.
Don't forget to also specify the date you're writing, though.
You’ll write better code because you’ll explain better
Explaining code on paper (even just to yourself) trains your internal “compiler.”
Every time you write something like:
“Recursion is just a function calling itself with smaller subproblems until it hits a base case.”
You’re not taking notes. You’re rehearsing how to explain the concept — which means you’re internalizing it.
The best programmers I’ve met aren’t those who type fast. They’re the ones who can explain why their code works with the calm precision of a philosopher.
In practice: What to put in your programming notebook
Definitions: Clear, mathematical explanations (“Polymorphism: the ability of different data types to be accessed through the same interface.”)
Code patterns: Reusable snippets with notes on when/why to use them
Debugging logs: Notes on mistakes and how you fixed them
Diagrams: Memory models, flowcharts, data structure visualizations
Reflections: What you learned, what confused you, and how you solved it
Keep it structured but human — your notebook is not a documentation file; it’s a dialogue with your future self.
I have kept a personal journal since 2020 only to write down my personal thoughts, and it is always fun to run to it just to save a memory, an idea, a feeling or something that reminded me of that present moment for my future self: I do the same when it comes to programming. It's weird, probably dumb, but I like it. I'm a geek after all. We are all, indeed.
Final Thought
A programmer’s notebook is a mirror of your thinking process. Over time, you’ll see how your logic evolves, how your clarity sharpens, and how you move from “writing code” to understanding computation.
Remember computers store data.
Programmers store understanding.
So keep writing your understanding line by line!
Top comments (0)