# Code Smell 264 - Hanlon's Razor

> TL;DR: Overdefensive code leads to unnecessary complexity.

# Problems

- Unnecessary complexity

- Confusing logic

- Hidden bugs

- Harder maintenance

- Slower performance

- Cluttered Code

# Solutions

1. Simplify checks

2. Trust your logic

3. Focus on essentials

4. Follow the K.I.S.S. principle

5. Refactor regularly

# Context

Overthinking and overdesigning your code can lead to unnecessary complexity. 

You might need to defend against *every* possible scenario, but this approach often produces bloated, confusing code. 

[Hanlon's Razor](https://en.wikipedia.org/wiki/Hanlon%27s_razor) suggests that you should not assume malice when simple mistakes or misunderstandings are more likely.

Avoid overly defensive programming and focus on clear, straightforward logic. 

You might anticipate future problems that might never happen or try to make your code too flexible.

Simple code is easier to maintain, debug, and understand.

# Sample Code

## Wrong

[Gist Url]: # (https://gist.github.com/mcsee/5e59715c1c7bcfc4f1b8a4b89a2731fc)

```javascript
function processData(data) {
    if (typeof data === 'undefined') {
        throw new Error('Data is undefined');
    }

    if (typeof data !== 'object') {
        throw new Error('Data is not an object');
    }

    if (data === null) {
        throw new Error('Data is null');
    }

    if (Array.isArray(data)) {
        throw new Error('Data should not be an array');
    }

    if (!data.hasOwnProperty('items')) {
        return [];
    }

    if (!Array.isArray(data.items)) {
        throw new Error('Items should be an array');
    }

    if (data.items.length === 0) {
        return []; 
    }

    let processedItems = [];
    for (let item of data.items) {
        if (typeof item === 'undefined') {
            continue; // Skip undefined items
        }

        if (typeof item !== 'object') {
            continue; // Skip non-object items
        }

        if (item === null) {
            continue; // Skip null items
        }

        processedItems.push(processItem(item));
    }

    return processedItems;
}
```

## Right

[Gist Url]: # (https://gist.github.com/mcsee/b5c20329bc5670687423d274d0b6f3e8)

```javascript
function processData(data) {
    if (!Array.isArray(data.items)) {
        throw new Error('Invalid data');
    }

    return data.items
        .filter(item => typeof item === 'object' && item !== null)
        .map(item => processItem(item));
}
```

# Detection

[X] Manual

Complicated code usually has more lines and [long methods](https://maximilianocontieri.com/code-smell-03-functions-are-too-long) are a possible hint.

# Tags

- Bloaters

# Level

[x] Intermediate

# AI Generation

AI generators can introduce this smell when they try to account for every possible edge case. 

For example, dealing with [NULLs](https://maximilianocontieri.com/null-the-billion-dollar-mistake) is unnecessary if you completely [avoid them](https://maximilianocontieri.com/refactoring-015-remove-null).

# AI Detection

AI tools can help detect overly defensive code by analyzing the logic and suggesting simplifications with proper guidance. 

These tools often recommend removing unnecessary checks or combining them for clarity.

# Conclusion

Avoid overthinking and overdesigning your code. 

Focus on the most likely scenarios and write clear, straightforward logic. 

Simplicity leads to better code quality and easier maintenance.

# Relations

%[https://maximilianocontieri.com/code-smell-03-functions-are-too-long]

%[https://maximilianocontieri.com/code-smell-12-null]

# More Info

%[https://en.wikipedia.org/wiki/Hanlon%27s_razor]

# Disclaimer

Code Smells are my [opinion](https://maximilianocontieri.com/i-wrote-more-than-90-articles-on-2021-here-is-what-i-learned).

# Credits

Photo by [Nacho Fernández](https://unsplash.com/@inteligencia_eco) on [Unsplash](https://unsplash.com/photos/gray-metal-razor-quxbQxvGiPA)
  
* * *

> Simplicity is the ultimate sophistication.

 _Leonardo da Vinci_
 
%[https://maximilianocontieri.com/software-engineering-great-quotes]

* * *

This article is part of the CodeSmell Series.

%[https://maximilianocontieri.com/how-to-find-the-stinky-parts-of-your-code]