Stop me if this sounds familiar: you decided you wanted to create your own web applications, and asked around or searched Google for advice. People told you to work through TryRuby to get your feet wet, and then to try your hand at other tutorials like Codecademy and RubyMonk. Once you’ve got a feel for Ruby, you’re ready to move on to Rails with Hartl’s Tutorial. Then dig deeper with The Odin Project, and books like Practical Object-Oriented Design with Ruby.

Still with me?

So you follow that advice, and it’s clear that you’re learning a ton. There’s just one problem: despite everything you’ve learned, you still can’t build the web apps that motivated you to learn Rails in the first place. In fact, the more you learn, the more new things you discover you have left to learn.

Learning Rails becomes learning Ruby, HTTP, databases, Javascript, and deployment. Learning Ruby becomes learning the syntax, standard library, design patterns, object-oriented programming, test-driven development, text editors, and git. Learning Javascript becomes learning the language, multiple frameworks – jQuery, Ember.js, and Angular.js for a start – and Ajax. Learning deployment becomes learning Heroku, Linux, EC2, and Capistrano. On and on it goes…

Your TODO list of things to learn gets longer every day. You’re busting your ass, and learning a ton… but instead of getting closer, your goal of creating web apps gets pushed farther away.

“How much longer before I can actually build something?”

It’s a fair question, but here’s one that will help you even more: “Is there a better way?”

Of course there is :)

But before we get into that, let’s take a look at what’s wrong with the approach you’ve been following so far:

Problem #1: You don’t have any direction

There’s so much stuff to learn about programming, you could spend the rest of your life doing nothing else. And that’s exactly what happens when you don’t have any direction: you spend your time learning about programming, instead of actually programming.

You acquire tons of information… and lose it just as quickly. You spend your time working through tutorials over and over again, trying to read books (but falling asleep), reading blogs and watching screencasts.

But programming? You hardly do any. You’re too busy learning about programming.

Problem #2: You’re biting off more than you can chew

How do you eat an elephant? One bite at a time. The old maxim would work great if you were trying to do the metaphorical equivalent of eating an elephant, but I’ve got news for you: you’re trying to eat an entire herd of elephants (metaphorically… :)

Every one of the skills you learn in programming could take months to get the hang of, and years to master. Try to do it all at once, and you’re destined to fail.

Problem #3: You’re always behind the curve

Every day, programmers invent new methods, and create new software, to help them do their work better. This means that the available programming information expands faster than you can possibly hope to learn it. You will never know all there is to know about programming – it’s simply not possible.

If you spend your time learning about programming, and not creating programs, then you’ll always be playing a game of catch up which you can’t possibly win. You’ll never learn enough to “just do something” because you’ll always have “just one more thing” to learn.

“Okay, I see what I’ve been doing wrong… now what do I do about it?”

The good news is, you can find and use a better way to learn. And now that you understand the problems inherent in the way you’ve been learning, you’re ready to solve them:

Solution #1: Intentional learning

Intentional learning is the opposite of learning without direction. Instead of following a path that others have laid out, assuming that it will get you to where you want to go, you can forage your own path. You can set specific learning goals, and work to achieve them. The simplest way to do that is to treat your learning as a series of small research projects.

Solution #2: Think smaller

It’s easy to get caught in the trap of thinking bigger is better. If you set bigger goals, you’ll feel a bigger sense of accomplishment, right? Maybe… and only if you actually achieve that big goal. More likely, you’ll fail. And that’s okay – you can always pick yourself up and try again. But failing over and over isn’t just demotivating, it’s also unnecessary.

Any time you’re reading a book or tutorial, take note of all the things that you’re learning. Pick one of those things to work on by yourself, to improve your skills. And when it comes to your own projects, don’t think you need to work on something big and impressive. It’ll motivate you at first, but then you’ll get stuck. You’re much better off writing small applications that solve specific problems.

Solution #3: Flex your new superpowers

Working on an ever-growing TODO list of things to learn is like climbing a mountain that keeps getting taller. And that’s not being fair to yourself, because you really have learned a lot!

Instead, take stock of what you can do today that you couldn’t do yesterday. Maybe you finally understand how lambdas work, or remember to write a failing test before writing implementation code. Look at what you can do today that you couldn’t do last week: maybe you can debug a NoMethodError in a few minutes, where last week it took you over an hour. Look at what you can do today that you couldn’t do a few months ago: maybe understanding technical blog posts, or reading open source code, or creating tiny utility applications.

Software development is all about expanding human capabilities. When you develop your programming skills, you gain new superpowers. Celebrate those superpowers! Pat yourself on the back for what you can do today that you couldn’t do before. And most of all, continue building on top of your new superpowers.

Learning to program doesn’t happen by accident. You now know about a better way to learn – are you going to use it?