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 Tags Hierarchies 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 Conclusion Parallel hierarchies create unnecessary complexity and make the codebase harder to maintain. They bring deep hierarchies, which is a symptom of subclassification for code reuse You can merge the hierarchies and use composition to simplify the design and improve the system's robustness. You can use Metaprogramming to manage the persistence or the unit tests. Metaprogramming is also a code smell when you use it for domain problems, but persistence and testing are orthogonal domains. Relations Code Smell 137 - Inheritance Tree Too Deep Code Smell 11 - Subclassification for Code Reuse Code Smell 58 - Yo-yo Problem More Info https://hackernoon.com/laziness-chapter-i-meta-programming-6s4l300e?embedable=true Disclaimer Code Smells are my opinion. Inheritance is surely a good answer but who knows the questions? Michel Gauthier Software Engineering Great Quotes This article is part of the CodeSmell Series. How to Find the Stinky Parts of your Code Double Trouble: The Curse of Redundant Structures Double Trouble: The Curse of Redundant Structures TL;DR: Parallel hierarchies lead to duplication and tight coupling. 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 Increased complexity DRY / Code Duplication Maintenance Nightmare Coupling Ripple Effect Potential for inconsistencies across different hierarchies Solutions Merge hierarchies Use composition Extract Common Functionality Merge hierarchies Use composition Extract Common Functionality Refactorings https://hackernoon.com/refactoring-013-eliminating-repeated-code-with-dry-principles?embedable=true https://hackernoon.com/refactoring-013-eliminating-repeated-code-with-dry-principles?embedable=true https://maximilianocontieri.com/refactoring-007-extract-class?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;
} // 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);
    }
} 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 [x] Semi-Automatic [x] You can detect this smell by traversing the hierarchies Exceptions Some frameworks force you to extend your domain using this technique Some frameworks force you to extend your domain using this technique Tags Hierarchies Hierarchies Level [x]Intermediate [x] Intermediate [x] 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 'Instanceof' Conclusion Parallel hierarchies create unnecessary complexity and make the codebase harder to maintain. They bring deep hierarchies , which is a symptom of subclassification for code reuse deep hierarchies subclassification for code reuse You can merge the hierarchies and use composition to simplify the design and improve the system's robustness. You can use Metaprogramming to manage the persistence or the unit tests. Metaprogramming is also a code smell when you use it for domain problems, but persistence and testing are orthogonal domains. Metaprogramming Relations Code Smell 137 - Inheritance Tree Too Deep Code Smell 137 - Inheritance Tree Too Deep Code Smell 11 - Subclassification for Code Reuse Code Smell 11 - Subclassification for Code Reuse Code Smell 58 - Yo-yo Problem Code Smell 58 - Yo-yo Problem More Info https://hackernoon.com/laziness-chapter-i-meta-programming-6s4l300e?embedable=true https://hackernoon.com/laziness-chapter-i-meta-programming-6s4l300e?embedable=true Disclaimer Code Smells are my opinion . opinion Inheritance is surely a good answer but who knows the questions? Inheritance is surely a good answer but who knows the questions? Michel Gauthier Michel Gauthier Software Engineering Great Quotes Software Engineering Great Quotes This article is part of the CodeSmell Series. How to Find the Stinky Parts of your Code How to Find the Stinky Parts of your Code

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

Explaining Bitcoin in 5 Levels of Difficulty

Refactoring 013 - Eliminating Repeated Code with DRY Principles

Buy My Book

Code Smell 255 - Addressing Parallel Hierarchies in Code

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

10 Predictions About the Future of Finance

100 Days of AI Day 4: Maximizing Productivity & Creativity with ChatGPT

10 Tips to Take Your ChatGPT Prompts to the Next Level

10 Tips to Get the Most out of ChatGPT

100 Days of AI Day 2: Enhancing Prompt Engineering for ChatGPT

10 ChatGPT Prompts to Accelerate Your Learning

10 Predictions About the Future of Finance

100 Days of AI Day 4: Maximizing Productivity & Creativity with ChatGPT

10 Tips to Take Your ChatGPT Prompts to the Next Level

10 Tips to Get the Most out of ChatGPT

100 Days of AI Day 2: Enhancing Prompt Engineering for ChatGPT

10 ChatGPT Prompts to Accelerate Your Learning

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps