Amy M Haddad

5 Lessons Learned (So Far) as a Programmer

By: Amy M Haddad

image

Programming is a fantastic skill to develop. But, as a self-taught programmer, I’ve found the learning process unnecessarily ambiguous and complex. I’ve spent a lot of time figuring out what to learn (and when to learn it), which resources to use, and how to learn a vast number of technical topics.

So I’ve put together five lessons I've learned (so far) from my own journey. I hope the ideas and resources in each lesson will set you up for a more direct route for learning and getting better at programming.

1. Learn the fundamentals of programming.

One piece of advice shaped my entire learning trajectory as I set out to learn to program. “Don’t do what I did,” a programmer warned me. “Don’t focus on the technologies.”

I received this advice before I knew anything about programming—before I’d even typed a line of code. I just knew that I wanted to learn to program, but this programmer’s advice really got me thinking about how I’d go about it. Instead of focusing on technologies, I'd focus on the fundamentals of programming, though I had no idea what those were at the time or how I’d go about it.

And thus began my indirect pursuit to learn the fundamentals of programming. It was indirect because I had to figure out what the fundamentals were, what resources to use, and how to go about learning a vast amount of technical information.

I didn’t have a roadmap to direct me, so I meandered a lot. I tried learning algorithms way too soon, for example. It would’ve been better to first focus on data structures and data abstraction.

So the learning process wasn’t quick. Nor was it easy. But I can tell you this: learning the fundamentals has been essential. And if I had to start all over again, I’d start with the fundamentals. There are several reasons why.

First, when you learn the fundamentals—including problem-solving, algorithms, databases, object-oriented programming, and data structures—you build a set of transferable skills that’ll help you now and years down the road. That’s because the fundamentals don’t go out of fashion like technologies do. It’s a point made clear by Steve McConnell:

“You often hear people say that software development knowledge has a 3 year half-life: half of what you need to know today will be obsolete within 3 years,” he explains. “In the domain of technology-related knowledge, that’s probably about right.”

However, McConnell is quick to point out that “software engineering principles” don’t “have a three year half-life.” As he puts it, “[t]hese software engineering principles are likely to serve a professional programmer throughout his or her career.”

As a result, you’re more adaptable when change happens. And in a fast-moving field like programming, change is a given.

You’ll also feel more prepared because you’ve built a solid foundation of knowledge, which is another reason why the fundamentals matter. You’ll have more confidence because you know why and when to use recursion, for example.

Third, a solid grasp of the programming fundamentals can help you learn technologies faster and easier. If anything, the learning process will be a bit smoother, at least that was my experience.

Don’t get me wrong: it’s fun to build apps and play with new technologies. Besides, we need to use technologies in our daily work. But—and this is the important point—you’ll be more effective with the technologies if you’ve got a solid foundation of programming knowledge. Likewise, a basketball player will play the game of basketball better if they go to the gym and work on their shooting and dribbling skills.

My roundabout way to learn the fundamentals of programming inspired me to create Programmer’s Pyramid. It’s the tool I wish I had. It’s the direct way to learn the fundamentals. It contains the topics you need to learn and the resources to learn them.

2. Learn Scheme.

Learning Scheme was one of the best programming decisions I’ve made. It’ll help you in two ways. First, it’ll get you really comfortable with recursion.

Prior to Scheme, recursion was something I only used if I had to. Truthfully, I was fearful of it. But I got over that fear with Scheme. That’s because there are no loops in Scheme. So you use recursion everywhere!

As your comfort level increases with recursion, so will your confidence. Instead of dreading recursive problems, you’ll embrace them. Over time, I found myself looking for opportunities to use it.

Learning Scheme will also teach you to be resourceful. Scheme is a very simple language. There’s just not a lot to it. And yet you can still write some pretty neat programs with a limited set of tools. There’s value for learning how to do more with less.

One of my favorite Scheme resources is the book, The Little Schemer. I like it not only for its content but also its teaching style. It breaks concepts down to their simplest parts, and then prompts you with questions. Therefore, you make the connections before given the information, which helps you to learn the content.

Simply Scheme by Brian Harvey and Matthew Wright is another great book: there are tons of practice problems and the explanations are clear. Lab 10, from Berkeley’s excellent course, CS 61A: Structure and Interpretation of Computer Programs, is a great way to get some extra practice with Scheme.

3. Solve math problems.

When I was just starting out in the field, I asked seasoned programmers a question: “what would you do differently if you were to start your programming journey over again?”

The answer I got on more than one occasion was this: “I’d spend more time learning math.”

So that’s what I did. As I began learning to program, I was re-learning math concepts and solving math problems. It’s a practice I continue today for three reasons.

First, solving math problems is another way to improve your logical thinking skills. Second, it offers problem-solving practice but in a different context. I think of solving math problems as a mental form of cross-training.

A runner, for example, may run four times per week and cross-train by biking or swimming the other days. They’re still pushing their cardiovascular system, but in a different way. And so with solving math problems: you push your mental abilities in a new and different way.

Third, basic math concepts often come up in programming. So if it’s been awhile since you last worked with concepts like exponents, multiples, or divisors, then it’s worth brushing off the cobwebs.

To do so, I highly recommend the Art of Problem Solving series as a math resource. Instead of memorizing formulas and definitions, you’ll find yourself learning by doing: you’ll solve tons of problems. As a result you’ll begin to spot patterns and make connections, which are critical skills you’ll use when solving programming problems.

This series contains books for people of various math levels. If you need a place to start, consider The Art of Problem Solving, Volume 1: the Basics by Sandor Lehoczky and Richard Rusczyk.

4. Study the code of others.

I’ve written about the importance of studying the code of others in many articles on my blog, and for good reason: it’s so important.

There are a lot of great programmers out there that we can learn from. And in the process you’ll:

So after you solve a problem, study the code of others. This is low-hanging fruit that more people should take advantage of.

There are many ways to go about it. One of my favorites is to apply a learning technique that Ben Franklin used to become a better writer. Franklin would study an article, from a publication he admired, and make hints of the “sentiment” in each sentence. After some time passed, he tried to reproduce the article, using the hints he’d made.

This how Franklin’s technique works when applied to programming:

  • Solve a problem.
  • Find a programmer who’s solved the same problem.
  • Study their solution. Summarize each line of code by writing a comment in your editor.
  • Re-solve the problem after some time has passed. Use the comments you typed out as hints to guide you along the way.
  • Compare your new solution to the one you studied, and make any necessary changes.

LeetCode and Exercism are great resources to use for this practice. Both offer a range of problems and have community solutions you can study and learn from. AlgoExpert is another favorite problem-solving platform of mine. It provides one or more solutions for each problem. But the real benefit is the video explanation that accompanies each problem. It contains a conceptual overview and a walkthrough of the provided solution(s).

5. Pay it forward.

From the start, I’ve been amazed at the generosity in the programming field. So many programmers willingly answer questions, review code, and create free content. All of us have benefitted from this generosity, and I encourage you to pay it forward.

Each of us has something to offer, even if you’re brand new to the field. In fact, I think those who are just starting out have a real advantage: the beginner’s mind. Oftentimes authors of books, articles, or courses forget what it’s like to be a beginner; they’re too far removed. So they assume a lot, make huge leaps, and leave the struggling learner back in the dust.

So if you’re starting out as a programmer or if you’re a seasoned programmer who’s learning a new subject or technology, then I encourage you to share what you’re learning, doing, or struggling with. There are others that have the same question and could benefit from your experience learning Git, for example, or how you got unstuck solving a problem. Or what you did to learn C. As you set out to help others, you’ll also help yourself.

Still Learning to Program

Above all, never stop learning. It saddens me when I hear people talk about learning to program like it’s a one-time thing—because it’s not. The field of programming is huge. You can spend years on a single subject or algorithm. So when people treat programming as a one-time thing, they put a cap on their knowledge and skills, and thus their potential.

So my challenge to you is to embody what Carol Dweck calls a “growth mindset.” Keep learning. Keep getting better. And this is why I added “so far” in the title of this post. I’m still learning. I’m still growing. And as long as I’m programming, I’m still learning to program.


← back to all posts