Egoless programming

A few weeks ago, I was reading a discussion about “the most valuable thing you learned this year”.  One of the answers talked about the value of “egoless programming” http://programmers.stackexchange.com/a/15900/90342

At the beginning of several projects, I have participated in discussions about architecture.  We discuss concepts like: which approach, platform, framework, (etc) is going to be the best one for this project?  Everyone has their opinions, which are usually based on past-experience. “I had success with this approach before.  I’d like to be successful again.  So I think I should play it safe and stick with [what I know] instead of [trying to reinvent the wheel]”.  Then the next person says the same thing, but with a different twist and different list of technologies.

Then there is sudden silence.
The wind blows and a tumbleweed rolls past.
Everyone clears the saloon and the theme from “Bonanza” starts playing.

Egoless Elitist?

This really tests the foundation of [what makes a person a good programmer].  Although I may be an elitist, I also believe this: To be an elitist, you must be willing to be humble periodically.  Humble people have open minds.  Without an open mind, it is very difficult to learn anything.  Learning is the cardio-pulmonary system of a programmer.  Maybe you can hold your breath for a while, but to survive, you need to take some breaths, (often) and a programmer needs to learn.

In contrast, closed-minded people often are the victims of their own arrogance and stubbornness.  They talk more than they listen and end up with a foot in their mouths. I love the saying: “To keep your foot out of your mouth, it is best to keep it closed”.

Egotism and Folley

One of my favorite geek-humor web sites is “the daily wtf”.  Many of the posted stories are tales of companies with an arrogant programmer who is the master guru and unquestionable czar of all technology at that company.  The stories usually document one or more epic follies made by the master guru and the ensuing antics.  In the discussion area, below the article, there are many comments like this:

  • Whenever somebody gets promoted to guru, he should be fired for the good of everyone
  • This guy’s narcissism will bring this company down
  • Wait a second, you guys don’t know all of the decisions that this guy handles.  Maybe his solutions look weird, but maybe there are solid reasons behind his madness that would make sense if you could see it through his eyes.  (then, people respond with “boo, hiss” and vegetable throwing)

I find discussions, like these, to be fascinating.  Each of them has some validity (under the right conditions) but each of them could also be terrible advice (under other conditions).  This is the fun of discussion boards.  People are jumping to conclusions like it was a gunny sack race.  It is actually a little guilty-fun to over-react and join the food-fight for a while.  However, this isn’t reality and it isn’t a way to exercise or strengthen your professionalism.

What Egoless Feels Like

At a few places that I’ve worked, I’ve introduced the concept of code reviews.  They really seem to bring out the rats.  I’ve actually been approached by a programmer (or two) with a big ego and told “Hey, what if one of these junior programmers finds a flaw in your program and takes you to school?  You will be humiliated.  Do you really want to take that chance?!” When I responded “yup”, the other person ducked, for fear that my ego would cause my head to swell suddenly and knock him over.  Heh.

I continued, “I hope I learn something.  If my code is wrong, I want to be corrected sooner, not later.  If a junior person schools me, then I will probably ask him to review my code more often.   I hope that happens”.  I suppose maybe I was bluffing a little, but I intended to stand behind every word that I said, no matter how much it hurt.

Later that week, my bluff actually did get called.  The code review revealed that I had cut a few corners, there were a few opportunities to refactor and even two logic gaps were discovered.  I felt a little like Foghorn Leghorn with my feathers blown-off.  “Fortunately, I keep my feathers numbered, for just such an emergency”.  I took it like a man, even when a few people had a little fun with me.  After the code-review, some of them may have felt a little guilty for teasing and even apologized.  “No problemo” I said, “Let’s do better next time, okay?”

Next code review, everyone checked their egos at the door.  We all showed impeccable manners.  Nobody wanted to do any teasing any more.   As a result, nobody felt defensive and we learned a lot.  We even talked about our process and some of our standards; did they make sense under all conditions or were there some exceptions?  People opened their minds and tried to bend a little more.  We were willing to consider different ideas and try a few new things instead of dismissing them.

I think we all became a little more elite, that day.

Advertisements

About Tim Golisch

I'm a geek. I do geeky things.
This entry was posted in IT Psychology, Professionalism and tagged . Bookmark the permalink.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s