Geared up for success in 2024

Gift Masekere — Thu, 11 Jan 2024 08:25:32 +0000

As software developers, or in any other profession, we often have a strong desire to accomplish numerous goals. However, in our pursuit of these targets, we often fall short of our potential because we fail to take the time to reflect on our successes and failures. As we find ourselves in the year 2024, it is crucial that we address the mistakes we made in 2023, as they could greatly hinder our future success. In this article, I will explore several strategies that can enhance our performance as software developers in 2024.

Planning

One of the major mistakes developers often make is failing to adequately prepare for their desired achievements within a year, month, or week. Effective planning, coupled with diligent execution, is a key driver of success. Engaging in thoughtful planning tends to enhance our understanding of what strategies yield positive outcomes and what approaches fall short over time. Planning is a skill that can be honed and refined, serving as a fundamental pillar of success.

Premature Optimization

When developing software, it is important to first construct the foundation of the entire system. Once the essential features have been built, you can then proceed to enhance and add new functionalities over time. It is common for developers to become engrossed in perfecting a single feature, neglecting other crucial aspects. While it is essential to optimize your code, it is advisable to avoid doing so in the initial stages of a new project. By following this approach, you can ensure a more efficient, professional, and comprehensive software development process.

Code Reuse

Reusable code has a significant impact in numerous ways. Not only does it save us time during software development, but it also guarantees the creation of well-maintained code that is easily debuggable. Unfortunately, many developers tend to overlook the importance of writing tests, particularly unit tests, due to the additional time required to write them. However, neglecting this crucial step can result in wasting valuable time when new bugs emerge or when updates are necessary.

Accountability

Being accountable will foster trust and reliability and cultivate a positive and productive environment. This can be reaped by taking responsibility for our actions, openly acknowledging mistakes, and actively rectifying them. Sometimes we might be given work and we mess up, but the focus should not be merely about admitting fault; it should be about actively seeking solutions and making amends. When individuals hold themselves accountable, they inspire others to do the same, creating a positive and high-performing work environment.

Learning Agility

Learning agility is the remarkable capacity to discern the appropriate course of action when faced with uncertainty or unfamiliarity. It encompasses the ability to navigate through uncharted territories and make informed decisions in the absence of clear guidance or prior experience. This invaluable skill enables individuals to adapt swiftly and effectively to new challenges, allowing them to thrive in dynamic and ever-evolving environments.

Networking

Networking is an incredibly powerful way to attain remarkable success. It possesses the ability to accelerate the learning process and open doors to superior opportunities. Enhancing our communication skills can have a substantial positive influence on our journey towards success.

Conclusion

Take a seed as an example; removing hindrances such as weeds and giving the plant appropriate food is healthy for the plant. The same applies in our professional lives. Understanding what is working and what is not can be a real game changer. Thank you for reading my post.

Javascript features that makes coding sweet

Gift Masekere — Wed, 13 Dec 2023 16:26:59 +0000

Javascript is packed with various methods and properties
that make programming sweet. Learning about these improves
our code quality, thus leading to cleaner code, which is
easier to maintain. In this article, I am going to cover some
of such features.

Optional Chaining

Suppose we want to fetch user data from an api

const user = await fetch('https://api.example.com/user/123');
// the api responds with null 

// This leads to a TypeError
console.log(user.name);

// to safeguard this
// We can use the logical conjunction operator (&&)
user && console.log(user.name);

// check if user is not null
if (user && user.name) {
    // code
}

// Using optional chaining reduces our code
if (user?.name) {
    // code
}

Nullish coalescing

The logical OR operator considers "", 0, null, and undefined to be false values. However, sometimes we need only null or undefined values to be our false values. That's where nullish coalescence can be applied

const age = 0

// outputs 0
console.log(age ?? 'Age is undefined');

// outputs 'Age is undefined' 
console.log(age || 'Age is undefined');

Destructuring

const user = {
    name: 'Gift',
    age: 21
}

const { name = 'Default', surname = 'Masker' } = user

console.log(name, surname); // => Gift Masker

const users = ['Kiroko', 'Sophiana', 'Ted', 'Perul']
const [firstname, ...other] = users

console.log(firstname); // => Kiroko

const [, , thirdname] = users
console.log(thirdname); // => Ted

Spread Syntax

/* 
     █████╗ ██████╗ ██████╗  █████╗ ██╗   ██╗███████╗
   ██╔══██╗██╔══██╗██╔══██╗██╔══██╗╚██╗ ██╔╝██╔════╝
  ███████║██████╔╝██████╔╝███████║ ╚████╔╝ ███████╗
 ██╔══██║██╔══██╗██╔══██╗██╔══██║  ╚██╔╝  ╚════██║
██║  ██║██║  ██║██║  ██║██║  ██║   ██║   ███████║
╚═╝  ╚═╝╚═╝  ╚═╝╚═╝  ╚═╝╚═╝  ╚═╝   ╚═╝   ╚══════╝
*/

const num = [1, 2, 3, 4, 5]

// spread numbers as args
Math.max(...num) // => 5

// store all paremeters in argz
const details = (...argz) => {
    console.log(argz[0]);
}

let arr1 = [1, 2, 3]
let arr2 = [5, 345, 24]

// spread arr1 into arr2
arr2 = [...arr2, ...arr1] // => [ 5, 345, 24, 1, 2, 3 ]
// or use push with spread 
arr2.push(...arr1) // => [ 5, 345, 24, 1, 2, 3 ]


console.log(arr2);

/* 
 ██████╗ ██████╗      ██╗███████╗ ██████╗████████╗███████╗
██╔═══██╗██╔══██╗     ██║██╔════╝██╔════╝╚══██╔══╝██╔════╝
██║   ██║██████╔╝     ██║█████╗  ██║        ██║   ███████╗
██║   ██║██╔══██╗██   ██║██╔══╝  ██║        ██║   ╚════██║
╚██████╔╝██████╔╝╚█████╔╝███████╗╚██████╗   ██║   ███████║
 ╚═════╝ ╚═════╝  ╚════╝ ╚══════╝ ╚═════╝   ╚═╝   ╚══════╝
*/

const user = { 
    name: 'Gift',
    address: '15th Lorem Avenue',
    age: 21
}

// clone user
const clone = {...user} // => {name: "Gift", address: "15th Lorem Avenue", age: 21}

// clone & add property
const clone2 = {...user, surname: 'Masker'} // => {name: "Gift", address: "15th Lorem Avenue", age: 21, surname: 'Masker}

// clone and update name & age
const clone3 = {...user, name: 'John', age: 30} // => { name: 'John', address: '15th Lorem Avenue', age: 30 }

// merge two objects
const data1 = {name: 'Gift', age: 21}
const data2 = {address: '5th Lorem Avenue'}
const merged = {...data1, ...data2} 
console.log(merged); // => { name: 'Gift', age: 21, address: '5th Lorem Avenue' }

Conclusion

In this article, I only picked a handful of the many cool features JavaScript has. There are a lot of features and operators Javascript has, such as the ternary operator and many more, that improve code readability.

Forem: Gift Masekere

Geared up for success in 2024

Planning

Premature Optimization

Code Reuse

Accountability

Learning Agility

Networking

Conclusion

Javascript features that makes coding sweet

Optional Chaining

Nullish coalescing

Spread Syntax

Conclusion