In the dynamic landscape of software development, a transformative concept is gaining prominence: "Egoless Programming." Rooted in collaboration and humility, this approach transcends individual ego to prioritize collective success. This article delves into the tenets of egoless programming, its impact on project quality, and its role in cultivating a harmonious development environment. A fresh perspective that could steer developers toward more efficient and fulfilling horizons.
Egoless programming," also known as "programming without ego" in French, is a concept in the field of computer programming that encourages developers to embrace a humble and collaborative approach when creating software. The fundamental idea behind egoless programming is for developers to set aside their ego, biases, and personal desires in order to work together constructively and produce high-quality code.
The key principles of egoless programming include:
Focus on Results, Not Individuals: Emphasis is placed on achieving project objectives rather than seeking personal credit or recognition. Programmers prioritize what's best for the software and its users, rather than their own glory.
Embrace Constructive Criticism: Programmers should be open to feedback and suggestions from peers. They should be willing to challenge their own code and make improvements based on received feedback.
Team Collaboration: Egoless programming promotes effective collaboration and communication among team members. Programmers should be ready to share knowledge and learn from others, rather than monopolizing expertise.
Continuous Learning: Programmers acknowledge that there's always something new to learn and discover. They should be open to continuous learning and skill improvement.
Minimize Code Ownership: Instead of clinging to specific code as if it were their exclusive creation, programmers should encourage code sharing and collective improvement.
Egoless programming can contribute to code quality enhancement, reduce conflicts within the development team, and foster a more positive and collaborative work environment. Ultimately, the focus is on creating high-quality software rather than individual programmer ego.
Top comments (14)
Almost all company will want their developers to be egoless. Because, egos among team members will do neither the company and the members any good. It is therefore a quality that all developers must have. It is a good thing to be humbe and show empathy on those you are advance than in your area of expertise.
Nice idea in principle, but awfully difficult in practice. Coding is an art form, and a very personal one at that. What one person sees as their great achievement may be viewed as flawed by someone with different sensibilities. It's entirely possible that neither person is more 'right' than the other, and it's entirely natural to be protective of your code.
I like this.
I've come to realise that everyone's learning something new everyday - it's to our collective benefit to make the experience as pleasant for everyone as possible: positivity generally encourages further positivity.
Everyone makes mistakes too. Issues pointed out in code are a reflection on the state of the code, not the author - it's important to not take these as personal 'attacks'.
It's a shame that being egoless can get you left behind in some companies' performance reviews though.
About your last point: yes it is a shame that it happens. That's where company and team culture play an important role in safeguarding against that kind of evaluation. I've seen companies where it's only a few team leads/managers who fight to make positivity and growth a priority. It can be an uphill battle.
I don't trust this idea. I imagine most defenders of egoless programming are thinking how those pesky developers, so full of themselves, should think more about the team and the results. How many are thinking how they themselves should tone their own ego down?
I also believe self-reflection can be easier than criticizing others, for certain people. That's where the team's culture of accountability comes into play.
Without a strong sense of shared responsibility, the "this does not apply to me" attitude can happen easily.
This is how you should approach everything - not just programming.
A lot of the time we as developers lose sight of what's important. Building anything is a collaborative effort, and we shouldn't let ego get in the way.
Exactly
I hadn't heard of this idea of programming mood. I really like it, and i agree with @noblica when he says that this is how we should approach everything. People are always too much focused on "Me" and "I" and that's the beginning of going nowhere or hurting others. So totally embrace this approach to programming but also in everyday things and everyday life!
Then it's easy... just let AI write the code, and get rid of the programmers? (joke)
For context, it would appear that egoless programming is a 1971 concept recently unearthed by Jeff Atwood... for whatever reason.
Not feeling negative about these thoughts but I do think you should bring up the context and back up your claim that "this is gaining traction". Otherwise we'd be left thinking the main reason there is traction is because of Jeff's blog, in blatant contradiction with egoless programming cmd #7
That's also a nice way for companies to never reward good developers by keeping this "egoless" trip ...
I don't say we shall score every developer effort, but ignoring individuals inputs in a common effort doesn't improve either salary, recognition, recommendations and so forth.
In an environment where teamwork takes precedence, the focus on climbing the corporate ladder through individual achievements and reviews can be diminished. This could potentially discourage individuals from striving for excellence in their own work, as the recognition and rewards that often come with individual accomplishments might be overshadowed by collective outcomes.
Also, how can we want to ignore ego and therefore the people to get to a common goal while we still get individual reviews/results ? That makes no sense at all.
It's mediocre at best, best at mediocre.
Not everyone lives in America, nor we all make 6 figures salary.
I see a lot of people mentioning that's it's impossible or even not desirable. I can't even understand how individual ego can get a team anywhere. All team I've been with one or more developer with a clearly visible ego stayed almost static for months, project where abandoned, assigned to another team, for into external audit to assess those ego claim and most important, all of them had a high turnover rate.
Ok the other side I've been on 3 different team (so not the majority) where in the ego balance it was clearly on the egoless side, the team was stable for year(s) feature where delivered, the whole code base was cleaner and in the most important part, at any given time any developer that knew that teckstack (not so dev are fullstack+mobile dev) could jump in and work on any part of the code.
As for how to get there, or start by ensuring everyone is listened when they speak, making sure dev help each other. Then, do code review on an helpful way. Speaking of code review, junior dev should review senior code, not only to learn, but to do proper review and give their constructive feedback on it. If all of this goes well, the team is more on the egoless side and will move forward way faster than otherwise.
Lastly, in term of personal evaluation and company progression, I'm now the one in charge of those evaluation and a great developer the work on his side, protecting his code not sharing the success with the team is not getting a positive evaluation. Because even if the success (and failure) are shared as a team, from inside the team we do know how each member contribute and act within that team and we do acknowledge individual effort, but coming from the team, not from an individual seeking recognition.
I love this as an idea. Do you have any recommendations on implementation? What methods have you seen be successful in finding the individuals and building this kind of culture?