TL;DR: Never focus on implementation. Focus on behavior instead.

Problems

• Coupling to implementation

• Lack of Separation between the 'What' and the 'How'

• Encapsulation and Information Hiding violations

• Lack of Abstraction

• Unclear separation of Interfaces/Protocol

• Coupled Testability

• Debugging using inspectors instead of sending messages to objects.

Solutions

1. Redesign your favorite programming language

2. Ignore the (accidental) implementation and study the available protocol

Context

For historical reasons, most class-based programming languages declare the attributes first and the public protocol after.

This is a problem if you need to understand what a class does at first sight.

Some languages implemented Header files (often denoted by the .h extension).

They contain declarations of functions, classes, variables, and other constructs without providing the full implementation.

These files serve as a way to share information about the structure and interface of a program or library across multiple source code files.

Sample Code

Wrong

public class ShoppingCart {

    // This is Accidental
    private List<Item> items;

    // This is Also Accidental
    // And irrelevant to cart usage
    public ShoppingCart() {
        this.items = new ArrayList<>();
    }

    public void addItem(Item item) {
        items.add(item); 
    }

    public void removeItem(Item item) {
        // Error handling is irrelevant for the example
        items.remove(item);
    }

    public double calculateTotal() {
        double total = 0.0;
        for (Item item : items) {
            total += item.getPrice();
        }
        return total;
    }
}

Right

public class ShoppingCart {

    // Focus on public behavior only    
    // This is invalid in Java :(
    public ShoppingCart() { } 
    public void addItem(Item item) { }  
    public void removeItem(Item item) { }     
    public double calculateTotal() {}
}

Detection

[X] Manual

This is language smell. You cannot detect it.

Exceptions

• This smell applies only to languages requiring explicit attribute definitions like Java, C#, PHP, etc.

Dynamically-typed languages like Python or JavaScript do not require explicit attribute definition.

In these languages, you can create attributes on the fly without declaring them in the class definition.

Tags

• Hierarchies

Level

[X] Beginner

AI Assistants

Most AI Assistants generate code with this smell.

Try prompting: 'Generate a class representing a House in Java'

Conclusion

You cannot change the language you use, still, according to The Sapir-Whorf hypothesis the structure and vocabulary of a language can shape or influence how its speakers perceive and think about the real world using the MAPPER.

Relations

More Info

Disclaimer

Code Smells are my opinion.

Credits

Photo by K8 on Unsplash

---

Tests should be coupled to the behavior of code and decoupled from the structure of code

Kent Beck

---

This article is part of the CodeSmell Series.