---
title: A Short List of Good Practices in Programming
description: A concise list of programming best practices for writing maintainable, robust software.
pubDate: 2017-07-10T00:00:00.000Z
tags: architecture, career
---

Writing software is more than simply creating an application that
fulfills its requirements; it has to be created to be maintainable,
robust, verifiable, and readable, among many other things. Because
of this, we as developers need to constantly strive to learn and
find new ways that can help create better code, and ultimately, a
better software application.

The goal of this blog post is to list a few good programming practices
than can improve your code. This list is not by any means exhaustive
(there are entire books written about this very topic). That being
said, I have focused on listing good programming practices that
have had the greatest impact on the quality of the code I write.

## Test Driven Development (TDD)

Writing tests first offers many advantages such as verifiability,
regression prevention, and documentation, among others. But one of
my favorites is that it introduces a “user” of the code that will
be written.

A test itself can be thought as a user of some code that will
eventually be written, and as a result of it, writing code using
the tests first approach enforces good design of code. This means
that code written using TDD is usually better designed as writing
the tests first forces the developer to write code that is easy to
test, which is usually well designed code.

It is worth pointing out that TDD should be used together with
Behavior Driven Development (BDD). TDD usually relies too much on
the specific implementation a developer decided to use, while BDD
instead tests the behavior of the code. This is specially useful
while refactoring, as you can still be able to tell if the new code
correctly implements the required behavior of the old code, without
having to update any behavior tests at all.

## Use Pure Functions

A pure function is defined as a method which, given the same input,
will always return the same output and depend on no external mutable
state. Pure functions offer a variety of benefits such as no side
effects, ease of testing, ease of debugging, etc.

To illustrate pure functions, let us consider the following example:

``` javascript
const numbers = [5, 3, 1]
const sortedNumbers = numbers.sort()
console.log(numbers) // [1, 3, 5]
console.log(sortedNumbers) // [1, 3, 5]
console.log(numbers === sortedNumbers) // true
```

The `Array` sort method is an impure function as it mutates the
original array on which it is executed. This could lead to hard-to-find
bugs, as the application would not necessarily always want to have
the array of `numbers` in that particular order. A pure implementation
in ES6 would instead look like this:

``` javascript
function sortArray(arr, compareFunction = null) {
  return [...arr].sort(compareFunction)
}
const numbers = [5, 3, 1]
const sortedNumbers = sortArray(numbers, (a, b) => a - b)
console.log(numbers) // [5, 3, 1]
console.log(sortedNumbers) // [1, 3, 5]
console.log(numbers === sortedNumbers) // false
```

The example above does not mutate the `numbers` array anymore. In
addition to that, it allows passing of an optional sort method to
specify how to sort the array, which makes the `sortArray` method
more reusable.

A related point to consider is favoring the use of functional
programming. Functional programming is a declarative software
programming paradigm and it avoids changing state and mutable data.
There are many concepts to functional programming other than pure
functions, but the use of it will enforce code that uses pure
functions.

## Single Source of Truth (SSOT)

The concept of a single source of truth refers to the idea of storing
application data in only one place. Any other link to a specific
piece of information is simply done by reference, and thus this
approach can help to both avoid data synchronization issues and
create a clearer separation of data and its representation.

SSOT can also be applied to other endeavors outside of software
development, such as to an organization or product development.

`boolean` variables should be named positively and contain `is`
which implies `true/false`

Naming `boolean` variables positively helps to avoid double negatives
which are more complicated to understand. Consider the following
example in English:

```
There is no one in this crowd you can't see.
```

This sentence actually means you can see everyone in this crowd,
but it is difficult to understand because it is written negatively.
Let us now consider another example, but this time written in
JavaScript:

``` javascript
const inactive = false
if (!inactive) {
  console.log('is active')
}
```

This piece of code can be easily improved by applying the concepts
from above. First, let us add the word `is` to the name of the
variable, in order to imply `true/false`, and finally let us rename
it to `active`, so that it is written positively:

``` javascript
const isActive = true
if (isActive) {
  console.log('is active')
}
```

This modified version is far easier to understand and read than the
one written negatively. Always favor naming boolean variables
positively and include `is` to imply `true/false`. With relatively
low effort, this good practice will tremendously improve the
readability of your code.

## Favor the Verb-noun Approach for Naming Methods

Naming things is one of those problems that have haunted software
developers for quite a long time. That being said, there are a few
tricks developers can use to alleviate this issue, and one that has
worked good for me is the verb-noun approach for naming methods.

When naming a method, start by describing the action it will perform
with a verb, such as `get`, `set`, `transform`, or `render`. After
the action the method will perform has been specified, include a
description of the value the method will return or update such as
`getInvestmentTotal(...args)`, `renderHeader(...args)`, or
`saveUserAvatar(...args)`.

Using the verb-noun approach will help other developers to more
clearly understand the code you have written and save them time by
letting them understand what the method does without having to read
its implementation.

## Conclusion

In this blog post, I have listed a few good programming practices
that have helped me improve the quality of the code I write. As
mentioned in the introduction, there are entire books written about
this topic, and thus I have limited myself to only list those good
practices that have had the greatest impact for me as a developer.