guitarino profile image Kirill Shestakov ・5 min read

I'm trying to formulate something I've been feeling on a subconscious level in my experience as a developer. This article is a mostly pointless brain dump trying to express it. It's also a bit of an opinion on how I think the programming world should be. I could talk for hours justifying every statement I make here, but I decided I'm just going to express it as a short opinion, and leave it totally up to you whether you feel the same way or not.

Strong opinions

I often notice a certain character trait of people in our industry. When reading, say, articles about best practices, I often see authors convincing others that some practices are very bad. Such authors blame those practices for turning their code into spaghetti, they blame everyone who disagrees with them for promoting bad practices, and, of course, they passionately try to convince others to never use those practices. I felt that not only from the authors, but also quite a bit from people who just comment, and somewhat from my colleagues. Just to give a bit of an idea, there was recently lots of hate towards OOP, and praise for FP as the only true way. There is a plenty more examples I can name (and perhaps you can name too?), but right now I just want to talk generally about it.

It's not just about articles and posts. I often see developers dismissing each other's ideas in other ways. For example, developers of competing frameworks like to have beef with each other, which is especially clear in the front-end webdev community. Sometimes there is even a monetary incentive behind their quarrels. Some developers are strong believers in cloud development and laugh at those who aren't. Some developers believe in one language over another, they urge everyone to completely drop certain languages in favor of another. Sometimes I see the ideas being dismissed because they are not "standard", because they go against the accepted norm, and perhaps against code consistency. But really, behind it all, I often see only emotional, misguided or irrational impulses.

Programming 🆚 Arrogance

Programming is like a big galaxy. It's a big space, albeit mental space, filled with objects, connected and isolated systems, curious and varied internal, sometimes self-similar structures, with history, and with many interesting properties. Just like (and definitely related to) the ability to speak and do math, programming capability is universal among people. Any person can learn programming, just like any person can learn to speak and do math. Once they do, that big "galaxy" starts to appear in their mind. There is as many "galaxies" as there are programmers, they have different shapes, different structures, different histories, and different properties.

What happens when we look at someone else's code? What happens when we see a technology we're not used to, a different framework, a different way of thinking? What happens when you see someone who disagrees with the majority? What happens when someone goes against what you're used to? Almost automatically, we start judging and criticizing. We unite in groups that approve of something and disapprove of something else, we find like-minded people and stop talking to others, and we often end up in bubbles that polarize and limit us, without even us realizing it.

We do that because of our arrogance. We think we are smarter than others. We often think we are smarter than our colleagues. We think we know how things should be done, which frameworks should be used, what languages are good, what languages are bad, what constitutes good and bad practices, what should be considered a "standard". We think we know better than others. Even if you don't think like that right now, it is possible that you might start thinking like that at some point. Unfortunately, I used to also have strong beliefs like I described, but I'm actively working against them.

I can feel that arrogance is quite a common trait among somewhat experienced developers, and I believe it has a strong negative impact on our industry, on those who are learning programming, and I dare say it's partly responsible for the lack of women in programming. When the programming has a character of a boys' club where everyone competes to appear smarter, to enforce their strong opinions with loud voices, often portraying those as good practices or "standards", no wonder many feel unwelcome.

Clear mind

What we should be doing instead is learning from each other. I believe that no matter how many years of programming experience you have, you should keep learning from your peers. I believe that the best programmers (as well as best mentors in general) are those who are also non-stop learners, those who always keep a clear and non-judgmental mind. Those that can show you their own way of thinking without diminishing or dismissing yours. Those that collaborate instead of quarreling. Those that focus on code readability, maintainability and performance, rather than practices they read about.

The more coding a person does, the more their "galaxy" becomes clearer. The trick is to realize that everyone is on the path of seeing more clearly, including you. You should not slip into thinking you can already see everything clearly, hereby declaring a universal truth. This would lead to imposing your vision on others, imposing the picture of your "galaxy" rather than letting them discover their own. This could blind people or make them lose interest in programming, this could limit the ways they express themselves, their experimentation, preventing them from learning and self-discovering. Since everyone is on the path of seeing more clearly, accept everyone on the stage they're on. They're on the path - they will keep growing, keep improving, keep discovering. But for the time being, accept their personal coding preferences and quirks.

I believe our industry can benefit if it focuses on code readability, maintainability and performance. If those qualities are satisfied, everything else should be accepted. Different ways of thinking, different syntax, different solutions, in fact, differences in general. Differences allow us to learn more from each other. During code reviews, I believe differences should be accepted, as long as code is readable, maintainable and performant. I also believe you should accept that people choose to use a different technology, a different paradigm, and I encourage you to seek to learn from them rather than believing that you know better.

Just like you treat your friends and your family members, as long as they don't hurt others, you accept their personality and their uniqueness, so should you accept your fellow programmers, collaborate and learn from them, instead of competing. Those who even begin to compete for being smarter have already lost - they have stopped seeking the true nature of their programming ability.

So let's keep learning, experimenting and collaborating. And let's eradicate arrogance within ourselves. If you're a beginner, don't be discouraged and don't lose hope. Keep trying, keep searching and keep exploring. You will do great things. ✌️

Posted on by:


markdown guide

The feelings that spur on such reactions aren't arrogance, I don't think, so much as desire to minimize deviation from a "comfort zone". Yes, it takes humility to try other ways of writing code. But it's also entirely natural to not want to. Perhaps it is laziness. Perhaps it is the personal, private need to associate habits with lessons learned, and the feelings of insecurity when those associations are challenged. You're right that this is something that many if not most of us devs are guilty of doing, but it's not so simple as boiling it down to arrogance. It might be as simple as cognitive dissonance.