The Bottom-Up Approach

Have you ever seen a tree that’s strapped to the ground?

There’s a reason for the straps: the tree has no roots; no foundation. Without straps, the tree would fall over. This is what happens when you start with the end product, which I refer to as the top-down approach.

When applied to programming, it’s when people start at the top of the Pyramid and focus almost exclusively on technologies, like React or Node. This has become a popular practice. The fundamentals of programming are a mere afterthought, if they’re addressed at all.

That’s a problem. Heading straight to the technologies bypasses a number of core programming topics and skills. As a result, programmers build a shaky foundation of knowledge.

That’s why Programmer’s Pyramid advocates a different approach, which I call the bottom-up approach. It focuses on the fundamentals of programming.

Think about it this way: an aspiring basketball player could start their career by playing a bunch of games. This is the top-down approach to learning the game of basketball. Sure, they’d see improvement and learn the game—up to a point.

Or the player could take the bottom-up approach and nail the fundamentals, like shooting, dribbling, and ball-handling, in addition to playing games. They’ll play the game better because they’ve sharpened their skills and honed their craft.

Indeed, the end product does matter. Just like a basketball player needs to play games, you undoubtedly need to learn technologies to use in your daily work. But—this is the important point—the fundamentals are the enabler.

They enable us to use the technologies better. They enable us to write better—more effective—programs. They enable us to become more versatile and adaptable. They enable us to become better programmers.

The Roots Come First

The alternative to a tree that’s strapped to the ground is one that begins as a seed. It builds roots from the start, which become really strong over time. No straps are needed because it has a solid foundation. The roots come first, then the end product. It’s the bottom-up approach: start small and steadily build a solid foundation over time.

The bottom-up approach permeates many aspects of life. It’s how we progress as humans: from baby to child to adolescent to adult. We first learn to crawl. Then walk. Then run.

This idea has been applied by experts in other fields, too. Think Michael Jordan and Kobe Bryant of basketball; Julia Child of cooking; Pablo Picasso of art; or Josh Waitzkin of chess.

What do these individuals have in common? In addition to the success achieved in their respective fields, each focused on the fundamentals of their craft.

Programming should be no different. After all, it's a skill. The way to build a skill of any kind is to break it down and focus on its core parts. Programmer’s Pyramid does just that.

Build It and Retain It

In order to build this solid foundation, Programmer’s Pyramid advocates an active approach to learning. It's a method I call apply first, study second. Try solving the problem or writing the program first. Then, consult a course, book, or article if you get stuck.

“Apply first, study second” runs counter to how most of us got through school, where we’d sit through a lecture, then do our homework. But inundating ourselves with information from the start isn’t useful for this reason: the information doesn’t stick.

“In very short order we lose something like 70 percent of what we’ve just heard or read,” argue the authors of the book, Make It Stick. Moreover, this isn’t an effective use of time. Although there’s a lot to learn, you don’t need to know everything right now.

For these reasons, the Pyramid champions a targeted and active approach to learning from the start. Each topic in the Pyramid has two parts: “Reference” and “Apply It”. Try a problem from the “Apply It” section first. You don’t have to successfully solve the problem, just try it.

There’s much to gain by attempting the problem before you study the content. First, trying brings awareness to a specific roadblock. For example, you try solving a problem and get stuck trying to implement a while loop.

Now that you’ve identified the roadblock, pivot to a resource in the “Reference” section to learn about this specific topic. The point is this: you reference a resource with purpose. Instead of trying to learn everything, you’ve narrowed your focus to one thing, and nailing that one thing.

Second, you’ll retain the information better. We often remember the times we struggle. (Remember how hard it was to complete that workout? Remember how hard it was to write that twenty-page research paper?)

“When you’re asked to struggle with solving a problem before being shown how to solve it,” according to Make It Stick, “the subsequent solution is better learned and more durably remembered...when you’re then shown the solution, a light goes on.”

Third, and perhaps most important of all, by attempting a problem first, you’ll build what I call your “programmer’s intuition.” You’ll begin to spot patterns and make connections as you bend existing knowledge in new and different ways.

You may not solve the problem on your first attempt, but you’ve identified what data structure you need and realize why you need it based on a related problem you solved a few weeks ago. These are big strides. You’re spotting patterns. You’re making connections. You’re building your programmer’s intuition.

Admittedly, watching video tutorials is easier than solving problems. But easier isn’t better when it comes to learning. "When the mind has to work, learning sticks better," Make It Stick explains.

If you want to retain the information and get the most from your time, then "apply first, study second" is the approach I suggest. In my experience, it’s not only a more efficient and effective learning strategy. But it's also a lot more fun to solve interesting problems than crank through a bunch of lectures.

The quicker you get to “doing” the better the learning. Make your learning active.