When your methods return generic types, you break the call chain When your methods return generic types, you break the call chain TL;DR: Avoid methods that return Object, Any, or null instead of specific types. Make them fully polymorphic TL;DR: Avoid methods that return Object, Any, or null instead of specific types. Make them fully polymorphic Problems 😔 Missed Polymorphism
Tight Coupling
Excessive Null Checks
Confusing Returns
Fragile Code
Hard to Test
Lost type safety
Ifs Pollution
Broken polymorphism
Runtime errors
Unclear contracts
Testing difficulties
Poor maintainability Missed Polymorphism Tight Coupling Excessive Null Checks Null Checks Confusing Returns Fragile Code Hard to Test Lost type safety Ifs Pollution Ifs Pollution Broken polymorphism Runtime errors Unclear contracts Testing difficulties Poor maintainability Solutions 😃 Return Polymorphic Types
Use Null Object Pattern
Avoid Returning any
Favor Exceptions for Errors
Rename for Clarity
Return specific types or Interfaces
Use proper abstractions
Create meaningful objects Return Polymorphic Types Polymorphic Types Use Null Object Pattern Null Object Pattern Avoid Returning any any Favor Exceptions for Errors Rename for Clarity Return specific types or Interfaces Use proper abstractions Create meaningful objects Refactorings ⚙️ https://hackernoon.com/code-refactoring-tips-no-015-remove-null?embedable=true https://hackernoon.com/code-refactoring-tips-no-015-remove-null?embedable=true Context 💬 When you write a method that can return many types, such as an any or a null, you lose polymorphism. any null null Polymorphism lets you treat objects that share an interface or a base type interchangeably, simplifying your code. Returning null forces your callers to write extra checks and handle special cases, which clutters the code and increases coupling. Returning any (or a type that erases actual type information) makes it harder to understand what the method actually returns, causing bugs and confusion. You force callers to perform type checking and casting. casting This breaks the fundamental principle of polymorphism where objects should behave according to their contracts. contracts Methods should return specific types that clearly communicate their intent and allow the compiler to verify correctness at compile time. Remember Two methods are polymorphic if their signatures are the same, the arguments are polymorphic, AND the return is also polymorphic. Two methods are polymorphic if their signatures are the same, the arguments are polymorphic, AND the return is also polymorphic. polymorphic Sample Code 📖 Wrong ❌ public class DatabaseConnection {
    public Object execute(String sql) {
        if (sql.startsWith("SELECT")) {
            return new ResultSet();
        } else if (sql.startsWith("INSERT")) {
            return Integer.valueOf(42);
        } else if (sql.startsWith("UPDATE")) {
            return Boolean.TRUE;
        }
        return null;
        // The billion dollar mistake
    }
}

public class QueryHandler {
    public void handle(String sql, DatabaseConnection db) {
        Object result = db.execute(sql);
        // The caller needs to be aware of many different types
        if (result instanceof ResultSet) {
            System.out.println("Fetched rows");
        } else if (result instanceof Integer) {
            System.out.println("Inserted " + result);
        } else if (result instanceof Boolean) {
            System.out.println("Updated " + result);
        } else {
            System.out.println("Unknown result");
        }
    }
}

// This second class has a method execute()
// which is NOT polymorphic since it returns 
// another types
public class NonRelationalDatabaseConnection {
    public Object execute(String query) {
        if (query.startsWith("FIND")) {
            return new Document();
        } else if (query.startsWith("INSERT")) {
            return Integer.valueOf(1);
        } else if (query.startsWith("UPDATE")) {
            return Boolean.TRUE;
        }
        return null; // The billion dollar mistake
    }
} public class DatabaseConnection {
    public Object execute(String sql) {
        if (sql.startsWith("SELECT")) {
            return new ResultSet();
        } else if (sql.startsWith("INSERT")) {
            return Integer.valueOf(42);
        } else if (sql.startsWith("UPDATE")) {
            return Boolean.TRUE;
        }
        return null;
        // The billion dollar mistake
    }
}

public class QueryHandler {
    public void handle(String sql, DatabaseConnection db) {
        Object result = db.execute(sql);
        // The caller needs to be aware of many different types
        if (result instanceof ResultSet) {
            System.out.println("Fetched rows");
        } else if (result instanceof Integer) {
            System.out.println("Inserted " + result);
        } else if (result instanceof Boolean) {
            System.out.println("Updated " + result);
        } else {
            System.out.println("Unknown result");
        }
    }
}

// This second class has a method execute()
// which is NOT polymorphic since it returns 
// another types
public class NonRelationalDatabaseConnection {
    public Object execute(String query) {
        if (query.startsWith("FIND")) {
            return new Document();
        } else if (query.startsWith("INSERT")) {
            return Integer.valueOf(1);
        } else if (query.startsWith("UPDATE")) {
            return Boolean.TRUE;
        }
        return null; // The billion dollar mistake
    }
} Right 👉 interface QueryResult {
    void display();
}

class SelectResult implements QueryResult {
    public void display() {
        System.out.println("Fetched rows");
    }
}

class InsertResult implements QueryResult {
    private final int count;
    InsertResult(int count) { this.count = count; }
    public void display() {
        System.out.println("Inserted " + count);
    }
}

class UpdateResult implements QueryResult {
    private final boolean ok;
    UpdateResult(boolean ok) { this.ok = ok; }
    public void display() {
        System.out.println("Updated " + ok);
    }
}

class DocumentResult implements QueryResult {
    public void display() {
        System.out.println("Fetched documents");
    }
}

interface DatabaseConnection {
    QueryResult execute(String query);
}

public class RelationalDatabaseConnection 
  implements DatabaseConnection {
    public QueryResult execute(String sql) {
        // execute() is now polymorphic and returns a QueryResult
        if (sql.startsWith("SELECT")) {
            return new SelectResult();
        } else if (sql.startsWith("INSERT")) {
            return new InsertResult(42);
        } else if (sql.startsWith("UPDATE")) {
            return new UpdateResult(true);
        }
        // You remove null
        throw new IllegalArgumentException("Unknown SQL");
    }
}

public class NonRelationalDatabaseConnection 
  implements DatabaseConnection {
    public QueryResult execute(String query) {
        // execute() is now polymorphic and returns a QueryResult
        if (query.startsWith("FIND")) {
            return new DocumentResult();
        } else if (query.startsWith("INSERT")) {
            return new InsertResult(1);
        } else if (query.startsWith("UPDATE")) {
            return new UpdateResult(true);
        }
        throw new IllegalArgumentException("Unknown query");
    }
}

public class QueryHandler {
    public void handle(String sql, DatabaseConnection db) {
        QueryResult result = db.execute(sql);
        result.display();
    }
} interface QueryResult {
    void display();
}

class SelectResult implements QueryResult {
    public void display() {
        System.out.println("Fetched rows");
    }
}

class InsertResult implements QueryResult {
    private final int count;
    InsertResult(int count) { this.count = count; }
    public void display() {
        System.out.println("Inserted " + count);
    }
}

class UpdateResult implements QueryResult {
    private final boolean ok;
    UpdateResult(boolean ok) { this.ok = ok; }
    public void display() {
        System.out.println("Updated " + ok);
    }
}

class DocumentResult implements QueryResult {
    public void display() {
        System.out.println("Fetched documents");
    }
}

interface DatabaseConnection {
    QueryResult execute(String query);
}

public class RelationalDatabaseConnection 
  implements DatabaseConnection {
    public QueryResult execute(String sql) {
        // execute() is now polymorphic and returns a QueryResult
        if (sql.startsWith("SELECT")) {
            return new SelectResult();
        } else if (sql.startsWith("INSERT")) {
            return new InsertResult(42);
        } else if (sql.startsWith("UPDATE")) {
            return new UpdateResult(true);
        }
        // You remove null
        throw new IllegalArgumentException("Unknown SQL");
    }
}

public class NonRelationalDatabaseConnection 
  implements DatabaseConnection {
    public QueryResult execute(String query) {
        // execute() is now polymorphic and returns a QueryResult
        if (query.startsWith("FIND")) {
            return new DocumentResult();
        } else if (query.startsWith("INSERT")) {
            return new InsertResult(1);
        } else if (query.startsWith("UPDATE")) {
            return new UpdateResult(true);
        }
        throw new IllegalArgumentException("Unknown query");
    }
}

public class QueryHandler {
    public void handle(String sql, DatabaseConnection db) {
        QueryResult result = db.execute(sql);
        result.display();
    }
} Detection 🔍 Semi-Automatic Semi-Automatic Look for methods with return types like Object, Any, void*, or frequent null returns. Also check for scattered if-null checks or type checks after method calls. Tooling and static analyzers sometimes warn about methods returning any or null without documentation. Search for instanceof checks or type casting after method calls. Watch for methods that return different types based on parameters or their internal state. Exceptions 🛑 Generic collection frameworks
Serialization libraries Generic collection frameworks Serialization libraries Tags 🏷️ Polymorphism Polymorphism Level 🔋 Intermediate Intermediate Why the Bijection Is Important 🗺️ When a method always returns a type that aligns with the concept it represents, programmers don't need special cases. Breaking this Bijection by returning any or null creates ambiguity. Bijection The calling code must guess the actual type or deal with nulls, increasing bugs and maintenance cost. Real-world objects have specific types and behaviors. Real-world AI Generation 🤖 AI generators sometimes produce methods returning any or null because they prioritize flexibility or simplicity over strong typing and polymorphism. AI Detection 🧲 AI tools can fix this smell when given instructions to enforce typed returns and suggest Null Object or Optional patterns. Null Object They can refactor null returns into polymorphic return hierarchies automatically if guided. Simple prompts about "improving return types" often help AI suggest better alternatives. Try Them! 🛠 Remember: AI Assistants make lots of mistakes Remember: AI Assistants make lots of mistakes Suggested Prompt: Replace methods returning Object, Any, or null with specific return types. Create proper abstractions and null object patterns. Ensure type safety and clear contracts Suggested Prompt: Replace methods returning Object, Any, or null with specific return types. Create proper abstractions and null object patterns. Ensure type safety and clear contracts Without Proper Instructions

With Specific Instructions



ChatGPT

ChatGPT



Claude

Claude



Perplexity

Perplexity



Copilot

Copilot



You

You



Gemini

Gemini



DeepSeek

DeepSeek



Meta AI

Meta AI



Grok

Grok



Qwen

Qwen Without Proper Instructions

With Specific Instructions



ChatGPT

ChatGPT



Claude

Claude



Perplexity

Perplexity



Copilot

Copilot



You

You



Gemini

Gemini



DeepSeek

DeepSeek



Meta AI

Meta AI



Grok

Grok



Qwen

Qwen Without Proper Instructions

With Specific Instructions Without Proper Instructions Without Proper Instructions With Specific Instructions With Specific Instructions ChatGPT

ChatGPT ChatGPT ChatGPT ChatGPT ChatGPT ChatGPT ChatGPT Claude

Claude Claude Claude Claude Claude Claude Claude Perplexity

Perplexity Perplexity Perplexity Perplexity Perplexity Perplexity Perplexity Copilot

Copilot Copilot Copilot Copilot Copilot Copilot Copilot You

You You You You You You You Gemini

Gemini Gemini Gemini Gemini Gemini Gemini Gemini DeepSeek

DeepSeek DeepSeek DeepSeek DeepSeek DeepSeek DeepSeek DeepSeek Meta AI

Meta AI Meta AI Meta AI Meta AI Meta AI Meta AI Meta AI Grok

Grok Grok Grok Grok Grok Grok Grok Qwen

Qwen Qwen Qwen Qwen Qwen Qwen Qwen Conclusion 🏁 Methods should return specific types that clearly communicate their purpose and enable compile-time verification. When you replace non-polymorphic returns with proper abstractions, you create safer, more maintainable code that expresses its intent clearly. Relations 👩‍❤️‍💋‍👨 https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-ix-7rr33ol https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-ix-7rr33ol https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-iii-t7h3zkv https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-iii-t7h3zkv https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-iii-t7h3zkv https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-iii-t7h3zkv https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-ix-7rr33ol https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-ix-7rr33ol https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxvi https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxvi More Information 📕 https://hackernoon.com/how-to-get-rid-of-annoying-ifs-forever-zuh3zlo?embedable=true https://hackernoon.com/how-to-get-rid-of-annoying-ifs-forever-zuh3zlo?embedable=true https://hackernoon.com/null-the-billion-dollar-mistake-8t5z32d6?embedable=true https://hackernoon.com/null-the-billion-dollar-mistake-8t5z32d6?embedable=true https://en.wikipedia.org/wiki/Design_by_contract?embedable=true https://en.wikipedia.org/wiki/Design_by_contract?embedable=true Disclaimer 📘 Code Smells are my opinion. opinion Credits 🙏 Photo by Randy Fath on Unsplash Randy Fath Unsplash Return the right type, always. Return the right type, always. Brian Goetz Brian Goetz https://hackernoon.com/400-thought-provoking-software-engineering-quotes?embedable=true https://hackernoon.com/400-thought-provoking-software-engineering-quotes?embedable=true This article is part of the CodeSmell Series. https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-i-xqz3evd?embedable=true https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-i-xqz3evd?embedable=true

Code Smell 03: Functions Are Too Long - Here's How to Fix That

Code Smell 02 - Don’t Let Mysterious Numbers Rule Your Code

Buy My Book

Code Smell 308 - The Key to Safer, Cleaner, More Polymorphic Code

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

Untitled Story

10 Predictions About the Future of Finance

Don’t Defend What’s Disappearing — Build What’s Emerging

The gh0stEdit Attack: How Hackers Hide in Docker Image Layers

Meta’s AI Boss Just Called LLMs ‘Simplistic’ — Here’s What He’s Building Instead

106 Stories To Learn About Clean Code

10 Predictions About the Future of Finance

Don’t Defend What’s Disappearing — Build What’s Emerging

The gh0stEdit Attack: How Hackers Hide in Docker Image Layers

Meta’s AI Boss Just Called LLMs ‘Simplistic’ — Here’s What He’s Building Instead

106 Stories To Learn About Clean Code

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps