Eliminating The Billion-Dollar Mistake forever TL;DR: Use the Null Object Pattern to eliminate null checks and simplify your code. Problems Addressed Frequent null checks and IFs cluttering your code
Null pointer exceptions
Hard-to-read and maintain code
Lack of extensibility
Unnecessary complexity with excessive null checks.
More detail about NULL creation and regrets Related Code Smells Code Smell 12 - Null Code Smell 260 - Crowdstrike NULL Code Smell 149 - Optional Chaining Code Smell 212 - Elvis Operator Code Smell 192 - Optional Attributes Code Smell 126 - Fake Null Object Code Smell 208 - Null Island Steps These steps are a special case of Remove IF Refactoring Create a Null Object class that implements the same interface
Replace null checks with the polymorphic Null Object Sample Code Before public class SoccerMatch {
    private Team homeTeam;
    private Team awayTeam;
    private TimeRecord regularTime;
    private TimeRecord extraTime;

    public SoccerMatch(Team homeTeam, 
                       Team awayTeam,
                       TimeRecord regularTime, 
                       TimeRecord extraTime) {
        this.homeTeam = homeTeam;
        this.awayTeam = awayTeam;
        this.regularTime = regularTime;
        this.extraTime = extraTime;
    }

    public int totalGoals() {
        int goals = regularTime.goals();
        // You might forget this if check 
        // resulting in a null error
        if (extraTime != null) {
            goals += extraTime.goals();
        }
        return goals;
    }
}

class TimeRecord {
    private int goals;

    public TimeRecord(int goals) {
        this.goals = goals;
    }

    public int goals() {
        return goals;
    }
} After // 1. Create a Null Object class that implements the same interface

interface TimeRecord {
    // The common protocol between the real object 
    // and the Null Object
    int goals();
}

class PlayedTimeRecord implements TimeRecord {
    // This class is suitable both to be
    // a Regular Time or an Extra Time
    private int goals;

    public PlayedTimeRecord (int goals) {
        this.goals = goals;
    }

    public int goals() {
        return goals;
    }
}

class NoExtraTime implements TimeRecord {
    public int goals() {
        // They are polymorphic
        // They don't need IF checks
        return 0;
    }
}

public class SoccerMatch {
    private Team homeTeam;
    private Team awayTeam;
    private PlayedTimeRecord regularTime;
    private TimeRecord extraTime;

    public SoccerMatch(Team homeTeam, 
                       Team awayTeam,
                       PlayedTimeRecord regularTime,
                       TimeRecord extraTime) {
        this.homeTeam = homeTeam;
        this.awayTeam = awayTeam;        
        // There's a business rule telling
        // regular time is not optional
        // Therefore is an instance of PlayedTimeRecord
        this.regularTime = regularTime;
        this.extraTime = extraTime;
    }

    public int totalGoals() {
        // 2. Replace null checks with the polymorphic Null Object
        // No Ifs 
        // No null checks
        return regularTime.goals() + extraTime.goals();
    }
} As a side note when you prompt Gemini-AI with the After version it says: While the code is well-structured, there's a minor optimization opportunity.
The NoExtraTime class can be eliminated without compromising the code's
functionality. .. and suggests using the first version with the billion-dollar mistake problem!* Type [x]Semi-Automatic The refactoring has a semantic part that needs to find an existing NullObejct in the domain. Safety This refactoring is generally safe. You must ensure that the Null Object's behavior matches the expected behavior for real cases in your code. The null object needs to be partially polymorphic with real ones. In strongly typed languages, they must adhere to the same interface or belong to the same hierarchy. Why is the code better? You eliminate null checks with accidental IF conditions, making the code cleaner and easier to understand. The Null Object Pattern ensures you always work with objects, avoiding null pointer exceptions - The Billion Dollar Mistake. Tags Null Related Refactorings https://hackernoon.com/refactoring-014-how-to-remove-if?embedable=true See also https://hackernoon.com/null-the-billion-dollar-mistake-8t5z32d6?embedable=true https://refactoring.guru/es/replace-conditional-with-polymorphism?embedable=true This article is part of the Refactoring Series on HackerNoon https://maximilianocontieri.com/how-to-improve-your-code-with-easy-refactorings?embedable=true Eliminating The Billion-Dollar Mistake forever Eliminating The Billion-Dollar Mistake forever TL;DR: Use the Null Object Pattern to eliminate null checks and simplify your code. TL;DR: Use the Null Object Pattern to eliminate null checks and simplify your code. Problems Addressed Frequent null checks and IFs cluttering your code Null pointer exceptions Hard-to-read and maintain code Lack of extensibility Unnecessary complexity with excessive null checks. More detail about NULL creation and regrets Frequent null checks and IFs cluttering your code IFs Null pointer exceptions Null pointer exceptions Hard-to-read and maintain code Lack of extensibility Unnecessary complexity with excessive null checks. More detail about NULL creation and regrets detail about NULL creation and regrets Related Code Smells Code Smell 12 - Null Code Smell 12 - Null Code Smell 260 - Crowdstrike NULL Code Smell 260 - Crowdstrike NULL Code Smell 149 - Optional Chaining Code Smell 149 - Optional Chaining Code Smell 212 - Elvis Operator Code Smell 212 - Elvis Operator Code Smell 192 - Optional Attributes Code Smell 192 - Optional Attributes Code Smell 126 - Fake Null Object Code Smell 126 - Fake Null Object Code Smell 208 - Null Island Code Smell 208 - Null Island Steps These steps are a special case of Remove IF Refactoring Remove IF Refactoring Create a Null Object class that implements the same interface Replace null checks with the polymorphic Null Object Create a Null Object class that implements the same interface Replace null checks with the polymorphic Null Object Sample Code Before public class SoccerMatch {
    private Team homeTeam;
    private Team awayTeam;
    private TimeRecord regularTime;
    private TimeRecord extraTime;

    public SoccerMatch(Team homeTeam, 
                       Team awayTeam,
                       TimeRecord regularTime, 
                       TimeRecord extraTime) {
        this.homeTeam = homeTeam;
        this.awayTeam = awayTeam;
        this.regularTime = regularTime;
        this.extraTime = extraTime;
    }

    public int totalGoals() {
        int goals = regularTime.goals();
        // You might forget this if check 
        // resulting in a null error
        if (extraTime != null) {
            goals += extraTime.goals();
        }
        return goals;
    }
}

class TimeRecord {
    private int goals;

    public TimeRecord(int goals) {
        this.goals = goals;
    }

    public int goals() {
        return goals;
    }
} public class SoccerMatch {
    private Team homeTeam;
    private Team awayTeam;
    private TimeRecord regularTime;
    private TimeRecord extraTime;

    public SoccerMatch(Team homeTeam, 
                       Team awayTeam,
                       TimeRecord regularTime, 
                       TimeRecord extraTime) {
        this.homeTeam = homeTeam;
        this.awayTeam = awayTeam;
        this.regularTime = regularTime;
        this.extraTime = extraTime;
    }

    public int totalGoals() {
        int goals = regularTime.goals();
        // You might forget this if check 
        // resulting in a null error
        if (extraTime != null) {
            goals += extraTime.goals();
        }
        return goals;
    }
}

class TimeRecord {
    private int goals;

    public TimeRecord(int goals) {
        this.goals = goals;
    }

    public int goals() {
        return goals;
    }
} After // 1. Create a Null Object class that implements the same interface

interface TimeRecord {
    // The common protocol between the real object 
    // and the Null Object
    int goals();
}

class PlayedTimeRecord implements TimeRecord {
    // This class is suitable both to be
    // a Regular Time or an Extra Time
    private int goals;

    public PlayedTimeRecord (int goals) {
        this.goals = goals;
    }

    public int goals() {
        return goals;
    }
}

class NoExtraTime implements TimeRecord {
    public int goals() {
        // They are polymorphic
        // They don't need IF checks
        return 0;
    }
}

public class SoccerMatch {
    private Team homeTeam;
    private Team awayTeam;
    private PlayedTimeRecord regularTime;
    private TimeRecord extraTime;

    public SoccerMatch(Team homeTeam, 
                       Team awayTeam,
                       PlayedTimeRecord regularTime,
                       TimeRecord extraTime) {
        this.homeTeam = homeTeam;
        this.awayTeam = awayTeam;        
        // There's a business rule telling
        // regular time is not optional
        // Therefore is an instance of PlayedTimeRecord
        this.regularTime = regularTime;
        this.extraTime = extraTime;
    }

    public int totalGoals() {
        // 2. Replace null checks with the polymorphic Null Object
        // No Ifs 
        // No null checks
        return regularTime.goals() + extraTime.goals();
    }
} // 1. Create a Null Object class that implements the same interface

interface TimeRecord {
    // The common protocol between the real object 
    // and the Null Object
    int goals();
}

class PlayedTimeRecord implements TimeRecord {
    // This class is suitable both to be
    // a Regular Time or an Extra Time
    private int goals;

    public PlayedTimeRecord (int goals) {
        this.goals = goals;
    }

    public int goals() {
        return goals;
    }
}

class NoExtraTime implements TimeRecord {
    public int goals() {
        // They are polymorphic
        // They don't need IF checks
        return 0;
    }
}

public class SoccerMatch {
    private Team homeTeam;
    private Team awayTeam;
    private PlayedTimeRecord regularTime;
    private TimeRecord extraTime;

    public SoccerMatch(Team homeTeam, 
                       Team awayTeam,
                       PlayedTimeRecord regularTime,
                       TimeRecord extraTime) {
        this.homeTeam = homeTeam;
        this.awayTeam = awayTeam;        
        // There's a business rule telling
        // regular time is not optional
        // Therefore is an instance of PlayedTimeRecord
        this.regularTime = regularTime;
        this.extraTime = extraTime;
    }

    public int totalGoals() {
        // 2. Replace null checks with the polymorphic Null Object
        // No Ifs 
        // No null checks
        return regularTime.goals() + extraTime.goals();
    }
} As a side note when you prompt Gemini-AI with the After version it says: While the code is well-structured, there's a minor optimization opportunity.
The NoExtraTime class can be eliminated without compromising the code's
functionality. While the code is well-structured, there's a minor optimization opportunity.
The NoExtraTime class can be eliminated without compromising the code's
functionality. .. and suggests using the first version with the billion-dollar mistake problem!* .. and suggests using the first version with the billion-dollar mistake problem! * the billion-dollar mistake problem! Type [x]Semi-Automatic [x] Semi-Automatic [x] The refactoring has a semantic part that needs to find an existing NullObejct in the domain. Safety This refactoring is generally safe. You must ensure that the Null Object's behavior matches the expected behavior for real cases in your code. The null object needs to be partially polymorphic with real ones. In strongly typed languages, they must adhere to the same interface or belong to the same hierarchy. Why is the code better? You eliminate null checks with accidental IF conditions , making the code cleaner and easier to understand. accidental IF conditions The Null Object Pattern ensures you always work with objects, avoiding null pointer exceptions - The Billion Dollar Mistake . The Billion Dollar Mistake Tags Null Null Related Refactorings https://hackernoon.com/refactoring-014-how-to-remove-if?embedable=true https://hackernoon.com/refactoring-014-how-to-remove-if?embedable=true See also https://hackernoon.com/null-the-billion-dollar-mistake-8t5z32d6?embedable=true https://hackernoon.com/null-the-billion-dollar-mistake-8t5z32d6?embedable=true https://refactoring.guru/es/replace-conditional-with-polymorphism?embedable=true https://refactoring.guru/es/replace-conditional-with-polymorphism?embedable=true This article is part of the Refactoring Series on HackerNoon This article is part of the Refactoring Series on HackerNoon https://maximilianocontieri.com/how-to-improve-your-code-with-easy-refactorings?embedable=true https://maximilianocontieri.com/how-to-improve-your-code-with-easy-refactorings?embedable=true

Walkthroughs, tutorials, guides, and tips. This story will teach you how to do something new or how to do something better.

Code Smell 261 - DigiCert Underscores

Code Smell 260 - Crowdstrike NULL

Buy My Book

Share your ideas with me!

Read My Stories

Buy Me a Coffee

Too Long; Didn't Read

Make resilience your competitive advantage

Code Refactoring Tips: No. 015 - Remove NULL

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

Untitled Story

10 Predictions About the Future of Finance

106 Stories To Learn About Clean Code

100 Pieces of Programming Advice from the Book Clean Code by Robert Martin

110 Stories To Learn About Refactoring

3 Things Coding And Prose Writing Have In Common According To Cory House

10 Predictions About the Future of Finance

106 Stories To Learn About Clean Code

100 Pieces of Programming Advice from the Book Clean Code by Robert Martin

110 Stories To Learn About Refactoring

3 Things Coding And Prose Writing Have In Common According To Cory House

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps