About a programmer’s ego.
Thoughts on the psychological factors that can affect software development teams.
“With great power, comes great responsibility”.
(standard message of almost every superhero movie)
It is not uncommon for words of exclamation to be heard in a software team’s office space every now and then, such as “guys, who sneaked into my code again?”, or “this thing was working fine when I pushed it yesterday!” or even “please don’t touch those code units while others are working on that feature”. These “eruptions” are the results of one or more of the developers being “cowboys” for a little while (that means, deliberately circumventing team collaboration protocol), and they can occur seemingly “out of the blue” even within well-organized teams. There are times when a developer subconsciously desires “his/her own way of solving a problem” to be adopted by the team and “his/her own code” to make it to the main branch. These occurrences can lead to real-world behaviors that create a subtle sense of friction and in a few cases, tension — thus compromising the nice atmosphere and the overall quality of the final product in the long run.
“But how can those ‘cowboy’ situations occur if the team is properly organized?”, one might ask. The answer is that they can happen, if the team members’ ego is not kept in check. So let’s elaborate on a few factors that contribute to the potential development of such moments of high ego within a programmer’s work environment.
Being a software developer or software engineer can provide you with a sense of power; particularly after the first few years in the profession. In my opinion, this is happening for three reasons: firstly, the machine can in many ways be viewed like a fully obedient servant — always ready to perform as you, the programmer, instruct it to. In addition, software development teams are supposed to rarely experience emotional turbulence, because they are safely isolated from their clients by means of a Product Owner or any other equivalent mediating entity. And on top of that, each member of a software development team gradually tends to become remarkably skilled in a highly specific implementation spectrum within the team’s objectives. The overall result is that programmers develop an invisible “shell” around them; their own personal “world”, which they understand perfectly and are able to control.
A frequently overlooked but significant factor in the development of a higher ego, is the local and social environment outside of the workplace. Commuting to the office or even taking your car to enjoy a ride along the seafront can sometimes become a tedious and/or difficult experience: highly crowded cities, frantic traffic, noise and air pollution — all these are possible sources of annoyance. And when they are inflicted on persons on a daily basis, they can also contribute to the slow, gradual formation of a defensive mentality towards others; an instinctive need to obtain the ability to “overtake, outvoice or overpower” others. In the case of software developers that could translate for example to “I need to get that tormenting bug fixed NOW, before its ticket is added to the board …”.
Another factor is the programmer’s individual culture — how they have been raised to respond to situations of everyday life as well as how they regard their own self. The ability of an adult person to be polite and patient is well-known to have its roots in the specifics of their childhood development and it is a fundamental element of a smoothly functioning development team. Even a momentary absence of this element in any member of a well-organized team can be immediately felt by everyone in it, creating a declining mood and possibly leading to the previously mentioned “eruptions” of other team members. The second part, regarding how a person views their own self, is also of crucial importance. It is primarily about the self-induced factor that we call “blame” and how a person manages it. It is about how a person can accept their own responsibility for an objectively verified mistake they have made, how to correct it without developing negative emotions towards themselves or towards the persons that brought it up and move on; thus gaining experience and growing as a professional.
Consequently, a huge boost for developers in acknowledging their own mistakes without blaming themselves, is the absence of micromanagement upon them. Every programmer has experienced that awesome feeling of “being FINALLY left alone” to do their job without someone looking over their shoulder all the time! And of course, this is definitely about trust. Providing team members with an evident atmosphere of trust is crucial in alleviating any spontaneous urge to “go cowboy”, because that can satisfy a programmer’s ego in a healthy and productive manner. If your colleagues trust you, then you definitely know that you are important to them and as a result you instinctively learn to put the team before yourself.
I truly believe that a team which manages to concurrently encompass all of those three basic ingredients (trust, self-appreciation and self-restraint), can effectively diffuse any spontaneous moments of high ego and create great software with minimum effort.
References
