DEV Community: Amy Haddad

Level Up your Programming with Programmer’s Pyramid (it’s free!)

Amy Haddad — Mon, 22 Mar 2021 16:35:55 +0000

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.

We’re Fighting the Same Fight

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.

Your Learning System

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.

The Bottom-Up Approach to Learning to Program

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.

Lay the Foundation: Focus on the Fundamentals

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.

Crush the Content

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.

Programmer and writer: amymhaddad.com | programmerspyramid.com | I tweet about programming, learning, and productivity @amymhaddad

Originally published on amymhaddad.com.

Why Reading Code Matters (and how to get better at it)

Amy Haddad — Mon, 01 Mar 2021 17:02:28 +0000

It strikes me as odd. We’ve heard the same messages: Write clean code. Write readable code. Write meaningful code.

I agree with these sentiments. But all the talk about writing code overshadows another critical skill: the ability to read it.

This is odd to me because so much of our time as programmers is spent reading code:

debugging your code or someone else’s,
picking up a project mid-stream, or
receiving some starter code for a project or problem to complete.

More to the point, reading code can help you become a better writer of it.

An Important Skill

When I began writing articles, I repeatedly got the same advice for self-improvement: write a lot and read a lot. That’s right, read a lot.

So that’s what I did (and still do). I read—a lot. I read to learn. I read to better understand grammar. I read to understand how to structure and design a sentence, paragraph, and article.

Now, as a programmer, I read code for similar reasons. I read code to enhance my programming knowledge and learn how to design better programs.

As I see it, in both cases, reading is just part of the job. You need to continually read in order to continually improve your skills as a writer of prose or code.

Reading vs Doing

Writing code and reading it are two different skill sets. Athletes make the distinction clear.

You’ll often hear about athletes who watch their game films. At first it seems like a basketball player isn’t getting any better when glued to the television watching last night’s game. After all, they’re watching the game, not playing it.

However, there's a good reason why they do it: to get better at reading the game. As a result, they start seeing patterns.

They see the opening to take the three-point shot, which they passed up at the end of the quarter. They pick up tricks from the all-star point-guard on the opposing team. In short, they evaluate their own performance and see room for improvement.

The “reading” informs the “doing.” So when the next practice or game rolls around, they’ll apply what they learned from “reading” the films.

Reading Informs Writing

Reading code is like an athlete who watches their game films. There’s a lot to gain when you become a vast reader.

1. See patterns. Train your mind and eye to spot situations to use a particular algorithm, function, or data structure. If you encounter a problem that uses reduce(), there’s a good chance that you’ll encounter another problem that’ll use it.

When you read code, you familiarize yourself with such situations. So when you work on a related problem in the future, you’ll recognize the pattern and know what to reach for.

2. Learn new strategies to solve the same problem. I solved one problem using a list of dictionaries. Then I read the code of another programmer who solved the same problem, but he used defaultdict. It turned out to be a much better approach. Same problem, new trick.

3. Improve code design. It’s been said that easy reading is hard writing. That’s true for writing both prose and code.

When you read code written by a great programmer, see how easy it is to read. Variables are well named. Each function has its purpose. It’s effortless reading in part because it’s a well-designed program. It’s something to strive for.

4. Spot bugs better. We’ve got to find a bug before we can fix it, which can be tricky. And here’s where reading code comes in: the more efficiently you can read and understand code, the more quickly you can find and correct the errors.

That’s because, as a vast reader of code, you anticipate what each line of code should do and what it should return. You’re familiar with the errors that can occur and can read and understand them, too. This helps you zero in and find what’s causing your issue.

Become a Better Reader

Consider using these three ways to get better at reading code.

Follow Ben Franklin’s Lead

I’ve written before on a learning tactic that Ben Franklin used to become a better writer. I’ve modified it and use it to become a better programmer.

It’s a favorite of mine because it emphasizes reading, studying, and emulating quality code. Here’s how it works.

Solve a problem.
Find a programmer who’s better than you and who's solved the same problem.
Study their solution. This is a crucial step: read each line of code and type a comment in your editor to explain it.
Re-solve the same program after some time has passed. Use the comments you typed out as hints to guide you along the way.
Compare your program to the one you studied.

The benefits of this practice are many. You’ll expand your programming knowledge. You’ll see good code design. You’ll train your eye to see patterns to use certain algorithms for a given type of problem or when it makes sense to use one data structure over another.

In short, expose yourself to good habits. You’ll learn a ton and your programming skills will grow.

Solve Problems on LeetCode

Solving problems on the website LeetCode offers an important benefit: it provides in-depth solutions to problems. Oftentimes there are multiple solutions with explanations.

This is hugely beneficial when it comes to reading code.

For one, you’ll see multiple ways to solve the same problem. That way, when you come across a related problem (and you will), you’ll be armed with several different approaches.

The solutions may be written in a language you don’t know, and that’s okay. Try to figure it out.

Reading code in a language that you don’t know can be a benefit, not a detriment. It’s a practice dealing with ambiguity, which is what we do each day as programmers. Reading code in a foreign tongue gives you that practice.

Recycle Your Own Problems

There have been times when I’ve been confused by my own code. (Did I really write that?!)

I use it as a learning opportunity. Here's what this practice looks like.

Solve a problem, and make a note in your calendar to re-solve in a few days or weeks. Then re-solve it and compare your solutions.

Just like tennis players re-watch their matches to study their serve, you’re studying the solutions you wrote.

Read both solutions carefully. What were you trying to do originally? What did you do better this second time around, and why? What changed? What would you do differently if you were to solve the problem yet again?

The goal here is self-improvement: read your solutions to understand what is better and why.

Be a Better Programmer

A programmer does a lot of things. Writing code is one of them. So is reading it.

In the end, being able to read code can help you to write it. It’s circular. Reading code matters and we ought to strive to get better at it.

Programmer and writer: amymhaddad.com | programmerspyramid.com | I tweet about programming, learning, and productivity @amymhaddad

Originally published on amymhaddad.com.

How to Get Better at Solving Programming Problems

Amy Haddad — Tue, 16 Feb 2021 15:08:43 +0000

Most of us have been given the same advice: to become a better problem solver, you need to solve more problems. But this advice is too simplistic. Getting good at anything requires more than just reps. It’s also how you go about it.

Besides, when programmers hear the advice “solve more problems,” they often think that “more” means faster. It’s a mistake I made when starting out.

The problem-solving treadmill can be detrimental to learning and improving. Early on I’d speed through one problem and head to the next. But the reality of that approach soon set in. By focusing on quantity, I compromised quality and missed key learnings along the way.

It’s not to say that repetition doesn’t matter; it does. However, repetition alone doesn’t get to the heart of the matter. The process does.

I have a vested interest in this topic: I want to get better at solving problems in order to improve as a programmer. So here I offer my plan of attack. It involves reps to be sure—and a whole lot more.

1. Solve a Variety of Problems on a Variety of Platforms

“I was obsessed with HackerRank when I began learning to code,” said an instructor of a Python course I was taking. Although it’s fine to have a favorite platform, don’t limit yourself to a single one. Here’s why: you need to be ready for anything.

One goal of mine is to toggle smoothly among different problem types and across different platforms. The problems on Interview Cake are different than those in Reuven Lerner’s book, Python Workout. Likewise I find the problem statements in Lerner’s Weekly Python Exercise different from those on HackerRank.

I have my preferences, to be sure. However, I need to be able to solve problems of all types. So I’m using a variety of platforms and resources to get practice.

Here are some examples:

LeetCode
Interview Cake
Cracking the Coding Interview by Gayle Laakmann McDowell
Exercism
Python Workout by Reuven Lerner
Weekly Python Exercise by Reuven Lerner

On Sundays, when I make my plan for the week ahead, I select a few problems from the above resources. I’m deliberate about it. For example, I’ll pick a problem that focuses on binary search from LeetCode. Then, one that focuses on data structures from one of Reuven Lerner’s sources.

This practice prevents me from getting too comfortable. I can’t rely on the same data structure or technique. I need to be able to pick the best tool for the job. I’ve got to be able to pivot.

It also challenges me. That’s because I select problems that push me to the edge of my limits, a feature of what psychologist Anders Ericsson calls “deliberate practice.”

Deliberate practice is all about skill development. It’s a fully-focused, conscious effort that takes you out of your “comfort zone,” centers on a specific goal, and “demands near-maximal effort,” Ericsson explains in his excellent book, Peak.

In other words, you’re not going through the motions doing something that comes easy or natural. “The hallmark of . . . deliberate practice,” Ericsson writes, “is that you try to do something you cannot do.”

2. Cross-Train Your Programming Brain

You often hear about athletes who incorporate cross-training into their routine. For example, a runner completes a bike workout or two each week. It makes a lot of sense: by cross-training athletes push their cardiovascular fitness from a different angle.

Cross-training for programmers is a topic I’ve written about before. Yet, more needs to be said about the benefits of this approach. Just like an athlete cross-trains to improve their cardiovascular fitness, I’m incorporating cross-training to improve my mental fitness.

My cross-training involves solving math problems. I apply the same tactics I’d use to solve a programming problem but in mathematics. Same process, different context.

My current math book provides the cross-training benefits mentioned above. But it’s doing something more: it’s helping me build my intuition for solving problems.

That’s an important point. I don’t want to memorize a math equation or process. I want to intuitively know when to use it. The same is true when solving programming problems.

3. Learn from Your Solutions

All of us get stuck and all of us get errors while problem-solving. We use these failures to help us figure out what to do differently.

Oftentimes that’s where the learning stops. Once we’ve solved the problem we’re anxious to move along. But don’t.

Mathematician Richard Hamming suggests that’s when the learning should begin.

“I regard the study of successes as being basically more important than the study of failures...there are so many ways of being wrong and so few of being right, studying successes is more efficient,” Hamming writes in his book, The Art of Doing Science and Engineering.

This idea of "looking back" and studying your successes is a topic I've written about previously, and it's worth noting again.
You always hear about how we need to "learn from our failures." But Hamming is right: there's so much to learn from our successes.

So one of the biggest changes I’ve made to my problem-solving process is putting Hamming’s words to practice. I vividly recall solving my first problem that involved a linked list, a data structure that was new to me at the time. After I solved the problem, I studied it intently. I copied my solution into a Google Doc file and used comments to explain the code to myself.

I wanted to ensure I clearly understood what I did and why for this critical reason: so I could do it again.

4. Get Feedback

Awareness can be a wonderful teacher.

Don’t assume your solutions are great. Find out for yourself by getting feedback. Feedback is a critical factor when it comes to getting better. It’s also a component of deliberate practice.

There are two ways I’m getting feedback.

First, after I complete a problem, I study the solutions of others. Sometimes resources, like LeetCode and Cracking the Coding Interview, provide the solution. Other times I find the solution of a programmer who’s solved the same problem. Sometimes use both.

Either way, the next step is the same: I start at the top of the solution and explain each line in my own words. I speculate why the programmer chose this particular data structure, for example. Then, I write a short summary of the program to solidify the core concepts or new approaches that I just learned about.

Putting something complicated, like a line of code, into your own words is a great test to see if you really understand it. Plus, you get practice at another core skill: reading code.

If there’s something that’s new to me, I research it. I compare their code to my own. I study. I evaluate. I learn. It’s an arduous process, but I get so much from it.

The second way to get feedback is to simply ask another programmer for it. Video calls are helpful to step through code line by line in real time. Although, pull requests are useful, too.

There’s a point to the feedback: apply it! Put your learnings into practice.

5. Be Consistent

Now let’s talk about repetition. Problem-solving is a skill. Like any skill, it takes time to build. It simply doesn’t happen overnight or over a weekend. That’s why I devote time each day to problem-solving.

There’s a common reaction to this daily practice: “There’s too much to learn. I can’t spend time each day problem-solving.”

My response is two-fold. First, there’s always going to be something more to learn, always.

Second, in large part programming is problem-solving. It's fundamental to our craft. It’s worthy of your time and attention each day. Here’s the caveat: make your daily practice intentional.

It’s an Art

Many people regard problem-solving as an art. I happen to agree with that sentiment. The same can be said for the process itself.

The ideas outlined in this article are my approach for getting better at problem-solving. Your approach may look very different. The point is this: be intentional about your practice. Quality matters; make each problem count.

Programmer and writer: amymhaddad.com | programmerspyramid.com | I tweet about programming, learning, and productivity @amymhaddad

Originally published on amymhaddad.com.