As a coder, I've long had the theory that there are two types of coders, and you can tell which type you are with the following test: when you come across someone else's code and it appears wrong, do you assume that you've misunderstood it in some way and there are good reasons why it is the way it is, or do you assume that the person who wrote it is a bad coder?
Now hopefully you think that every reasonable coder is in the first category, but I've been surprised in my career at just how many coders have the first instinct to shit all over other people's code (but let me be clear here, all of the coders in my current workplace are thankfully the first type). I don't know if it's due to ego, insecurity or something else, but a lot of coders feel the need to criticize other coder's work, and not in order to be helpful!
In reality, experienced coders know that there can be a lot of reasons for code that doesn't make sense: maybe you simply don't understand it ('clever' use of templates comes to mind here); maybe it made sense alongside other code that existed at the time, but that code is now gone; maybe there were various time constraints and the code was written as well as possible within them; maybe there were known bad hacks for some deadline that never got removed later on; maybe it was prototype code that was never intended to make it into production (surely that never happens!); or maybe the coder was, in fact, inexperienced at the time, and lacked proper mentoring and review.
There are so many reasons why less than optimal code can exist in a codebase, so jumping to the conclusion that you're smarter than the person who wrote it, and they're a dumb-ass, really says so much more about you than about the other person.
I call this the good faith problem. When you are in a situation where you can choose between initially assuming that you've misunderstood something, or assuming something negative about the other party, which do you go for? Do you start with a good faith trust of the other person's abilities and intentions, or do you start assuming the worst, and then force them to prove otherwise?
Now, while I thought up this model in the context of software development, I've noticed recently just how much this actually seems to reflect the behavior of people in all kinds of discussions. On news programs, in online discussions, everywhere that people with differing views face each other, discussion seems to be getting more and more polarized, with each party assuming the worst possible intentions and motives of the other.
When two parties are discussing some disagreement about climate change, there's the immediate assumption that one is an apologist for fossil fuels or a science denier, while the other is anti-business. When there is a discussion about anti-vaccination, there's the assumption that one side is an anti-science moron, and that the other side is fooled by big pharma. When there is a discussion about left versus right politics, one side is a lazy socialist freeloader, while the other side is a big business tax avoider that hates the poor. And so on.
Rather than assuming that the other party may have good information that we don't, or assuming that maybe they've missed the good information we've seen, the temptation is there to just jump to the worst, that they're stupid, ignorant, or even willfully malicious with a hidden agenda.
One reason that I think this is becoming so common is that it's an effective debating tactic. If you can level accusations at the other party, then it puts them on the defensive as they are forced to disprove them. Further, if you can convince yourself that the other party has bad intentions, then you no longer feel the need to address any valid criticisms that they have. If you can assassinate their character, then you no longer need to deal with the substance of their arguments.
Productive discussion requires that we have some degree of good faith in the intentions and intelligence of the people we are discussing with. When we detect something that doesn't make sense, we shouldn't immediately assume that it's the other person's fault. We should consider whether or not we've misunderstood and then try to fix that misunderstanding.
Giving others the benefit of the doubt rather than assuming the worst is usually going to make for a more productive discussion than starting with the equivalent of "You're an evil dumbass. Prove me wrong!"
In part 2 of this topic, I'm going to look at when the other party actually is bad intentioned, with what I call the bad actor problem.