Code Smell 255 - Addressing Parallel Hierarchies in Code

21 Jun 2024

Double Trouble: The Curse of Redundant Structures

TL;DR: Parallel hierarchies lead to duplication and tight coupling.

Problems

Increased complexity
DRY / Code Duplication
Maintenance Nightmare
Coupling
Ripple Effect
Potential for inconsistencies across different hierarchies

Solutions

Merge hierarchies
Use composition
Extract Common Functionality

Refactorings

https://hackernoon.com/refactoring-013-eliminating-repeated-code-with-dry-principles?embedable=true

https://maximilianocontieri.com/refactoring-007-extract-class?embedable=true

Context

Parallel hierarchies occur when you must make a counterpart every time you create a domain class.

The counterpart might be persistence, UI, Controller, tests, Serialization, etc.

This leads to duplicate structures and tight coupling.

Changes in the domain model require changes in the parallel classes, making the system more brittle and harder to manage.

Sample Code

Wrong

// Domain classes
abstract class Transaction {
    private String id;
    private double amount;
}

class BankTransaction extends Transaction {
    private String bankName;
}

class CreditCardTransaction extends Transaction {
    private String cardNumber;
}

// Persistence classes
abstract class TransactionDAO {
    private String id;
    private double amount;
}

class BankTransactionDAO extends TransactionDAO {
    private String bankName;
}

class CreditCardTransactionDAO extends TransactionDAO {
    private String cardNumber;
}

Right

public class TransactionService {
    private EntityManager entityManager;

    public TransactionService(EntityManager entityManager) {
        this.entityManager = entityManager;
    }

    public void saveTransaction(Transaction transaction) {
        entityManager.getTransaction().begin();
        entityManager.persist(transaction);
        entityManager.getTransaction().commit();
    }

    public Transaction loadTransaction(
        Long id, Class<? extends Transaction> transactionClass) {
        return entityManager.find(transactionClass, id);
    }
}

Detection

[x]Semi-Automatic

You can detect this smell by traversing the hierarchies

Exceptions

Some frameworks force you to extend your domain using this technique

Level

[x]Intermediate

AI Generation

AI generators often create this smell by mirroring domain models in persistence layers without understanding the implications, leading to unnecessary duplication.

AI Detection

AI Assistants can fix this smell with instructions to consolidate hierarchies and use composition, reducing duplication and improving maintainability.

ChatGPT offered a solution using 'Instanceof' which is an even worse code smell