I was recently explaining to a friend of mine why being recklessly confident is a better strategy than being mindfully humble if you want to become a proficient software developer in a short period of time. I realized that I’ve had some variation of this conversation at least a dozen times, so it’s probably more economical to write my thoughts down.
Everyone who comes into programming after say high school, experiences the same phenomenon: that everyone is smarter than them, and therefore they will never be great. Different people experience it to different degrees, but these emotions of inferiority are so common and so universal that it supersedes random chance. There must be something larger in play.
It’s a similar type of phenomenon as gravity. You can’t observe it directly, but if you throw enough objects off a building with different masses and find they all behave the same way then you can make inferences about the world you’re living in. Likewise when you watch hundreds of students from different backgrounds and career arcs all encounter identical emotions you can draw a conclusion that the phenomenon is more universal than unique to any one individual.
In a traditional industry at a large company the growth curve for intellectual ability is roughly linear. You get better on the order of the time and effort that you put into your craft. If you have been an accountant for 5 years, you’re something like 5x better than when you started. If you work twice as hard you’ll be twice as good.
Programming doesn’t tend to work this way. The growth curve is much more dynamic. You might be 5x where you started after just a couple of months. The underlying physics of skill acquisition are still the same, but the exponents are much more pronounced, a little like how gravity behaves on the Earth vs. the Moon.
Because of this altered gravity, someone 3 months ahead of you is much better than you. Someone 8 months ahead of you is much much better than you. Someone three years ahead of you might be 20 times better than you. If you’re not used to it, then it will be startling to experience. I think this is why you see more successful 19-year old programmers than you do accountants or lawyers, because the skill acquisition curve is so dynamic that it actually is plausible to be at a young age and a significant skill level at the same time.
But if you look at your peers through the lens of a skill acquisition curve from a different field, then someone 3 years ahead of you being 20x better than you is simply impossible. Unless… gasp what if they’re just smarter than you? I’ve seen every single person make that mental connection at some point, it happens so much that we have a term for it — “The Imposter Syndrome”.
In reality, there are two possible explanations for the emotion of inferiority that new developers feel. Either everyone else is actually smarter than you and the discrepancy is something intrinsic to yourself OR the gravity has simply been altered to make skill acquisition possible at a much faster rate than you realize. Most people miss the second explanation and assume the first, that it’s some inadequacy in themselves that explains their skill level relative to their peers. And it turns out to be an incredibly destructive mindset to have in this space, and the sooner you can conquer it the better.
The growth curve in most new developers is roughly a punctuated equilibrium, with periods of high growth followed by periods of sustained refinery. The growth spurts happen when you fully understand a new concept. Understanding AJAX changes the way you think about building UIs. Understanding React empowers you to make highly stateful UIs and not drown in complexity. The first time you abstract data flow onto a messaging queue it changes the way you think about building systems. At the micro level it might be understanding how to use some library to accomplish a task. i.e. upload a file from a web application to Amazon S3. At the macro level it might be learning a completely new paradigm like functional programming. Learning new concepts at both the micro and macro level require good explanations and good resources to understand.
Looking back now after 4 years, there was nothing I’ve encountered that is actually so challenging that a good explanation couldn’t explain the concept naturally to anyone. Even the things I think are hard now (distributed consensus algorithms, concurrency etc…) I’m sure aren’t hard to understand if I could find a good explanation for it and something that makes sense to me.
Good resources are so important that they actually overwhelm the sheer hours/quantity of work you put in. The algorithm for learning to code is O(number of good resources), which means the search algorithm for finding them is incredibly important. If there’s a way to find good resources faster, then you can traverse the skill acquisition distances faster, and if you don’t find the right resources you are essentially wasting your time.
The problem is that because of this innate inferiority complex most beginners don’t let themselves filter out bad resources which perverts their internal learning algorithms. Good resources are simple to spot: Does this make sense to you? Do you understand this? Did the author make an effort to predict the next logical thought and answer that? And if the answer to those questions is no, then you have to be able to quickly dismiss the resource and move on. But so many beginners are unable to dismiss bad resources because they think the other likely explanation for why they didn’t understand it, is that they are too stupid and their own inadequacies must be the reason for their lack of understanding. And if you have that mindset you’re going to keep getting discouraged, bang your head against the wall, try desperately to fix something with yourself, instead of just thinking that whatever you’re reading is poorly explained and simply moving on to something else.
“I’m not smart enough to understand functional programming so I’m going to stick to Ruby” vs. “I’m going to keep looking until I find a good explanation of functional programming, because I’m interested in the idea of building a system without objects” are binary differences in attitude … And if functional programming is a macro-level growth spurt (it is) guess who is going to zoom ahead and who is going to fall behind?
Another common mistake is to become fixated on the absolute distance of the Y-Axis. i.e. “I did all this work to learn HTML, CSS + Javascript but how can I learn back-end and databases and devOps it’s too much”. Objectively the distance to cover is substantial, and if you think on the timescales of other industries the traversal seems unattainable, but really that “devOps” thing that seems so impossible might only take a couple months to wrap your head around and feel competent at. The speed at which you can traverse the distances is also substantial, but if you don’t realize it you’ll constantly be demoralized and intimidated and never actually try.
Almost everyone I know that became a high impact outlier was recklessly confident from the day I met them. The more confident you are in your abilities the more likely you are to just throw yourself forward on the X-axis and traverse distance. This is interesting because I don’t think it’s what most people will tell you. If you asked a coding school what the key values they impart on their students are, the answer would probably be empathy, cautiousness, code quality etc… But really these are things that are much better learned on the other side of the spectrum.
If you have this assumption that coding is supposed to be hard and frustrating then you’ll never consider that you’re just reading the wrong things, using the wrong tools, or working with the wrong people — which will inhibit your growth. Coding is fun, and exciting, and understandable. I hated working with AngularJS and thought I was too stupid to make sense of all it’s complexity. But once I switched to React, I immediately felt better and UI development made sense again. Had I been convinced that coding was supposed to be hard, I probably never would have declared Angular too annoying to use and ditched it, but it was a macro-level growth spurt when I did.
Coincidentally, things like learning a foreign language, or learning to play a musical instrument have similar learning curves. People, in general, tend to overrate how hard things are when the skill acquisition curve is dynamic. Learning foreign languages and playing musical instruments aren’t hard, the deltas in skills are just more pronounced. I think this is why you’ll hear someone say something like “I’m bad at learning foreign languages” but never “I’m bad at accounting”, they’ll normally opt for something like “accounting isn’t for me” instead.
So really you just need to be confident if you want to get good at something, and hurl yourself forward with reckless abandon. Hopefully realizing that the world works this way is enough to help a little if you’re feeling overwhelmed.
— @AlwaysBCoding