Codes & Waffles

Day 68: on bias

Published 20 Apr 2018

Humans are flawed. But in some cases, those flaws are really features our brain gets shipped with. And in some cases, a lack of thereof would actually make our lives much easier. One of such features are the cognitive biases we build as we live.

According to Wikipedia:

A cognitive bias is a systematic pattern of deviation from norm or rationality in judgment. Individuals create their own “subjective social reality” from their perception of the input.

The way I understand it is more like this:

It’s a subjective evaluation of reality, based on our context and past experiences, which can make us unable to remain objective in any given situation.

They’re features, because at some point in time, it was important that our mind reacted very fast to things around us. And it created a map of situations and reactions in our mind that was then accessed when facing stimuli.

The Unknown

One of the strongest biases we have is that of Familiarity. In short, it means that we tend to prefer the things we already know. Situations that look or feel familiar to us will also be more comfortable. And our brain uses this as an escape hatch when under a lot of stress, because its main task is to keep all our systems working. It’s no wonder then that when we’re writing Software, a task with high cognitive load, Familiarity Bias is really prevalent.

When we look at code that looks different to what we’re used to see, our first and most natural reflex is to reject it. We have to fight that reflex in order to accept that new idea. That’s why trying to learn new languages with vastly different syntaxes is really hard and tiring at the beginning. And even inside of a programming language we feel comfortable in, it can be a daunting task to learn a new syntax structure.

I remember the first time I saw an arrow function my brain almost exploded. It looked ugly, and nigh impossible to understand. And it was only through a lot of practice that I understood that this:

const add = x => y => x + y; 

Is actually the same as this:

const add = function(x) {
	return function(y) {
		return x + y;

And even a bit longer to understand why the first one is preferable to the second one in almost every way. If I hadn’t fought my familiarity bias, or if it had been stronger, I would’ve had an even harder time seeing the benefits of arrow syntax.

Danger Reflex

We escape to the familiar because it’s safe, or at least safer than the unknown. In the old days, running to places we knew were safe was a reflex that could save our lives. The unknown was equal to danger in most occasions and reacting quickly in the presence of unknown stimuli was crucial to survival. So, evolution made it so that only those who reacted very, very fast survived. And that created a trigger in our brain to react in a certain way to certain things. That reflex has stayed with us until today in the form of the Backfire Effect.

In the face of contradictory evidence, established beliefs do not change but actually get stronger.

If my belief that function(){} syntax was the best thing since sliced bread had been more rooted in myself, I wouldn’t have ever budged to rational arguments and facts about arrows. Im sure we can all see how dangerous such attitudes are in an industry so fast paced as Software Development.

In the face of all these features our brain ships with, we need to make an effort to counteract them. Be very mindful about what you transform into an established belief, because that might turn you into the problematic dev that is unable to see why the different approach is better. And on a higher level, these biases are also the root of our prejudices. Identifying them and understanding where they come from is the only way we can get rid of them. Our brain wants to build them and use them, but it’s our decision wether we’re ruled by them or not, and our responsibility as free-willed human beings to destroy them whenever possible.

Personal Blog of Daniel Bolívar
Writer of Codes for the Webs