Code Smell 271 - The Hollywood Principle

Don't Call Us, We'll Call You

TL;DR: The Hollywood Principle promotes loose coupling by inverting control. High-level components decide when and how to use low-level components.

Problems

• Tight coupling
• Difficult to extend
• Reduced flexibility
• Increased complexity
• Violation of SOLID principles
• Lack of Testability

Solutions

1. Apply Inversion of control

   
   

2. Use Dependency injection

   
   

3. Depend on abstractions

Context

The Hollywood Principle is a software design principle emphasizing loose coupling between components.

High-level components should not directly control the execution flow in low-level components.

Low-level components should register themselves with high-level components, and high-level components should decide when and how to use them.

This is also known as Inversion of Control.

Sample Code

Wrong

class TicketCart {
    private paymentMethod: PaymentMethod;

    constructor(paymentMethodType: string) {
        // TicketCart is tightly coupled
        // to specific payment method classes 
        // like CreditCardProcessor and CryptoService.  
        if (paymentMethodType === 'creditCard') {
            this.paymentMethod = new CreditCardProcessor();
        } else if (paymentMethodType === 'Crypto') {
            this.paymentMethod = new CryptoService();
        } else {
            throw new Error('Invalid payment method');
        }
    }

    checkout(money: Money): void {
        this.paymentMethod.pay(money);
    }
}

const cart = new TicketCart('creditCard');
const money = new Money(126, 'USD');
cart.checkout(money);

Right

interface PaymentMethod {
    pay(total: Money): void;
}

class TicketCart {
    private paymentMethod: PaymentMethod;

    constructor(paymentMethod: PaymentMethod) {
        // This solution is more open and less coupled
        // because it relies on abstractions
        this.paymentMethod = paymentMethod;
    }

    checkout(total: Money): void {
        this.paymentMethod.pay(total);
    }
}

class CreditCardProcessor implements PaymentMethod {
    pay(total: Money): void {
        console.log(`Processing payment of ${total.Amount()} 
        ${total.currency()} using credit card.`);
    }
}

const creditCardProcessor = new CreditCardProcessor();
const cart = new TicketCart(creditCardProcessor);
const total = new Money(126, 'USD');
cart.checkout(total);

Detection

• [x]Manual

This is a design smell

Tags

• Coupling

Level

[X ] Intermediate

AI Generation

AI generators can sometimes create code that violates the Hollywood Principle if you don't explicitly instruct them to follow inversion of control patterns.

They often generate straightforward, tightly coupled code by default.

AI Detection

AI tools can effectively detect violations of the Hollywood Principle by analyzing code dependencies and identifying tight coupling with proper instructions. (see below).

Try Them!

Remember: AI Assistants make lots of mistakes

Conclusion

This principle can improve your code quality, reduce complexity, and enhance testability.

Relations

https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxxx

https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-vii-8dk31x0

https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xiii

https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-iv-7sc3w8n

https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xiii

https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xiii

More Info

Disclaimer

Code Smells are my opinion.

"Dependency Injection is fundamentally about passing dependencies to objects, rather than having objects create or find them."

Martin Fowler

This article is part of the CodeSmell Series.

How to Find the Stinky Parts of your Code