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

Apply Inversion of control
Use Dependency injection
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

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).