Learning to code can be so daunting. There are so many languages to choose from, new technologies are constantly arising, and the amount of information to take in can be overwhelming.

This feeling can really bring down the budding developer, often leading to unhealthy levels of self-doubt and anxiety. Then they burn out. Quit. Give up on their dream.

Sound familiar? Let’s refactor that thought process a bit. (Refactoring is the process of making small incremental changes to your code to change the way it achieves its purpose. It makes code more legible and usually helps it to perform better.)

“I don’t know anything.”

I hear this from new developers. A lot. You know what? You’re not alone.

I’ve been developing software for a couple of decades now (yikes!) in dozens of languages. You’d assume by now I’d know it all. But that’s very far from the truth. In fact, to this day, every single project I start I usually have to not only learn the business logic, but also some part of the required technology. It was terrifying in the beginning, now it’s just old hat. Everyone has that feeling.

Try this real quick experiment: for an entire day watch the people you encounter in your daily life performing their jobs. Imagine their first attempt.

Take a bus driver, for example. Imagine how terrifying his first day must’ve been with all that responsibility in his hands. He had to remember lots of different stops. All the different fares and transfers. Deal with potentially unruly riders. Then there are the “what ifs”: What if the bus got too crowded? What if he was too late/too early? What if the bus broke down? What if he got in an accident? And so much more.

There’s no way he could’ve anticipated all the different scenarios. So he most likely did what anyone would’ve done on their first day: started winging it. He took the wheel and drove into the unknown.

“I don’t know how to do that … yet”

Now let’s switch our focus to a programmer’s job. Chances are, the new developer is probably going to be getting their feet wet by working on defects and small tweaks of the code base while they learn the environment within which they will be working. You won’t have a whole lot of responsibility yet.

That’s because no one expects you to walk in and immediately be productive in an unfamiliar environment. It’s a misconception that commonly causes panic, but I think there’s a deeper root cause: job postings.

Today’s technical job postings are littered with buzzwords and unrealistic requirements. I recently saw a job posting asking for three years experience with the Swift programming language. Swift, at the time of the posting, had only been out for a little over a year.

If that feels unattainable, it’s because it is (well, without time travel). Wondering why it was posted like that in the first place?

My guess is the job poster who was asked to go find talent didn’t fully understand the request. They asked a dev team what they needed for the product they were building, and the team overshot their requirements.

This was because the team didn’t have experience with all the new technology they were using. They’re learning together as they build the product, and you guessed it, winging it.

It goes back further: there was probably a manager who had been given the responsibility to put together a team to build the most efficient, cutting-edge project. But with the way that technology is evolving, hiring can be extremely difficult and unforeseeable. So the manager did what they’ve been doing throughout their career: winged it.

At the start of all this was the entrepreneur putting pressure on the manager to help get their shiny new product built. And the entrepreneur by definition is always winging it.

So here’s a tiny refactor for you: Everybody’s winging it. Almost all of the time.

“I don’t know that, but I will learn it”

As a player in the tech industry, your job is to be confident and comfortable winging it.

The quicker you realize this, the quicker you’ll drop those feelings of inadequacy, and the better you’ll get at embracing this inherent change.

Not knowing a technology comes with the territory. Having been a hiring manager for junior devs, I can say with certainty that the most successful hires I made are those that came with the attitude “I don’t know that, but I can learn it.”

Obviously one way you can do that is by using Treehouse. We have different learning tracks that’ll give you guided, hands-on exposure. At the end of each course, you’ll almost always end up building a project you can further expand upon.

The more you experience the different languages and tools, the more you’ll be able to see the similarities between them. It’s the understanding of these shared root concepts that allow you to really grow confident.

We’re also here for you after you land that gig. We got your back when you want to strengthen your winging it skills. . . I mean, keep up to date with the latest trends. We’ve been producing a ton of new workshops with this audience in mind, and our library is ever expanding. Please make your voice heard to let us know what you need.

Now that we’ve wrapped up that refactoring exercise, you should be able to see that not knowing something is an opportunity for growth. Go and tackle what you need to learn through hands-on practice, and don’t beat yourself up about lack of experience.

This is the first time I’ve ever tried to express this thought in a blog post. I hope you found it beneficial.

I was totally just winging it.