There was a time when I thought I needed to learn everything before I could start building anything. I figured real programmers knew all the algorithms, wrote perfect SQL queries in their sleep, and could probably implement a compiler before breakfast. I imagined they had mastered the fundamentals, whatever that meant.
So, I did what any overwhelmed newbie would do. I bought a massive algorithms book, started watching deep dive videos on operating systems, and spent a ridiculous amount of time trying to understand how compilers worked. And you know what? I built absolutely nothing.
It turns out, focusing on “the fundamentals” first is a great way to never get started at all.
The Myth of “The Fundamentals”
Ask a senior developer what the fundamentals are, and you’ll get different answers depending on their background. Some will say it’s data structures and algorithms. Others will insist it’s memory management. A web developer might tell you it’s knowing how the browser works, while a backend engineer might swear by database optimization.
The truth? It depends on what you’re trying to do.
I once met a software engineer who had built and sold multiple mobile apps. He had no idea how a hash table worked. Another friend of mine writes some of the cleanest, most maintainable code I’ve seen, yet he wouldn’t be able to whiteboard a binary search tree to save his life. And then there are developers who can wax poetic about the efficiency of quicksort but haven’t deployed a single production application.
So, which of these people actually know the fundamentals?
Learn by Doing, Not by Studying
A few years ago, I was building a web app that needed real-time updates. I had no clue how WebSockets worked, but I knew that if I wanted to get my app to behave the way I needed, I had to figure it out. So, I did what every programmer does—I Googled. I found some examples, copied code from Stack Overflow, and hacked together a working solution.
Did I understand all the inner workings of WebSockets at the time? Absolutely not. But did I solve the problem and learn something valuable along the way? Yes.
This is how real learning happens. You build things, you hit roadblocks, and you learn what you need when you need it. Instead of memorizing abstract concepts, you’re applying knowledge in a meaningful way.
If you wait until you’ve “mastered the fundamentals” before you start coding, you’ll be stuck in tutorial hell forever.
Fundamentals Are Contextual
Here’s another example. Let’s say you want to build a simple mobile app that tracks your daily habits. Should you start by learning about low-level memory management? Probably not. Should you spend weeks studying how the Android rendering pipeline works before writing a single line of code? Definitely not.
What you actually need is a basic understanding of UI components, state management, and how to store data. As you build, you’ll naturally run into situations where you need deeper knowledge—maybe you need to optimize battery usage, so you learn about background processes. Maybe your UI lags, so you learn about rendering optimizations. The key is that you learn these things when they become relevant, not before you’ve even started.
Fundamentals Find You
Let’s be clear: I’m not saying that things like algorithms, data structures, and performance optimizations aren’t important. They absolutely are. But you don’t need to stress about learning them all upfront.
Instead of worrying about what the fundamentals are, focus on building things. Pick a project, start coding, and let the problems you encounter guide your learning. The fundamentals will find you when you need them.
If I could borrow a Bible saying, “Seek first the kingdom of God and all these things shall be added unto you,” then in programming, the equivalent would be: Start building first, and all the fundamentals will be added unto you. When you immerse yourself in real projects, the gaps in your knowledge become clear, and you naturally fill them in as needed. You don’t need to hunt them down—they come looking for you.
So, the next time someone tells you to focus on the fundamentals, just smile and nod. Then go write some messy code, ship something broken, and learn along the way.
