Maybe it's just me but there seems to be a rise in the developer community surrounding impostor syndrome.
This feeling seems to affect the full range of technical roles. Whether you're a junior or a senior, front end or back end, it doesn't seem to matter.
This feeling makes total sense to me. I definitely feel it from time to time. It doesn't surprise me, honestly. If anything, it's intriguing how vocal this feeling has become when I've personally considered it to be just "part of the nature of the job".
Maybe I should try and explain with some examples.
Tech jobs aren't the only jobs
There are so many other jobs out there in the beautiful world we live in. Being an actor or actress is a job, for example. Did you know the actress Michelle Pfieffer claimed to suffer from impostor syndrome at one time?
The term seems to have been coined in the 1970s. Compare the number of available technical jobs and roles you could undertake at that time to what we have now.
What does this mean? We, as developers (and related roles), are not some special breed that experiences a unique syndrome afflicting us and only us. Plenty of people in the past have suffered from the same.
Thats good! It means we can look at some historical data and figure out what this syndrome is and where it comes from. It also means that it's normal to feel it!
Why do you feel it?
If you read the research on the syndrome you can easily get lost. It's not something that's explained in any one way or with any one set of terms.
Suffice it to say, there are a large number of factors that shape your brain to think "I should be this kind of person to be worthy of accomplishing goals" and then you experience a scenario where you are maybe praised for some successful action and you review how you got to that wonderful point and realize "I am not the person I should be so I obviously somehow cheated to accomplish this goal" and you're thus an impostor.
Thats a pretty general way to express it but you can see how that feeling might manifest itself in a variety of jobs and roles.
Ok but let's focus on developers. I do feel that developers have their own special set of circumstances that cause this feeling to come up.
What do you know?
You're sitting in front of a screen. You look around you and take in the sights. It's an office. But you're a fresh bootcamp grad and this company was a dream company you wanted to get a job at. Here you are. They hired you based on your performance at bootcamp and you get to enjoy your dream now.
You boot up your shell and realize you need to grab the latest code because a team of developers worked overnight on critical updates.
"$ git pull"
You look at the commit notes just to see what you're in for.
"Added lodash, momentjs, and pouchdb to node modules." (or something along those lines)
"$ yarn install"
Mmmk. Cool. You kinda know lodash a bit. You know what moment does but never used it. Pouch is new to you. A quick perusal of the node_modules folder shows a number of other dependent modules also installed. Yarn (or maybe npm) knew what to install.
I'm going to ask a series of questions now. You answer yourself honestly.
Do you know exactly what git pull did? I mean, exactly. Do you know how it was able to determine the difference between your files and the files you were missing or the updates you needed? How much do you know about git in general? Do you know what a rebase is? Do you know exactly how it works? Do you know the algorithms it uses to figure out what to do? Like, I mean exactly what is uses and how.
Especially if you're a junior developer, you just know "$ git pull" and that it does a magical thing to determine what you're missing and then update your copy of the code to the latest.
How about yarn? Do you know exactly how it works? If you open the hood and look underneath, could you explain all the moving parts? All of them? Exactly? How does it tell which packages are dependencies? Does it make API calls somewhere? How does it make those calls? Curl? Something else? What language is it powered by?
Look at all those modules in the node_modules folder. Do you know how each and every one of those modules work? What kind of code lives in them? Why does pouchdb depend on vuvuzela? Exactly? Can you explain that?
Instead you just ran "$ yarn install" and trusted that yarn knew why for you.
So what do you actually know about your job?
Who has the time?
Let's be honest. We are all on a short lease. We don't have the time to know everything. We depend a lot on each other, as a global community, and locally, to learn from each other. There is a certain amount of trust we place on each other's knowledge.
But it's that lack of understanding, that inability to express a concept, because you don't know it, that leads to impostor syndrome.
You don't have the time to get a firm grasp on all the different aspects of your job even though you may feel that you must.
We've made it worse
I'm expressing a personal opinion here but I think we've made the whole problem worse, as an industry.
Companies are less willing to invest in their developers long term. That means companies tend to push stricter timelines to accomplish business goals. That means developers have less time to learn. So they depend a hell of a lot more on others having sorted something specific out for them. Then the developer has to pick a bunch of specifically pre developed stuff, smack it together, hope it works. More experience at that means you get better at smacking it together.
On top of that, we, as developers, agree to work under these restrictions and look for the easy way out and we accept our fate and we keep publishing more and more libraries and frameworks ad nauseam and it gets overwhelming. We don't all agree on everything. We're too short on time to come to a general understanding. We just throw another library into the mix and it's done our way and we understand it best and that's that.
I've generalized this a lot and my statements are not entirely true but I think they do state a majority of what's happening in our community.
How can you deal with this?
Having considered all things, it doesn't surprise me that we suffer from impostor syndrome.
But don't sell yourself short. There is a certain skill in knowing how to use a tool as there is in knowing how to make a tool. You don't always need to know both. You can be a useful member of society if you're good at your job because you know when to use a hammer versus a drill, for example.
Must you truly know every nook and cranny of code and languages and technical hardware and stacks in order to create something cool, powerful, or meaningful?
I think the history of the technical world shows that the answer is pretty clearly no.
Remember, you will feel like an impostor. In some ways, we all are. But that doesn't mean you're not a developer. It doesn't mean you're a bad developer either. It just means you have a lot to learn. That's ok. We all do.
Top comments (3)
I loved reading through this. Lots of interesting points to argue about. In general, indeed I think the "imposter syndrome" is no stranger to a lot of us these days, especially people working in something I'd consider "creative professions". However, there is one thing in here:
This has two implications. First off, indeed it leaves a load of us feeling like imposters while most of the time, like sleepwalkers, dancing on a thin wire right above an immensely deep ocean of complexity in which we would immediately drown. It's difficult to be in this situation from a personal point of view. But it's also difficult from an enterprise and quality point of view: What will happen if you end up continuously building software just like that? You end up with software built out of third-party bricks, in most cases glued together by people who have just a very vague idea of what pieces they are using, how they work and what they do. This is a nightmare in terms of virtually every non-functional requirement you possibly could imagine (reliability, stability, quality, ...). And this is the point where, then and now, I recommend people to, at least a bit, take that "imposter syndrome" seriously - and not by accepting that it is there but by trying to get rid of it, by trying do actually do dive into that complexity, trying to understand how most of the tools work and eventually trying to get rid of things they don't feel reasonably safe using. This will of course slow you down a bit, but it will reduce imposter syndrome and improve overall software quality, which definitely seems a win-win to me. ;)