Take a look at a typical code school, and you’ll find a huge curriculum and a promise: “Work through our lessons, and you’ll be ready to work as a professional developer!”

What actually happens?

You work through the first few lessons, which all re-hash the same material you’ve seen over and over. Syntax, numbers, arrays, if statements, loops…

Eventually you move beyond the same-as-everywhere-else introductory material and on to something new. And it makes sense! For a while…

Then you get to a lesson that has you stumped. It might be regular expressions, or metaprogramming, or testing. The lesson talks about things you’ve already learned… but you can’t remember.

Which brings up a question: have you really learned those introductory topics?

Or have you just read about them, and created a mushy placeholder idea in your brain… one that you can’t understand, recall, and use?

So you go back to the previous lessons, and work through them again. Maybe, just maybe, this time you’ll really get it and you won’t get stuck when you get to the more advanced lesson.

Maybe, just maybe, you do move past the lesson that got you stuck the first time around. Guess what? There’s another lesson immediately after, just waiting to knock you off track again… and another lesson after that, and another lesson after that.

It’s lessons all the way down, until you finally work through all of the lessons and have the skills you need to create the software you want.

That’s when it hits you: the code school lied to you.

They don’t lie to everyone, of course… just to you.

How else do you explain the fact that, even after struggling through the lessons, revisiting the same content over and over, you still can’t take what you’ve learned and create the software you want to create?

What do you do now? You go out in search of another course with another fixed curriculum, which looks the same at the beginning, takes a different turn near the middle… and leads you to the same exact place: Frustration-town.

It’s not your fault code schools lie to you. But it is your fault if you keep falling for the same lie over and over…

The truth about making software

Making software is messy. You start with an idea, and then the moment you start to work on it, it changes. As you keep working, the idea keeps changing… until one day, you have some software that does the job and does it well. People will look at your software and say, “Wow, this is awesome! You really know what you’re doing!” They don’t see the battle-scars. They don’t see the iterations, the scraps on the cutting room floor, all the ideas that you cut and added and cut again.

Making software is non-linear. You don’t follow a tidy progression from one idea to the next. You work on one idea, which generates five new ideas… and as soon as you start working on a new idea, the first idea changes. Around and around you go… and without a unifying idea, you’ll keep going around and around.

Making software is hard. You think professional programmers make fewer mistakes than you? Think again. Professional programmers make more mistakes than you. Way more. Waaaaay more. Waaaaaaaaaaaaaaaaaaaaaaaay more. Professional programmers make more mistakes in a day than you will in a month. What’s the difference? They make mistakes faster than you. Or more accurately, they recover from mistakes faster than you, which allows them to make mistakes faster than you, which allows them to recover from mistakes faster than you… get it?

Exposing the code school lie

If you read that last section carefully, you noticed something important:

Making software is messy, non-linear, and hard.

Not learning to make software… making software.

So what’s the code school lie? It’s two-fold:

  1. Learning to make software is different from making software.
  2. Once you’ve learned to make software, making software will be easy.

Let’s look at them in order:

Lie: Learning to make software is different from making software

Truth: Making software is learning to make software. Not the other way around…

You will learn more in your first week at a real job than you will in 6 months at your typical code school. Why? Because when you work at a job, you work on stuff that nobody knows how to do. Sure, you use skills that lots of people know, but applying those skills, at your company, to solve your company’s problem… you and your team are the only people who can do that.

Which leads us to the next point:

Lie: Once you’ve learned to make software, making software will be easy.

Truth: First, remember that making software is learning to make software. So what do code schools really mean with this lie? “Once you’ve mastered all this content, you’ll be prepared to work as a Ruby developer.” But remember: when you work at a job, you’ll do things that nobody else knows how to do, but when you work through a curriculum, you only work on stuff that everybody knows how to do.

It’s like the difference between amateur and pro sports. Going to a code school, expecting to be job ready when you graduate, is like going to a basketball camp and expecting to come out ready to take on Michael Jordan one-on-one on the court.

It just doesn’t make sense.

But if you don’t know the truth about making software, then how could you possibly know that that model doesn’t make sense? After all, thousands of people have attended these code schools… and thousands of people paying tens of thousands of dollars can’t be wrong… can they?

That’s one heck of a gamble to take, when you still don’t know much about making software.

Keeping it all together with the RubySteps unifying principle

Remember that I said you need a unifying principle, otherwise you’ll keep going around in circles?

You don’t need to sign up for the RubySteps Professional Developer Program to find out what it is. I’ll tell you, right now, for free:

Making software is all about people. It’s just people, working with other people, to help even more people.

People, people, people. That’s it. Computers, programming languages, and software are just tools - tools that we use to work with people, and help other people.

RubySteps is all about people. Not lessons, not techniques, not even Ruby or software… people.

Specifically, RubySteps is all about you.

It’s about helping you discover the path that you need so that you can make the software that you want.

It’s about helping you work effectively with others, so you can take all those ideas you have and make them real.

It’s about you finding your people.

It’s about you, working with other people, to help even more people.

Who do you trust?

I’ve told you about the code school lie… but how do you know you can trust me? How do you know that I’m not trying to sell you a fairytale too?

It’s a great question. There’s no way for you to know. It comes down to trust.

Trust me when I tell you that there are no guarantees in life. Nobody can guarantee that you will get a job, become an amazing programmer, and launch a wildly successful startup.

What I can guarantee you is that you’ll get my full support and commitment as you grow your software career.