Much has been said about imposter syndrome so you might rightly wonder why yet another variation on it? That's because I think there is an angle to it that doesn't get enough air time. The angle is that most software is outright user hostile and many times it is not human inadequacy that is the problem but our tools actively fighting us every step of the way in a very obnoxious manner and preventing us from realizing the full potential of an idea.
Everyone at one point or another overcomes the feeling of being an imposter and starts believing that their work is actually valuable and that they are good at doing the work. This generic phenomenon happens in all fields, it is not just restricted to software. But once people get used to not being imposters I think there is a danger of developing Stockholm syndrome in terms of accepting the status quo and our place in it as the way things should be. There is a specific reason I'm calling it Stockholm syndrome and it is probably best illustrated with a story.
I recently started playing around with C and immediately, just like in my college days, started running into segfaults. This is why I gave up C a long time ago. I realized then that life was too short to be chasing segfaults but there was a deeper realization rooted in that one and it only recently dawned on me.
Why does Linux kill a segfaulting process with extreme prejudice? Why can't Linux open up a debugger and let me inspect the state of the process to figure out what is going on? What is the reason for such an obnoxious design decision? Not only does Linux kill the process but it wipes all traces of its existence from memory, literally. I think this is insane! I think it is insane because I once saw a more humane design decision. The humane design decision was in a smalltalk environment and here's what it looked like
The above is an image from the Pharo smalltalk environment. It is running a test and showing the results of the test along with the test code and the state of one of the objects in memory. If you so desired you could single step through each expression and see the evolution of the state of each object. I think there are even enhancement to the debugger that allow one to see the references among objects and view the object graph as an actual graph with nodes and edges linking them.
I think that's what all programming environments should be like. I think modern tools are nowhere close to where they need to be to allow humans to express their intentions in the way they are meant to be expressed. Linux, the command line, IDEs, text editors, etc. are all inhumane ways to interact with computing tools and artefacts. So next time you are having doubts consider that it is the tools that are the problem and not what's inside your head. Don't settle for overcoming your imposter syndrome. Consider what the world would be like if we could wipe that notion from the field of computing entirely by building more humane ways for us and others to interact with computers.