I’m a programmer and I recently stopped pretending to know things I don’t know. I used to do it all the time. And if you’re a programmer, a designer, a marketer, or really any type of professional that takes pride in your career, you pretended to know things you don’t know. Maybe you still do.
But if you want to become better at your career, you need to stop pretending to know things that you don’t know. The reason why is probably not what you think.
I still remember the moment that everything began to change.
Not too long ago, I got into an informal conversation with Sam, a developer who I really respected. We started talking about the cool things we were working on, and Sam started raving to me about Elm, a programming language. I hardly knew anything about Elm. But I acted like I did, and I made it through the rest of the informal conversation by repeating some of the words he said and nodding my head every few seconds. I simply couldn’t bring myself to admit what I didn’t know.
I didn’t want to run into a similar situation again, so the next day, I decided to look into Elm. I spent about 20 minutes looking at the documentation and reading through some code examples. But even after my quick research effort, I honestly just didn’t get it. This stuff was complicated.
I could understand a few things:
- Programs that are written in Elm are somehow able to be run inside web browsers
- It is a functional programming language
- It is statically typed.
I understood these terms and I understood their upside. But I couldn’t quite wrap everything together in my head and figure out what exactly the point of Elm actually was. I couldn’t identify the problem that it solved. I still didn’t get it.
A few weeks later, I reached my inflection point.
I went to a Rails event in San Francisco and started talking to a senior developer, a nice guy named Brian, about one of my projects. I had been working on a content hub that incorporated a lot of really interesting features; such as video, lead-gen forms, moving image backgrounds, and other cool stuff. I was pretty excited about it. I talked about the cool collection of technologies that I was using to build the hub, and I was feeling pretty awesome about how the conversation was going. Mid-conversation, Brian asked me a question that stopped me right in my tracks:
“Why didn’t you use the Elm programming language?”
This is pretty much the last thing that I wanted to hear at the time. After all, I had tried and given up on understanding Elm just enough to make it look like I knew what I was talking about. I didn’t think that I would run into this situation again so quickly, and I really wasn’t sure what to say. All I knew was that I still did not want to admit that I really didn’t understand the point of Elm.
Here’s what I said:
“I don’t have a ton of experience with it, but from what I’ve read and learned it seems interesting.”
I then continued to try to save face by babbling off a list of the related buzzwords that I remembered from my 20 minutes of research.
Brian seemed to buy my cover enough, and he responded by jumping a few steps ahead of what I understood and talking about Elm in more depth.
I pretty much didn’t understand a single word that came out of his mouth. So I tried to wrap up the conversation as quickly as possible and find someone else to talk to about any topic in the world but the Elm programming language.
In the process, I realized two key things.
- The fact that Elm came up a second time was further evidence that it was worth learning about.
- The fact that I pretended to know more than I did know made it impossible for me to get any closer to actually understanding Elm at all.
On my way home, it became increasingly more obvious that I had done something pretty bad. In an effort to make myself look like I knew everything about programming, I bent the truth to try to make myself look more intelligent.
After all. This…
“I don’t have a ton of experience with Elm.”
…is very pretty different from this:
“I’ve spent about 20 minutes researching Elm and to be honest, I just don’t get it.”
By exaggerating my skills and pretending to know things that I didn’t know, I was shutting myself off from learning stuff from the only people who could explain it to me.
That day, I decided to stop caring what other people thought about me. I made a pact with myself to never exaggerate my skills again, and to move forward with the commitment of radical honesty.
It was clear that this was the only way for me to learn more about programming from other people. I had to do it. After all, new technologies are coming out every single day. It is impossible to know everything, so it simply doesn’t make sense to try to make people think you do.
My new strategy would soon be tested by a new programming technology, called Docker.
I had been researching other programming topics, which lead me to a technology called Docker. I found it pretty interesting. So I watched a couple of videos about it, reviewed the website, and even tried to test it out. I was able to hack some stuff together. But, to be totally honest, I didn’t fully understand how everything really worked under the hood.
A few weeks later, I went to another programming event. I found myself having a conversation about how to install programs on computers. Initially, I installed my development environment (think programming language, databases, etc) using normal programs on my computer. Eventually, I learned how to use vagrant, a pretty cool way to manage virtual computers – and it changed the way I installed my web development environment for the long term. I started talking with another developer about this, and he asked me a question:
“How come you don’t use Docker?”
I froze. This would be the ultimate test of my mindset shift. I responded like this:
“To be completely honest, I’ve researched it a bit. It seems pretty cool and I got something up and running using it fairly easily, but despite the fact that things seem to be working, I don’t really understand all the things that Docker is actually doing.
In a lot of ways I understand the theory, but I don’t fully understand how it maps to what’s happening on the computer.”
Something really cool happened.
The developer started explaining Docker to me. He explained:
- Exactly what Docker was
- How it worked
- What the point of it Docker was
- How to practically use the tool
My feeling of confusion immediately shifted to pure enlightenment.
At that point, I had a pretty solid understanding of Docker. And I never would have gained that understanding if I had cared about what other people thought about me.
So many people refuse to do this. We’re terrified of admitting to not knowing something that we feel pressured to know. The result is that we end up talking in buzzwords and dancing around concepts without really understanding how stuff actually works.
When you always pretend to know everything, be it a programming language, new design trend, marketing strategy, or really anything new, then you will never give yourself the opportunity to actually learn.
Stop caring too much. Stop pretending to know things that you don’t know. Instead, be brutally honest. And if someone asks you about something that you don’t know, make sure that you start your next sentence with:
“I don’t know, but would love to learn more….”
This is the fastest way to learn new things from other people. And it’s the only logical way to handle situations like this. Why? Because it turns out when you try to pretend to everything and overstate your actual skills, one of two things will happen:
You’ll fool nobody. And you’ll learn nothing.
You will fool someone. And because will assume you already know everything, you’ll learn nothing.
Being nice, humble and honest is the fastest way to build strong relationships and become a more intelligent person.
This is the best way to learn as an aspiring developer or really any other type professional.
If you found this post insightful, share it with someone using the Facebook and Twitter buttons.