I’ve always wanted to write about this, because this has been a running thought in my head for almost years now.

So here goes!

For those unfamiliar with the phrase, “imposter syndrome” is a psychological frame of mind where the person doubts their capabilities & accomplishments, and believes unquestionably that they are a fraud and have succeeded only by luck.

In other words, it’s when someone’s being too hard on themselves and not giving themselves credit for what they’ve really achieved.

And it’s extremely common, in software development. The reason I can say that with such confidence, is because EVERYONE wants to solve it.

The list of articles go on, but my underlying point is - I’m not alone in this. So yay!

The first time I felt a wave of imposter syndrome wash over me was when I first tried my hand at open-source back in my freshman year.

I claimed an issue and submitted a pull request - and shortly recieved some comments about my code.

The comments, while pointing out a typo or an optimization that could be made, were also breaking my fragile self-esteem and faith I had in myself as a developer.

But yeah, the pointers I recieved did help me improve my code quality.

After that, I spent some time fixing and improving my previous code.

Submitted another PR.

This PR now failed all the CI/CD tests.

BUT! As it turns out, the reason my code failed all the tests, was because of something not entirely my fault.

The reason was, I was using Windows – and the environment of the codebase demanded Linux. This is problematic because Windows uses a different “end-of-line” character that’s invisible to most text editors. But not to Notepad++, which is what I used to finally get my PR to be merged into the open-source project’s codebase.

This was just my first experience with the imposter syndrome.

It started popping in very often, after that.

• the SWE internship at Deloitte at the end of my freshman year.
• starting this technical blog.
• at Harvard’s Hackathon (HackHarvard 2017).
• the SWE internship at Cisco at the end of my sophomore year.
• giving a technical talk to other CS undergrads.

Every step of the way, I was constantly thinking “Um, hey, I think I’m just lucking out everywhere – someone pls slow me down.”

I think the imposter syndrome is good and bad.

For starters, it’s bad because – well, it feels bad. Nobody wants to feel like a fraud.

Furthermore, I think the field of software development lends itself to imposter syndrome because -

• All work is measurable.

  Owing to time and space complexities, and even otherwise, it’s very easy to measure the “efficiency” of solutions. Consequently, I can’t help but think any optimizations made to a program over time leads the initial developer to associate the degree of improvement to their lack of skill.

  I wouldn’t really feel proud of myself if another developer came in and improved my code by 500% in a few days.

• Global competition.

  This extends from programming contests, to open-source PRs, to full-fledged industrial product development. The world of software is very small, and competition is global – it’s not limited by physical/geographic distance.

  Because of this, the quality of competition is insanely high and that’s just another reason to not feel comfortable.

• It’s easy to forget the difficulty of things.

  In the process of comparing, or working alongside highly capable developers, its very easy to lose track of the cutting-edge work or the high quality of development that’s going around.

• Accountability for any code failures.

  I’ll admit it – it’s scary to be accountable. It’s hard to predict if users can break your code. And no matter how much I test it, I think I’ll always have that lingering sense of “Have I tested it enough?”

All that being said, I also think the imposter syndrome is a good sign.

Have you heard of the Dunning-Kruger effect?

The Dunning-Kruger effect, is the relationship between an individual’s perceived knowledge of subject matter, versus their ACTUAL knowledge of it.

Observe the graph - and you’ll notice that newbies, and inexperienced developers stay under the assumption that they are familiar with all that exists in the field.

A simpler way of interpreting the graph, is - The inexperienced do not know what they do not know.

It’s that simple. The experienced developers, or those on the track to becoming experienced, know how vast the field of software development is.

They know what they don’t understand – and eventually learn and fill in the holes in their knowledge.

So the imposter syndrome is a good thing! It shows that I’m not a newbie or inexperienced – since I’m aware I have a long way to go. :)

It feels bad, but its also good!