How To Write Maintainable and Readable Code
Tags: webdev, javascript, typescript, programming
Published: 2023-05-16 09:24:59

In software development, writing clean, maintainable, and readable code is crucial for the success of any project. Code that is well-organized, easy to understand, and can be easily modified and extended not only improves developer productivity but also reduces the chances of introducing bugs and errors.
In this article, we will discuss some of the best practices and techniques for writing clean, maintainable, and readable code in JavaScript and TypeScript, but it's important to note that these principles can also apply to other programming languages.

### Use meaningful variable and function names
One of the fundamental principles of writing clean code is using meaningful and descriptive variable and function names. Well-chosen names can greatly enhance the readability and understandability of your code. When someone reads your code, they should be able to quickly grasp the purpose and functionality of each variable or function without needing extensive comments or additional documentation.

For example, let's consider the following code snippet that uses poorly named variables and functions:

```js
let a = 10;
let b = 20;

function f(x, y) {
  let c = x + y;
  if (c > a) {
    return c - b;
  } else {
    return c + b;
  }
}

console.log(f(a, b));
```
In this code, it's not clear what the variables _a_ and _b_ represent. Similarly, the function _f_ has a nondescript name and uses cryptic variable names like _x_, _y_, and _c_. This makes it difficult to understand what the function is doing and how it is related to the rest of the code.

To improve the readability of this code, we can start by using more descriptive variable names that indicate their purpose. For example, we can rename _a_ to _threshold_ and _b_ to _offset_ to better communicate their meaning:

```js
let threshold = 10;
let offset = 20;

function f(x, y) {
  let sum = x + y;
  if (sum > threshold) {
    return sum - offset;
  } else {
    return sum + offset;
  }
}

console.log(f(threshold, offset));
```
With these changes, it is now much easier to understand what this code is doing. The variables _threshold_ and _offset_ are named after their specific roles, and the function _f_ has been renamed to _calculateSumWithThreshold_ to better communicate its purpose. Additionally, the variable _c_ has been renamed to _sum_, which more clearly indicates its value.

Using descriptive and meaningful names for variables and functions helps improve the clarity and maintainability of the code. Even in a more complex example, using good naming conventions can make a big difference in how easily the code can be understood and maintained.

### Use proper indentation and formatting
Consistent indentation and formatting play a crucial role in code readability. Properly formatted code enhances comprehension and makes it easier to follow the logical structure of the codebase. It also promotes consistency across the project, especially when multiple developers are working on the same code.

Consider the following code without proper indentation:

```js
function calculateAverage(numbers){
let sum = 0;
for(let i=0;i<numbers.length;i++){
sum += numbers[i];
}
let average = sum/numbers.length;
return average;
}
```
Without indentation, it becomes challenging to visually identify the code's structure and nesting. This can lead to confusion and introduce errors while understanding or modifying the code.

By applying consistent indentation, the code becomes much more readable and structured:

```js
function calculateAverage(numbers) {
  let sum = 0;
  for (let i = 0; i < numbers.length; i++) {
    sum += numbers[i];
  }
  let average = sum / numbers.length;
  return average;
}
```
In the formatted code, each level of indentation represents a higher level of nesting or scope. It clarifies the relationship between different blocks of code, such as loops and conditional statements. The code is now easier to scan and understand at a glance.

In addition to indentation, consistent formatting practices should be applied, such as proper spacing around operators, consistent placement of braces, and alignment of related code elements. Adhering to a style guide or adopting a code formatter tool like [Prettier](https://prettier.io) can help maintain consistent formatting across the codebase.

### Keep functions, methods, and classes short
"When picking a name for something, use the most common shortest name". This principle extends beyond domain names and applies to various elements in software development. It encompasses variables, functions, classes, and more. By choosing shorter and more common names, code readability and understandability can be significantly improved.

For instance, suppose you have a function named _relinquishSomething_. In that case, it might be beneficial to opt for a shorter and more commonly used alternative. You could rename the function to _releaseSomething_, for example. The word "release" is shorter and more familiar than "relinquish." Use Google or ChatGPT to search for word synonyms, e.g., "relinquish synonyms", to find the shortest and most common similar term.

### Comment and Document
Commenting and documenting your code is important for ensuring its clarity, maintainability, and understandability. Well-placed comments and documentation provide valuable insights into the code's purpose, behavior, and any considerations or limitations. They serve as a communication tool for developers, including your future self and team members, helping them navigate and work with the code more effectively.

In the past, I have made the mistake of neglecting proper commenting and documentation. I used to believe that my code would never be read by someone else and that investing time in commenting was a waste. However, I soon realized that this approach was flawed.

Code is rarely developed in isolation. Projects involve collaboration, maintenance, and often, the passing of code from one developer to another. Even if you are the sole developer, you may revisit your code months or years later, and without proper documentation, understanding your own code becomes a daunting task.

Here are some best practices for commenting and documenting your code:

- _**Use inline comments**_: Include comments within your code to explain complex or non-obvious sections. Inline comments should provide additional context and clarification without stating the obvious.

```js
// Calculate the sum of the array
let sum = 0;
for (let i = 0; i < array.length; i++) {
  sum += array[i];
}
```

- _**Write descriptive function and method headers**_: Begin each function or method with a descriptive comment that summarizes its purpose, input parameters, return values, and any side effects. This helps readers quickly understand the function's behavior without diving into the implementation details.

```js
/**
 * Calculate the average of an array of numbers.
 * @param {number[]} numbers - The input array of numbers.
 * @returns {number} The average of the numbers.
 */
function calculateAverage(numbers) {
  // Implementation
}
```

- _**Document external APIs**_: When working with external APIs or libraries, document how to use them effectively. Provide examples, explain input parameters and their expected values, and detail the structure of the response or expected output.

- _**Update comments regularly**_: Keep your comments up-to-date with the code changes. Outdated or misleading comments can be worse than having no comments at all, as they can misguide developers and introduce confusion.

- _**Write README files**_: Include a README file in your project's root directory to provide an overview of the project, installation instructions, usage examples, and any relevant information for contributors or users.

### Avoid code duplication (DRY Principle)
Code duplication, also known as "Don't Repeat Yourself" (DRY) principle, refers to the practice of having redundant or repetitive code in your codebase. Duplicated code can lead to several issues, including increased maintenance overhead, decreased readability, and the risk of introducing bugs.

You can avoid code duplication and adhere to the DRY principle by considering the following techniques:

- _**Extract reusable code**_: Identify common functionalities and create separate functions, methods, or classes

- _**Use inheritance and composition**_: Leverage inheritance and composition in object-oriented programming for code reuse

- _**Use libraries and frameworks**_: Use existing tools instead of reinventing functionalities to reduce duplication.

- _**Refactor duplicated code**_: Regularly review code and extract common logic into reusable components.

### Avoid magic numbers and strings
Magic numbers and strings are hard-coded values that are used throughout your codebase, often without any clear explanation or documentation. These values can be difficult to understand and maintain, leading to bugs and errors. Always declare constants for any magic numbers or strings and use them throughout your codebase. This makes it easier to modify these values in the future and provides context for their usage.

### Avoid deep nesting
Deep nesting refers to excessive levels of indentation and nesting within your code. It occurs when there are multiple levels of conditional statements, loops, or nested functions within each other. While nesting is sometimes necessary, excessive levels of nesting can make your code harder to read, understand, and maintain. It also increases the chances of introducing bugs and decreases code performance.

You can avoid deep nesting in your code by following these tips. First, simplify your logic by breaking down complex operations into smaller, more manageable functions or methods. This helps improve code organization and readability. Second, regularly review your code and look for opportunities to refactor or extract nested blocks into separate functions or methods, reducing the levels of nesting. Lastly, consider using early returns to handle exceptional cases or exit conditions early in your code, which can help flatten the code structure and make it more readable.

### Continuous refactoring
Continuous refactoring is another important aspect of writing clean code. It involves making changes to the existing codebase to improve its design, structure, and readability without changing its functionality. It helps in eliminating code smells and reduces technical debt. 

Refactoring is an ongoing process that should be integrated into your development workflow. It should not be considered a separate task to be performed after the code has been written. It should be done regularly, in small incremental steps, to ensure that the code is always in a good state. 

### Remove unused code
How many times have you forgotten to remove unused code from your projects? For me, it's happened more often than I'd like to admit. However, it's crucial to regularly review your code and eliminate any unused functions, classes, or variables that you no longer need. By doing so, you can greatly enhance your code's readability and reduce complexity. Additionally, removing unused code improves the performance of your application by eliminating unnecessary processing. Make it a habit to identify and remove unused code, either through manual code reviews or with the help of tools like Eslint.

### Summary
Writing maintainable and readable code is a fundamental skill for any developer. By adhering to best practices and techniques like following a consistent coding style, properly commenting on your code, and avoiding code duplication, you can greatly improve the quality of your codebase.

Remember to also prioritize simplicity and readability over complex, convoluted code that may be difficult to understand and maintain. Take advantage of automated tools to help identify and remove unused code and reduce the complexity of your codebase.

Connect with me on [various platforms](https://bio.link/thomassentre)