Lately, I’ve been thinking about what makes a software developer a good software developer. All the generic things that you would expect came to mind, knowledge, skills with tools/frameworks, memory, teamwork skills, caffeine etc. But all of those are boring and predictable, noone wants to be boring, so I thought harder, I thought and thought “till I couldn’t think no more”. Then I had some tea, then I watched “The Simpsons”, now I am writing this article, but I digress, which actually illustrates my first point fairly well (in a roundabout sort of way, so bear with me).
1. Creativity
While drinking my tea and munching on my crumpets (that’s a figure of speech I wasn’t actually eating crumpets, I was having a croissant … I think I just made it worse). Where was I, oh yeah, while doing something completely unrelated I was able to come up with some interesting points about what makes developers, developers. Unlike what TV and certain other elements would have you believe, most good developers are not just single-minded calculatory automatons obsessed with algorithms, but are rather very creative people. Notice how I made up a word in a very sentence preceding this one, I bet most of you didn’t even realise “calculatory” wasn’t a real word.
The point I am trying to make is that the ideas for this article came to me not through rigorous calculation and formulaic thinking but through inspiration. I stopped focusing on what I wanted to do and let the universe fill me with its goodness (in a completely figurative way) and then all of a sudden KABLAMO! Inspiration strikes and I am able to go and paint a painting (if I could paint), or create a little application to help me manage all my passwords (which I certainly can do), or write an article about developers (which I am doing right now). I bet you missed how I made up another word, kablamo, yeah I know, I am plagiarising it from someone, but plagiarism is the reality TV generation’s brand of creativity so it still counts.
2. Insane Curiosity
Many people are curious, but I find that many good developers are overly curious even when compared to your average Joe Curious. I would certainly fit that description. You’ve probably guessed that I am writing all this while operating under the assumption that I am a fairly good developer, since I use myself as an example so much. So, if you could all just suspend your disbelief for a few minutes and share that assumption with me we’ll be able to proceed with the rest of this article.
This trait of curiosity doesn’t just begin and end with software but extends to all facets of the life of a software developer. This is why most good software developers that you meet have one, two or sometimes even more alternative “things” that they really like doing and could probably make a living in if they weren’t doing software. It is also a really helpful trait in the IT industry with it ever-changing landscape. If finding out new things and learning new skills was a chore, one would find it very hard to keep up with the pace of the industry. But when you take insatiable curiosity into account, keeping up with the industry becomes a natural thing, a result of the personality of a good developer.
Finally it certainly doesn’t hurt to be a curious individual when your job involves constantly trying to get to the root of complex problems. You have to have the “need to know” rather than just treating it as a job.
3. Finding Fault With Absolutely Everything
Good software developers are ornery and opinionated, it is a fact, accept it. And the special power that the lot of them share is the ability to always find something to complain about. When it comes to code this trait presents itself as the perception that nobody else’s code is ever good enough, not even your own.
No matter how well the code is written, when good developers get their hands on it, they will always find a reason why the code is crappy and should be re-written/refactored to be “better” and of course they are just the person to do it. In this light this may not seem like such a desirable attribute, but consider that this trait is synonymous with a constant desire to improve. Notice that I never said that good developers like to find faults for the sake of finding faults, but rather they are able to find areas where they can use their expertise to improve the situation and create a better/cleaner/faster/etc system overall.
You could only hope and dream that the person who is building your house has this kind of attitude, if they did we might be able get some damn decent construction once in a while. For the moment though we’ll just thank the all powerful spaghetti monster in the sky that construction workers don’t build software, and hope that this trait of good software developers gets the recognition it deserves.
4. Working Hard To Facilitate Laziness
Developers are the hardest working lazy people you’ll ever meet or possibly the laziest hard working people. Developers love to write little tools and find little ways to make everything more automated which would of course make our lives much easier. Our goal is to get to the point where we just sit there and our little automated tools do all the work, from writing code to calling home and telling our wife/girlfriend/robo-doggie that we’ll be late for dinner.
At least that’s the myth that we all perpetuate amongst ourselves. We are all well aware that the more we streamline and automate and find ways to make our life easier in general, the more work appears to fill that five minutes that we’ve saved. Applications become more and more ambitious and the good developers have to once try to flex their ingenuity to shave off some time in all the right places. And then the application will become more ambitious still and the cycle begins again.
This trait is the reason that the software industry has come as far as it has in such a relatively short time-frame. The good developers find ways to do stuff more efficiently, to automate and streamline, all in the name of supporting their laziness habit which allows more room for grander scope and vision. If it weren’t for this trait that all good developers share we’d still be writing the next greatest calculator application using LogoWriter and punch cards (Go LogoWriter!!! You shall live on in our hearts forever! Amen!).
Well that’s it, I had all this other stuff to say, it was all really awesome, but I can’t be bothered. Hmmm, an application that figures out what I can’t be bothered saying and notes it down anyway. That’s gold! I’ll make billions! Where is my drawing board…?
Would you like to share your thoughts on the unlikely traits that good developers have, or maybe you’d like to critique my thoughts? Leaving a comment is your opportunity, you could even try to automate the process and then I’ll have to put capchas in (*sigh* it’s a never-ending dance).