Software Dev is Hard -- Don't Be Negative About It
Is negativism between developers the norm? Probably not, but it’s common. Do developers ever compliment each other? Yes, but it sometimes seems rare. When I step back, it does in fact seem that there is sometimes a noticeable wealth of negativism and a noticeable lack of complimenting. The nature of software and its developers may contribute. But we can overcome our challenges.
I realized this the other night when I read this tweet:
I rarely hear developers compliment each other. It’s usually negativity about how someone else “did it wrong.” #sad
I agree with the sentiment. I think it’s too often true. And that is sad.
So why do we developers often lack in our compliments? I’m sure the reasons are varied. Here are some of my thoughts about the nature of software development, the people who develop it, and how these factors might contribute:
Software is Hard to Write
Number one, software is just generally hard to write. Tons of it is produced daily, but a very small slice of the pie would probably be considered truly spectacular by anyone. But if this is really true, that means that we very often kid ourselves into thinking that what we could do is any better. (It would be us now trying to solve the same hard problem.)
Infinitely Malleable Medium
Software, because it’s virtual and does not conform to many physical laws, can be bended and twisted into just about anything you can imagine. There are so many ways to get from point A to point B. And whatever the end goal is could be infinitely improved upon. We only stop because we run out of time, money, or interest.
Code as Art
Related to its malleability, creating software, in my mind, is absolutely an art form. So much of a solution will be shaped by the person or people that create it – their combined biases, tendencies, heuristics, and styles. This is what makes software fun to write for the creative person – you can put yourself into it. Often it is probably the case that others don’t appreciate some bit of code mostly based on its style, just as not everyone enjoys the same flavored food (even though it might give you the same energy and nutrients when you eat it) or just as not everyone likes the same paintings (even though they might depict the same landscape or portrait subject).
We’re Too Protective
Software, because it is hard to write and because your own style is so embedded in the product, is often seen as some brain child of the creating developer. And of course, which mother doesn’t believe her baby the cutest? We are often blinded by this instinct.
Software is often used to solve or make simpler many of the complex problems or questions that we face in just about any field. Thus, related to software malleability and difficulty of development, software can balloon in complexity quite quickly. Now, sometimes we as developers introduce a fair sum of our own accidental complexity, but of the problems software solves, there is a great potential for huge inherent complexity.
Often times sotware that is written for one purpose is put into applications never imagined when the software was originally conceived. This can easily create situations where the software is not looking very elegant as a square pegged hammered into a round hole.
(Out of) Timelines
It is all too often that software is developed under crazy, unrealistic timelines. Unrealistic only if you want your hard problem solved correctly, in an elegant, maintainable, stable manner. The reality that we often buy with our crazy timeline is code that barely works for the stated business case but code that needs rewritten or cannibalized as soon as the situation or people change.
Developers that I’ve met are generally bright people that are doing their best to complete the challenging tasks they’re given. But we’re usually not the most socially-enabled bunch. We’re often content grumbling and mumbling – gollum! – at our desks (or prone to breaking out into song, depending on who you are). I don’t think this defines us as a species (Developus Sapiens), but our constant machine interaction, I think, tends to wear on our interpersonal skills. We might tend toward more passive-aggressive behavior, or just lack in much communication at all. Another reason for lack of inter-developer compliments? Most of us are men – notoriously competitive. And since we’ve now programmed farm machinery to allow many to do something besides hunting and gathering, we need another field of competition.
There are many bright exceptions to these aforementioned observations of software that pains our eyes, fingers, and psyches and exceptions to our less-desirable developer attributes.
Thank you to the developer that takes complexity and truly innovates, creating the simplest possible solution.
Thank you to the language creators who make languages that expressive, fluid, and guide us toward elegant techniques.
Thank you to the developers that push back aginst horrendous timelines and avoid false heroism.
Thank you to the patient customers and project managers who realize that good software is a gem that is rare and polished over time.
Thank you to the developers that refactor smelly code when they see it.
Thank you to the customers that have paid me even though my code was probably not “done right” at times.
Thank you to the team lead who is willing to try new things or better ways while still learning from his experiences.
Thank you to the corporate management that hires creative people and lets them do creative work without standardizing them into cookie-cutter solutions.
Thank you to the mentor developer who patiently explains to another how code works and why he chose to make it that way.
Thank you to the marketing developer who is willing to stand up in front of his peers and explain why he feels certain software choices are the best.
Thank you to the developer that, while he might create inelegant code, crafts good test suites around it to ensure I don’t break it.
The Bottom Line
There really is no such thing as perfect developers or perfect software. Neither exist. We’re all developing in our capacities across a spectrum – one that evolves at a rapid pace. One where the definition of “good” and “right” code is changing constantly. One where the bar is constantly being raised. We’re in an exciting field. The jobs are many. The problems are interesting. The technology is just getting more amazing all the time.
Let’s help each other out along the way. If it is hard to make software that is sometimes brain-drainingly complex and we live in plain, gray caves, then I’m sure we all need a good word now and then.