DEV Community: Diego Villa

Tech leadership: productivity happiness

Diego Villa — Sun, 25 Oct 2020 00:22:16 +0000

When we are talking about the role of Teach Leader, we think it is a position that serves as a technical reference for a software development team. That's true, but it is the most straight learning skill for the role. As a Teach Leader, you must have three tasks in mind: Advocate, Facilitate, Motivate.

Being a Tech Leader is being a team and culture builder over a technical reference.

In this post, we will discuss productivity happiness and how engaged teams drive better outcomes.

Team culture

The outcomes of every team are highly connected to the team culture. The team culture is a set of behaviors. Behaviors are what you do, and culture is the sum of the group's behaviors.

The behavior of a team is the reflection of the behavior of the leader.

That does not mean that the leader imposes rules about how to act inside the team. What really means is that a leader's mission is to align the team behavior with the principles to deliver high-quality outcomes.

Every person contributes to a set of behaviors that could be positive for the team culture. Leaders must recognize the set of good behavior patterns that the team is building and remove those that could produce a faulty relationship.

Building a team culture

As a leader, having a team culture where each member feels comfortable is the most difficult task because we lead with persons. Each member has different emotions that conduct them to act differently, based on the levels of trust they have within the group.

Building a team culture is an interactive process; there is no guide about developing that connection between humans. Each team is different and has different missions. Before creating a team culture, you need to identify each team member's motivation and then ask yourself what culture you want for this group of people you are leading.

At the end of the day, our goal is to build a healthy team culture. If a team has a healthy social relationship, a purpose, and promotes trust and communication, the team members will be engaged.

"Your work is going to fill a large part of your life, and the only way to be truly satisfied is to do what you believe is great work. And the only way to do great work is to love what you do". Steve Jobs

Engagement

We can define that engagement is the result of having teams with a strong sense of purpose. We can say that purpose is the feeling of being part of the same mission, and it is what motivates us to make our best effort to grow as a team and as professionals.

When team members are engaged, we will have high enthusiasm, energy, and motivation, translating into higher performance, creativity, and productivity.

Team culture + engagement = productivity happiness

Productivity happiness

Our productivity and happiness levels result from the team culture and engagement that every team member perceives inside the group.

Leaders often will perceive low productivity and happiness due to a lack of motivation, but that's not really true. I like to say that motivation is the result of engagement. Motivation drives a single person to achieve results, and engagement drives us as team members to achieve better outcomes.

We must focus on promoting high engagement levels because it is the glue that keeps a team strong and with high levels of innovation. Also, it produces side effects like friendship loyalty, that means:

We are motivated to work because we don't want to let down our friends.

Productivity happiness in the software industry

In the software industry, we can say that we have achieved a good productivity level when the members start thinking about delivering better user experiences. As a result, we start to see some behaviors aligning the end goals with better code quality.

If you want to learn more about workplace happiness, I recommend the course Boost Productivity Through Employee Happiness by Kylie Hunt (Workplace Happiness Advocate).

Photo by You X Ventures on Unsplash

OOP: From Pseudo-classical class instantiation to Class instantiation

Diego Villa — Sat, 24 Oct 2020 20:52:02 +0000

In this post, we will discuss how we can create objects in JavaScript. We will explore the traditional approach using Pseudo-classical class instantiation and will end with Class instantiation introduced in ECMAScript 6.

Introduction to objects

Objects are key/value pairs to store information about an entity that we can to represent in our code. You can create an object using the curly braces {}, and you can add properties and methods using the dot notation.

let employee = {};

// Properties
employee.name = 'Diego';
employee.position = 'Software Engineer';

// Methods
employee.program = function () {
  console.log(`${this.name} is programming!`);
};

employee.program(); // Result: Diego is programming!

Functional instantiation

To create multiple objects we can use a constructor function. A constructor function encapsulates an object creation and it allows you to create multiple instances of the same object structure.

Creating a constructor function to instantiate new objects follows the functional instantiation pattern.

function Employee(name, position) {
  let employee = {};
  employee.name = name;
  employee.position = position;

  employee.program = function() {
    console.log(`${this.name} is programming!`);
  };

  return employee;
}

const employeeDiego = Employee('Diego', 'Software Engineer');
const employeeJuan = Employee('Juan', 'Sofware Architect');

Functional instantiation with shared methods

Every time that we are creating a new instance of the Employee object we are creating, in memory, something like this:

const employeeDiego = {
  name: 'Diego',
  position: 'Software Engineer',
  program: [Function],
};

const employeeJuan = {
  name: 'Juan',
  position: 'Software Architect',
  program: [Function],
};

We can observe that we are creating two objects that share the same functionality (program). If we are creating two objects we probably didn't see the memory impact, but if we are creating thousands of objects we are wasting memory to store every time the same functionality. To avoid this problem we can use functional instantiation with shared methods.

const employeeMethods = {
  program: function() {
    console.log(`${this.name} is programming!`);
  }
};

function Employee(name, position) {
  let employee = {};
  employee.name = name;
  employee.position = position;
  employee.program = employeeMethods.program;

  return employee;
}

const employeeDiego = Employee('Diego', 'Software Engineer');
const employeeJuan = Employee('Juan', 'Sofware Architect');

With this improvement we will creating, in memory, something like this:

const employeeDiego = {
  name: 'Diego',
  position: 'Software Engineer',
  program: [Function: program],
};

const employeeJuan = {
  name: 'Juan',
  position: 'Software Architect',
  program: [Function: program],
};

In JS objects are passed as reference, so we only have created a single object that encapsulates the program function, and every instance of the Employee object access the same function in memory.

Object.create

We can improve our constructor function using Object.create.

const employeeMethods = {
  program: function() {
    console.log(`${this.name} is progamming`);
  }
};

function Employee(name, position) {
  let employee = Object.create(employeeMethods);
  employee.name = name;
  employee.position = position;

  return employee;
}

const employeeDiego = Employee('Diego', 'Software Engineer');
const employeeJuan = Employee('Juan', 'Sofware Architect');

With this improvement, every time we create a new instance of the Employee object we will have, in memory, something like this:

const employeeDiego = {
  name: 'Diego',
  position: 'Software Engineer',
};

const employeeJuan = {
  name: 'Juan',
  position: 'Software Architect',
};

If the created objects don't have the program method, how will it be possible to invoke it? Every time we invoke employee.program() will fail because the created object doesn't have that method. But we use Object.create(employeeMethods), so every time we invoke the program method it will look it in the parent object (employeeMethods).

Prototypal instantiation

In JavaScript, every function has a prototype property that references an object. This property allows us to share methods across all instances of a function.

function Employee(name, position) {
  let employee = Object.create(employeeMethods);
  employee.name = name;
  employee.position = position;

  return employee;
}

console.log(Employee.prototype); // Employee {}

So, we can use the prototype property to share the program function across all instances instead of using a separate object.

function Employee(name, position) {
  let employee = Object.create(Employee.prototype);
  employee.name = name;
  employee.position = position;
}

Employee.prototype.program = function () {
  console.log(`${this.name} is programming`);
};

const employeeDiego = Employee('Diego', 'Software Engineer');

With this improvement, every time we create a new instance of the Employee object we will have, in memory, something like this:

const employeeDiego = {
  name:  'Diego',
  position: 'Software Engineer',
};

And the Employee.prototype will look like:

{
  program: [Function]
}

Pseudo-classical class instantiation

Currently, we are using the Object.create() function to create a new object based on the prototype of a parent object, and then we return that created object. With the new keyword, we can merge the Object.create() and return functionality. The created object is called this.

function Employee(name, position) {
  this.name = name;
  this.position = position;
}

Employee.prototype.program = function () {
  console.log(`${this.name} is programming`);
};

const employeeDiego = new Employee('Diego', 'Software Engineer');

This pattern is called pseudo-classical class instantiation. When we use the new keyword we are invoking the function constructor. If we don't add the new keyword, the function won't create the object and it will return undefined.

Class instantiation

With ECMAScript 6 a class keyword was added. The class keyword was introduced to create classes in popular OOP programming languages like Java, but it works as the pseudoclassical class instantiation.

class Employee {
  constructor(name, position) {
    this.name = name;
    this.position = position;
  }

  program() {
    console.log(`${this.name} is programming!`);
  }
}

const employeeDiego = new Employee('Diego', 'Software Engineer');

Photo by Lucas Benjamin on Unsplash