Programming is a field rife with opinion, debate and exciting ideas. These aspects bring with them a broad spectrum of 'egos' you will likely encounter if you are active in this field. This article aims to expose the common egos that programmers often exhibit, as well as provide advice to avoid becoming them!
I believe that the egos of programmers can be lumped into seven specific personas, each encountered many times in my own exploration. Each of them have various areas of overlap, and one even embodies a little bit of each. We'll begin with one of the most prevalent egos...
Everyone has at least a little streak of this ego; we strive for perfection in what we do, but The Purist strives for it in what others do. Usually, it's impossible to impress these types - only to earn their critique.
"Don't use *insert language*, learn *insert language*."
"Your code is so inefficient!"
"You used 10 lines there when you could have just 1."
Sometimes their criticisms are valid, but their delivery is nonconstructive. Such more constructive forms of the same critique could be:
"This is a good start, I'd also look into *insert language*."
"Here is a more efficient way you could tackle this."
"As an alternative approach, try this 1 liner out!"
To The Purist; guide, don't command. Respect that there are different ways to solve a problem, and saving a few milliseconds of run time doesn't always matter that much.
One of the more prolific programming egos is that of the Show-boater. Unlike the stereotypical 'anti-social' programmer, this one thrives in the social realm - constantly broadcasting their feats of code to various social channels and video sharing platforms.
This would be great except for one thing - they never run through the 'how', only the 'what' of their workflows. Their goal is to convince you of how amazing they are by fast forwarding their script building process at 300% speed (if show it at all) and 20% zoom factor, all whilst blaring you with some royalty free techno music (to talk would take too much effort).
For the show-boater, programming isn't about programming - it's about them.
To the Show-Boater; it's important to ask yourself why you show your workflows, as well as who your target audience is. Are you really sharing when you hit the share button?
You come across a post going into detail about an amazing script, but hold on a minute... that's your code! Your annotation is absent, but you recognize all your variable names, you've been hit by The Impostor.
Chances are, the Impostor isn't actually a competent programmer, if one at all - they just exploit other people's efforts and present them as their own. The problem with how they operate is that they almost never give any credit to the source of what they used (sometimes edited, sometimes blatantly copied).
I've learnt over time to build a thick skin against these types, as they are very common. We live in age of self-gratification where it can sometimes be easier to believe we're creating, even if we're just copying.
To the Impostor; I'm glad you find inspiration in the ideas of others, but remember that copying an idea returns little value to others as well as your own learning journey. Stray outside the lines drawn by others.
Looks like a post generated quite a bit of interest... and even the source code was shared, wow! Hundreds of comments, yet the author has dropped the microphone and exited stage left - sounds like we've found ourselves another ego - the Invisible Coder.
I get it - we're busy people living in a busy world, but would it kill some people to respond to feedback and questions? When you put yourself out there as an educator, you take on an unspoken obligation to guide and help others - sometimes that means going an extra mile for someone seeking help.
To the Invisible Coder; recall that you likely learnt from many people who guided you along your own journey. Give back to the field that gave you purpose (and probably a means of making a living).
Say you're just beginning to learn to code, and you reach out for some tips. Here and there, you find some helpful leads and then suddenly you're met with a 25 paragraph essay on why programming is the best thing since sliced bread. We've just met The Academic.
There's nothing malicious or contrived about the Academic's motives, they simply want everyone else to feel as excited about programming as they are. Being passionate about what you do is a brilliant thing, but sometimes you need to wind the enthusiasm dial down from 11 when you meet a newcomer.
I know at least a few programmers who almost left the field on their first day, simply from encountering an Academic. Programming is complex, but it shouldn't begin that way - one step at a time is the only way that works for most of us.
To the Academic; remain enthused, but aim to ease people into the ocean of programming as opposed to dunk their head into the water. Try to make your words of guidance as efficient as your code.
Your script finally works, time to share it! Comments and feedback come in, it's going great - then The Promethean shows up. 'This isn't impressive, I did this 2 years ago' - sigh!
Everyone is entering programming at different points in time, and the Promethean fails to respect this. If they've done it before, 'there's no point in anyone else doing it now - go home everybody else, your work is done for you'. This attitude is not helpful, it is bitter - at the world that ignored their past forays, and at the world that will continue to do so.
I personally have three Prometheans on my own LinkedIn network, where I often share basic examples of Python and Dynamo coding. I could block them, but I prefer to keep them around as a silent reminder to others of what we should not become.
To the Promethean; stop raining on parades - join them instead. Lend your voice to the chorus of ideas so that we amplify good ideas rather than muffle them.
When we think of the stereotypical programmer, The Elitist likely comes to mind. This ego is a 'mish-mash' of all the above traits - an unapproachable coding chimera.
They critique from the vantage of The Purist;
broadcast with the attitude of The Show-Boater;
steal with the villainy of The Impostor;
lurk in the shadows as the Invisible Coder;
bombard with the gusto of The Academic, and
proclaim their stake as The Promethean.
I'm glad to say that there are less and less of these types around by the day; as coding becomes more mainstream, the acceptance of the 'anti-social' coder is dwindling. No doubt we've all encountered The Elitist at some point, and we look forward to a future where they no longer have a foot to stand on.
To The Elitist; no advice, you stopped reading after the introduction surely... but I'll see you in the comments probably!
Conclusion: Practice Mindfulness
Ultimately the goal of this article was to raise self awareness so that we may better serve the popularization of the field of programming. I hope that by considering each of these 'deadly egos' you may better reflect on your own approach to the field and how it affects other people exploring it around you.
Always help, never hinder.
- Gavin Crump @BIM Guru