DEV Community: Rhodé Zwijnenburg

Three easy tips to become a successful developer, by getting to know your feelings

Rhodé Zwijnenburg — Sun, 11 Oct 2020 14:47:03 +0000

To become successful, having well developed emotional intelligence is key, especially as a developer. Emotional intelligence is proven to be very important in becoming more successful, increasing your physical health and psychological health and for becoming a better leader^[1]. So that is quite a lot. I’m very curious to see if there are people who after reading the list above think: "Nah, I don’t want to be in good psychological health and I quite like being stressed out all the time". So if you’re an actual human that wants to feel good and succeed in life, keep on reading. The good news is that emotional intelligence, unlike IQ, can be learned ! So what is emotional intelligence (also called EI or EQ) exactly?

Emotional intelligence is

Being able to identify your own emotions and those of others
Being able to use emotional information to guide thinking and behavior
Manage and/or adjust emotions from yourself and others to adapt to environments or achieve goals^[2].

For these three topics, there are some easy and practical tips to achieve those things by increasing your emotional intelligence. In this blog I will provide you with tips to get to know your own feelings. Recognizing your own feelings is an important step to develop your Emotional Intelligence and becoming more successful. In upcoming posts, we will look at the other aspects too. But be warned before you read further, it’s about emotions…!

Get to know your own feelings

Observe the emotions you experience during one meeting at work. You’ll be surprised how many emotions you may experience, even during one short meeting. For instance: When playing planning poker you feel a little ashamed when the whole team has given a task 5 points, but you thought it was 20. Or being annoyed and a little angry when someone is talking through your fantastic plea. Or feeling frustrated and bored, because the discussion went on a tangent and is taking sooooo long etc.
Get to know all the feelings. Most of the time we only use basic emotions which does not always do justice to what you feel in reality. You’re saying a lot more if you are able to say that you feel bad about a plan because you are disappointed in the quality of it, rather than if you would only say you feel bad about it. Feeling bad about something could also mean that you are sceptical, offended, nervous or disinterested about the idea, which has very different implications for the handling of the original idea. This website gives an example of a lot more feelings. Try to expand your vocabulary on emotions, so that you are able to express yourself better and to become better in detecting the feelings of others.
Be honest to yourself: see where you excel, but also where your weaknesses are. Try to feel and accept feelings you are less proud of, like jealousy or insecurity. Most of the time we try very hard not to feel these emotions, because we think they are bad. But the emotions themselves are not inherently wrong, it’s about the actions you might undertake because of those emotions which could be bad. Do you know your own biggest fears? And no, I’m not talking about some mild fear or spiders. Most people fear failure, loss, being judged, losing control, losing identity or fear of who they really are. Find your biggest fears, feel them, however uncomfortable, and accept those feelings. This is important, because suppressed feelings result in undesirable behavior. For example, when you fear failure and retrieve critical feedback from your reviewer, you’ll question his knowledge. You’ll ignore his feedback, instead of trying to learn from the feedback and adjust the code in a better way.

Summary
It’s possible to develop your emotional intelligence, by getting to know your own emotions.
Three practical tips to achieve this are

Observing your own emotions
Getting to know all the feelings
Being honest to yourself. Doing this can help you become a more complete and successful human and developer

Tips to get to know feelings of others and learning the impact that you have on others will be given in my next blog posts.

[1] Black, P. H., & Garbutt, L. D. (2002). Stress, inflammation and cardiovascular disease. The Journal of Psychosomatic Research, 52, 1–23.
[2] Colman, Andrew (2008). A Dictionary of Psychology (3 ed.). Oxford University Press. Goleman, D. (1995). Emotional intelligence. New York, NY: Bantam Books, Inc. Retrieved from https://positivepsychology.com/importance-of-emotional-intelligence/

Reduce for beginners

Rhodé Zwijnenburg — Tue, 05 Nov 2019 13:49:06 +0000

What is reduce and why should I use it?

Reduce iterates over each value of an array, and reduces it to a single value, which could be anything.
There are lots of use cases where reduce comes in handy, for example when you need to:

calculate the sum of your array
calculate the average of your array
calculate the biggest number of your array
calculate the longest word of your array
count how many times each item is present in the array.

The basics

You might be familiar with the reduce syntax from MDN:

arr.reduce(callback(accumulator, currentValue[, index[, array]])[, initialValue])

A tear came out of your eye and you even might consider switching careers. Don't worry; you are not the only one who didn't understand the syntax immediately. The good news: it's way easier than it looks. With the reduce function you can get the same thing done as with the good old for-loop, only is the reduce function based on functional programming, so you are more forced to use these principles like not mutating data and not introducing side effects. But watch out, you're still able to do this if you use reduce the wrong way. :') Take a look at the for-loop and the reduce function in the snippets below, where we add up each value of the array. The myArray[i] variable in the for loop is comparable with the arrayVal of the reduce function. The count variable in the for-loop example underneath is comparable with the accumulator variable in the reduce function. The accumulator accumulates the returned values of the callback functions.

const myArray = [2, 3, 4, 5, 6]
let count = 0;

for (let i = 0; i < myArray.length; i++) {
  count = count + myArray[i] 
}

// => count = 20

const myArray = [2, 3, 4, 5, 6]

let reduced = myArray.reduce((accumulator, arrayVal) => arrayVal + accumulator);

// => accumulator= 2; arrayVal = 3  
// => accumulator= 5; arrayVal = 4  
// => accumulator= 9; arrayVal = 5  
// => accumulator= 14; arrayVal = 6  
// => reduced = 20

Common mistake when using reduce for the first time

The results of both snippets above are the same, but there are some important differences. Take a look at the next snippet:

const myArray = [2, 3, 4]
let reduced= myArray.reduce((accumulator, arrayVal) => accumulator + arrayVal * 3); 

 // => accumulator = 2; arrayVal = 3 
 // => accumulator = 5; arrayVal = 4
 // => reduced = 23

Wait, what happened? The mathematicians noticed immediately: 'This isn't right'. When you take a look at the callback function this is what you expected:
2 * 3 = 6
6 + 3 * 3 = 15
15 + 4 * 3 = 27.

But value of the variable 'reduced' is 23... Why? More tears...! When you take a look at the console.logs of the callback function it's becoming clear that the callback function isn't executed for the first value in the array. The reduce function takes that first arrayValue as the initial value, which gives the following calculation:

2 + 3 * 3 = 11

11 + 4 * 3 = 23

Okay, fine, when I really have to accept that for the first arrayValue the callback function is not executed, I will accept it. But sometimes you want the callback function to be executed for every value in the array.

InitialValue to the rescue

In that case you are able to use the initialValue of the reduce function, as is shown in the snippet below.

const myArray = [2, 3, 4]
let reduced = myArray.reduce((accumulator, arrayVal) => accumulator + arrayVal * 3, 0); 


 // => accumulator = 0; arrayVal=2
 // => accumulator = 6; arrayVal=3  
 // => accumulator = 15; arrayVal=4  
 // => reduced = 27

Do you see what has changed? In the code above there is a zero after the callback function; the initialValue. Now the callback function is invoked three times as you would expect.

0 + 3 * 2 = 6

6 + 3 * 3 = 15

15 + 4 * 3 = 27

So when should you use the initial value? If you want to iterate over each value in the array with a callback function, where the callback function not only includes adding up the arrayValue with the accumulator, then you should use the inital value.

Why and how to use index

There's one more important issue to address. Sometimes you want to execute different calculations for each value in the array.
For example: you want to multiply each of your arrayValues with the index of the arrayValue. In the classic for-loops you were able to do this: myArray[i]. With the reduce function you are able to use the optional index value, which can be used as shown in the snippet:

const myArray = [2, 3, 4]
let reduced = myArray.reduce((accumulator, arrayVal, i) => accumulator + arrayVal * i, 0); 


// => accumulator = 0   arrayVal = 2   i = 0
// => accumulator = 2   arrayVal = 3   i = 1
// => accumulator = 5   arrayVal = 4   i = 2
// => reduced = 13

See, that's it.

Summary

Reduce iterates over each value of an array, and reduces it to a single value.
Reduce is useful for for example calculating the average, finding the biggest number or the longest word in an array.
The accumulator accumulates the returned values of the callback functions.
The callback function is not executed for the first value of the array.
When you want the callback function to execute for every value in the array and you want the reduce function to start with a specific value: use the optional initial value of the reduce method.
Use the index when the array order matters to the logic.

Bonus 1: Figure out why the first example doesn't need an initial value.

Bonus 2: Try it yourself. I already gave some examples in the codepen which you can alter.