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

Code Smell 198 - Hidden Assumptions

Maxi Contieri ・ Mar 2 '23

#webdev #beginners #programming #tutorial

Code Smell 32 - Singletons

Maxi Contieri ・ Nov 23 '20

#codenewbie #tutorial #webdev #programming

Code Smell 63 - Feature Envy

Maxi Contieri ・ Mar 23 '21

#codenewbie #programming #oop #webdev

Code Smell 16 - Ripple Effect

Maxi Contieri ・ Nov 4 '20

#programming #tutorial #beginners

Code Smell 61 - Coupling to Classes

Maxi Contieri ・ Feb 4 '21

#webdev #tutorial #codenewbie #programming

Code Smell 64 - Inappropriate Intimacy

Maxi Contieri ・ Mar 27 '21

#codenewbie #codesmell #webdev #oop

More Info

Coupling: The one and only software design problem

Maxi Contieri ・ Feb 6 '21

#webdev #programming #oop #tutorial

Wikipedia

Wiktionary

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

Software Engineering Great Quotes

Maxi Contieri ・ Dec 28 '20

#codenewbie #programming #quotes #software

This article is part of the CodeSmell Series.

How to Find the Stinky parts of your Code

Maxi Contieri ・ May 21 '21

#codenewbie #tutorial #codequality #beginners