You realize that learning technologies, like React and Node, isn’t enough. So you want to enhance your skills and deepen your knowledge by learning the fundamentals of programming.
But you have some questions:
- What are the fundamentals of programming?
- What topics should I focus on first?
- Which resources are best?
You’re not alone. These are some of the questions I’ve repeatedly asked on my own self-taught journey. What I needed most was a roadmap.
I didn’t have one, so I created it: Programmer’s Pyramid.
This free, self-guided learning tool teaches you the fundamentals of programming. It defines what you need to learn and the sequence to learn it. It also provides the resources you need and explains how to go about learning the material.
As a result, you’ll build a solid foundation of knowledge and develop core skills, which will enhance your abilities as a programmer and prepare you for more advanced study.
Finally, there’s a clear and accessible process for learning to program.
Programmer’s Pyramid was created out of a need—my own.
Learning to program for me felt like a black hole. The more I learned, the more I realized there was to learn. I had a hard time identifying what to learn first and how to learn it.
Given these early roadblocks, I spent a lot of time learning how to learn, vetting resources, and studying great programmers. I knew there had to be a better—more effective—way to learn to program.
So I began sharing my ideas about learning to program effectively on my blog: learning strategies, useful programming resources, and important programming skills to develop. In the process, I found out that there were a lot of people just like me. We’re fighting the same fight: we want to get better at our craft, and need an effective way to go about it.
Programming is a fantastic skill to develop. But the learning process shouldn't be so ambiguous and complex. Enter Programmer’s Pyramid.
Getting lost in the details—all of the details—of whatever I was learning about was a mistake I commonly made. This slowed my progress and added to my frustration. Everything seemed important in the moment. But in hindsight it wasn’t.
While challenging to go through, a critical lesson was learned: the details make a lot more sense once the core structure is in place. Elon Musk puts it best:
“It is important to view knowledge as sort of a semantic tree — make sure you understand the fundamental principles, i.e. the trunk and big branches, before you get into the leaves/details or there is nothing for them to hang on to.”
That’s why the core comes first in Programmer's Pyramid.
Programmer’s Pyramid advocates a bottom-up approach for learning to program. The idea is to build a solid foundation—starting with the fundamentals.
This approach runs counter to a trendy approach today. I call it the top-down approach. It’s when programmers start at the top of the Pyramid and focus almost exclusively on technologies. Programming fundamentals are an afterthought, if they’re addressed at all.
This is a problem.
The top-down approach bypasses many important programming topics and skills, and results in a shaky foundation of knowledge.
It’s not to say that you don’t need technologies. You do. However, the fundamentals come first for this reason: the fundamentals are the enabler.
They enable us to use technologies better.
They enable us to write better—more effective—programs.
They enable us to become more versatile and adaptable.
Above all, the fundamentals enable us to become better programmers.
Programming is a skill. The way to build a skill of any kind is to break it down and focus on its core parts.
Experts in many fields have followed this precise recipe. Think of Josh Waitzkin of chess or Kobe Bryant of basketball: both focused relentlessly on the fundamentals.
And so does Programmer’s Pyramid. It clearly delineates what the fundamentals of programming are, and equally important, when and how to learn them. The pyramid shape gives learning its structure: start at the base and work your way up.
What you need to focus on—the fundamentals of programming—is only half of the battle. The other is how to learn them.
Programmer’s Pyramid advocates an active approach to learning, a method that I call apply first, study second.
The idea is to try solving the problem or writing the program first. You don't have to get the correct solution. Rather, it’s all about the attempt: see how far you get before you get stuck. In other words, find the roadblock. If you get stuck, then reference a book or course and focus on that specific roadblock.
There are several reasons why this approach works. First, it brings awareness to something specific that you're having trouble with.
Say you start a problem and get stuck using a while loop (why won’t it terminate?!). By trying the problem first, you’ll use the resource with purpose. Rather than mechanically cycling through lectures, only focus on the ones that will get you unstuck. So in this example, you'd zone in on while loops, and infinite loops in particular.
Consequently, your learning process will be much more efficient. We often sit through video lectures listening to content that we already know. Or we inundate ourselves with details—ones that aren’t relevant to us now. Instead of focusing on everything, with the apply first, study second approach you focus on one thing and nail it.
Learning is also much more meaningful with this approach, at least in my experience. That’s because when you watch a lecture or read a book you'll have a specific situation in mind to tie the information back to.
When you need more details, then get the details at that time. Otherwise, there’s a good chance you’ll forget them. “In very short order we lose something like 70 percent of what we’ve just heard or read,” explain the authors of the book, Make It Stick.
This gets at another reason why apply first, study second works: you’re bound to retain the information better because the learning process is active, not passive. Even if you don’t solve the problem on your first attempt, you’ll probably remember the process. That’s because we often remember the times we struggle.
For example, I vividly recall my first half-marathon. I struggled through it because I didn’t train for it properly. Although it was difficult to endure in the moment, I learned so much from that race—key lessons that I still hold with me today. I didn’t learn from passively watching a lecture on how to run a race. Instead—and this is the important point—I learned by taking action: I showed up on race day and ran the race.
For these reasons, Programmer’s Pyramid champions the apply first, study second approach. Each topic within the Pyramid contains two parts: “Reference” and “Apply It”. Try a problem from the “Apply It” section first. Then, consult a course, book, or article in the “Reference” section if you get stuck.
My mission is to help programmers learn to program effectively. Yes, there’s a lot of programming information to learn. But when you have the what and how in place, your journey becomes a lot smoother. It starts with a solid foundation and effective learning habits. That’s what Programmer’s Pyramid aims to deliver.
Originally published on amymhaddad.com.