Background

The late basketball Hall of Famer Kobe Bryant while sharing life lessons drawn from his famous Mamba Mentality had this to say;-

“It’s not about you, man. Like ok, you feel embarrassed you are not that important like, get over yourself. That’s where you go,” — Kobe Bean Bryant (Deceased)

And this very much applies to software development as well.

As a Tech Engineer, I couldn’t agree more that reflecting on the 10 commandments of Egoless Programming every now and then has a way of bringing out the best aspects of technical professionalism.

Introduction

The 10 commandments of Egoless Programming was inspired by the book, The Psychology of Computer Programming, first released in the 1970s, where Gerald Weinberg coined the term “egoless programming”. What Weinberg wrote in that book was a set of guidelines for developers working in a team environment to keep their egos separate from their code.

It is a must-read piece for developers, Software Engineers, IT Project Managers, and Tech Leads to say the very least.

The Commandments

Today’s ever-growing technology space is continually being dominated by more developers & technical thinkers/practitioners than ordinary personnel which is a big reason why more than ever the “10 commandments of Egoless programming” should be the moral guide for all those seeking to solidify a career in software development/engineering and other applications or system development related endeavors. So let’s look at them.

1. Understand and Accept That You Will Make Mistakes.

The point is to find them early before they make it into production. Except for a few incidences, mistakes are rarely fatal in our industry. Therefore, we can, and should, learn, laugh, and move on.

Mistakes can cause a lot of frustration, which in turn takes up task completion time. Working with a team helps Software Engineers and Developers grow into the habit of asking for or seeking help.

2. You Are Not Your Code

Remember that the entire point of a review is to find problems, and problems will be found. Don’t take it personally when one is uncovered.

As a Software Engineer and Developer, learn not to get too attached to the code you write, and you will start to appreciate being your own critic and reviewer before your colleagues and boss step in.

3. No Matter How Much “Karate” You Know, Someone Else Will Always Know More.

Such an individual can teach you some new moves if you ask. Seek and accept input from others, especially when you think it’s not needed.

Forums like GitHub, Stack Overflow, and medium to mention but a few can be very helpful here. Colleagues contribute a lot to the professional growth of a junior developer. But outside one’s immediate workplace or social tech circles, these forums continue to be very very productive.

4. Don’t Write Code Without Consultation.

There’s a fine line between “fixing code” and “rewriting code.” Know the difference, and pursue stylistic changes within the framework of a code review, not as a lone enforcer.

Team meetings and daily standups suck, but they are also lifesavers. It’s always during those sessions that timely feedback can change the tide of a project or code review. Code Reviews and reading the documentation from other Software Engineers and Developers is also very important.

5. Treat people who know less than you with respect, deference & patience.

Nontechnical people who deal with developers on a regular basis almost universally hold the opinion that we are prima donnas at best and crybabies at worst. Don’t reinforce this stereotype with anger and impatience.

Opinions and views often matter a lot in the tech space, as every idea however small can be the next best solution to a complex, reoccurring or previously unsolved problem.

6. The only constant in the world is change.

Be open to it and accept it with a smile. Look at each change to your requirements, platform, or tool as a new challenge, not as some serious inconvenience to be fought.

Sometimes change is inevitable and just in incases you don’t agree with changes, the best approach is to always see the opportunities therein.

7. The only true authority stems from knowledge, not from position.

Knowledge engenders authority, and authority engenders respect — so if you want respect in an egoless environment, cultivate knowledge.

You can never go wrong with having a thirst to constantly grow your knowledge.

8. Fight for what you believe, but gracefully accept defeat.

Understand that sometimes your ideas will be overruled. Even if you do turn out to be right, don’t take revenge or say, “I told you so” more than a few times at most, and don’t make your dearly departed idea a martyr or rallying cry.

These are usually very tough situations and can be very hard to get through but then again they are usually the times we learn and grow the most.

9. Don’t be the guy in the room.

Please do not be the guy coding in the dark office emerging only to buy cola. The guy in the room is out of touch, out of sight, and out of control and has no place in an open, collaborative environment.

A lot of “techies”, software engineers and developers face this challenge, as collaborating requires keeping in contact with colleagues, clients, and non-technical bosses. This is often perceived as “leading to a lot of wasted time” technical personnel feel can be used productively either building, mentoring, or resolving technical issues yet is considered valuable bonding time for the non-technical person. This is a grey area.

10. Critique code instead of people.

Be kind to the coder, not to the code. As much as possible, make all of your comments positive and oriented to improving the code. Relate comments to local standards, program specs, increased performance, etc.

This applies to other areas of human interaction, especially arguments and disagreements.

Conclusion

Spending time reading The 10 commandments of Egoless programming every now and then has helped me find value in my work as i continue to pursue a sound technical professional career.

References and Reading ReSources

• Book Review: A Philosophy of Software Design by John Ousterhout.

• Book Review: Scrum by Jeff Sutherland.