Depending on Abstractions - Programming To Interfaces | OneNoughtOne

0/246

System Design (LLD)The Power of Programming to Interfaces

The Power of Programming to Interfaces

LevelIntermediate

Duration60 mins

TopicThe Power of Programming to Interfaces

1 / 4

Depending on Abstractions

The Dependency Puzzle

Imagine you're building a payment processing system. You write code that directly uses StripePaymentProcessor throughout your application. The system works perfectly—until your business expands to regions where Stripe isn't available, and you need to integrate PayPal, Adyen, or local payment providers.

Suddenly, you face a nightmarish scenario: every single class that processes payments needs modification. The OrderService references Stripe. The SubscriptionManager references Stripe. The RefundHandler references Stripe. What should have been a straightforward addition becomes a weeks-long refactoring project with high regression risk.

This situation—painfully common in real-world codebases—illustrates the profound difference between depending on concrete implementations versus depending on abstractions.

What You Will Learn

By the end of this page, you will understand why depending on abstractions is a foundational principle of good software design. You'll learn to recognize concrete dependencies, understand their risks, and see why abstractions provide a more resilient foundation for building software that can evolve over time.

What Does "Depending on Abstractions" Mean?

In software design, a dependency occurs when one piece of code requires another piece of code to function. Your OrderService might depend on a PaymentProcessor to complete transactions. Your UserNotifier might depend on an EmailSender to deliver messages. These dependencies are unavoidable—software is composed of interconnected components.

The question isn't whether to have dependencies, but what kind of dependencies to create.

Concrete dependencies tie your code directly to specific implementations:

class OrderService {
    private StripePaymentProcessor processor;
    
    public OrderService() {
        this.processor = new StripePaymentProcessor();
    }
}

Abstract dependencies tie your code to contracts (interfaces or abstract classes) rather than specific implementations:

class OrderService {
    private PaymentProcessor processor;
    
    public OrderService(PaymentProcessor processor) {
        this.processor = processor;
    }
}

The difference appears subtle—we've merely changed a type annotation. But the implications are profound.

The Dependency Inversion Principle

This principle is formally known as the Dependency Inversion Principle (DIP)—the 'D' in SOLID. It states that high-level modules should not depend on low-level modules; both should depend on abstractions. We'll explore SOLID in detail later, but understanding abstract dependencies now builds essential groundwork.

Understanding the terminology:

When we say "depend on abstractions," we mean:

Your code's type declarations reference interfaces or abstract classes, not concrete implementations
Your code doesn't instantiate concrete classes directly—they're provided from elsewhere (often called "dependency injection")
Your code operates only through the abstract contract, never casting to or assuming specific implementations

This approach creates a seam in your architecture—a point where one implementation can be substituted for another without changing the dependent code.

The Problem with Concrete Dependencies

Concrete dependencies seem convenient at first. You know exactly what class you're using. Your IDE provides full autocompletion. There's no abstraction layer to navigate. But this apparent simplicity masks serious long-term costs.

Consider the anatomy of a concrete dependency:

ConcreteDependent.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class NotificationService {
    // Concrete dependency: directly coupled to Gmail implementation
    private GmailEmailClient emailClient;
    
    public NotificationService() {
        // Direct instantiation: we control the creation
        this.emailClient = new GmailEmailClient(
            "smtp.gmail.com",
            587,
            "[email protected]",
            loadSecretFromVault("gmail-password")
        );
    }
    
    public void notifyUser(User user, String message) {
        // Direct method call on concrete type
        emailClient.sendEmail(
            user.getEmail(),
            "Notification",
            message,
            GmailEmailClient.Priority.NORMAL,  // Gmail-specific enum
            GmailEmailClient.TrackingMode.FULL // Gmail-specific feature
        );
    }
}

This seemingly simple code has created multiple problems:

Hidden Costs of Concrete Dependencies

•Compile-time coupling — NotificationService cannot compile without GmailEmailClient and all its transitive dependencies. Gmail client updates force recompilation of notification code.
•Instantiation coupling — The service knows and manages Gmail-specific configuration (SMTP host, port, credentials). Configuration changes require code modifications.
•API coupling — The code uses Gmail-specific features (Priority, TrackingMode). Switching to SendGrid or Mailgun requires rewriting the notification logic.
•Testing difficulty — Unit tests must either use real Gmail (slow, requires credentials, might send real emails) or complex mocking that understands Gmail's internal structure.
•Runtime inflexibility — You cannot switch email providers at runtime. A/B testing different providers requires code changes and redeployment.

The Ripple Effect

When you depend on a concrete class, you implicitly depend on everything that class depends on. GmailEmailClient might depend on HTTP libraries, authentication systems, retry logic, and more. All of these become transitive dependencies of your NotificationService, even if you never use them directly.

The Abstraction Advantage

Now let's transform the same code to depend on an abstraction:

First, we define the contract:

EmailService.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/**
 * Abstraction for email sending capabilities.
 * Defines WHAT we need, not HOW it's implemented.
 */
public interface EmailService {
    
    /**
     * Sends an email to the specified recipient.
     * 
     * @param recipient The email address to send to
     * @param subject   The email subject line
     * @param body      The email content
     * @throws EmailDeliveryException if sending fails
     */
    void sendEmail(String recipient, String subject, String body) 
        throws EmailDeliveryException;
    
    /**
     * Checks if the email service is currently available.
     * Useful for health checks and graceful degradation.
     */
    boolean isAvailable();
}

Then, our service depends only on this abstraction:

AbstractDependent.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public class NotificationService {
    // Abstract dependency: coupled only to the contract
    private final EmailService emailService;
    
    // Dependency injection: implementation provided externally
    public NotificationService(EmailService emailService) {
        Objects.requireNonNull(emailService, "emailService must not be null");
        this.emailService = emailService;
    }
    
    public void notifyUser(User user, String message) {
        if (!emailService.isAvailable()) {
            log.warn("Email service unavailable, notification queued");
            notificationQueue.enqueue(user, message);
            return;
        }
        
        try {
            emailService.sendEmail(
                user.getEmail(),
                "Notification",
                message
            );
        } catch (EmailDeliveryException e) {
            log.error("Failed to send notification", e);
            notificationQueue.enqueue(user, message);
        }
    }
}

Observe what we've gained:

Benefits of Abstract Dependencies

•Compile-time isolation — NotificationService compiles with only the EmailService interface. It has no knowledge of Gmail, SendGrid, or any specific provider.
•Configuration externalization — The service doesn't know how email is configured. SMTP details, API keys, and retry policies are implementation concerns.
•API stability — The interface defines a stable contract. Provider-specific features don't leak into consumer code.
•Test simplicity — We can inject a simple test double that implements EmailService with in-memory behavior. No mocking frameworks required.
•Runtime flexibility — We can switch implementations based on configuration, environment, or even at runtime for different use cases.

The Interface as a Firewall

Think of the interface as a firewall between components. Changes on one side of the interface (the implementation) don't propagate to the other side (the consumers). This firewall is what makes large codebases manageable—teams can work on implementations independently without coordinating with every consumer.

Real-World Dependency Scenarios

Let's examine how abstract dependencies solve real-world problems that concrete dependencies make difficult:

Scenario 1: Multi-Provider Strategy

Your notification system needs to use different email providers for different purposes—transactional emails via SendGrid (high deliverability), marketing via Mailchimp (analytics), and internal alerts via self-hosted Postfix (security).

MultiProviderExample.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
// With abstract dependencies, this is trivial:
public class NotificationRouter {
    private final EmailService transactionalEmail;
    private final EmailService marketingEmail;
    private final EmailService internalEmail;
    
    public NotificationRouter(
        EmailService transactionalEmail,
        EmailService marketingEmail,
        EmailService internalEmail
    ) {
        this.transactionalEmail = transactionalEmail;
        this.marketingEmail = marketingEmail;
        this.internalEmail = internalEmail;
    }
    
    public void send(Notification notification) {
        switch (notification.getType()) {
            case TRANSACTIONAL:
                transactionalEmail.sendEmail(...);
                break;
            case MARKETING:
                marketingEmail.sendEmail(...);
                break;
            case INTERNAL_ALERT:
                internalEmail.sendEmail(...);
                break;
        }
    }
}
 
// Configuration wires up specific implementations:
@Configuration
public class EmailConfig {
    @Bean("transactionalEmail")
    public EmailService transactionalEmail() {
        return new SendGridEmailService(apiKey, ...);
    }
    
    @Bean("marketingEmail")
    public EmailService marketingEmail() {
        return new MailchimpEmailService(apiKey, ...);
    }
    
    @Bean("internalEmail")
    public EmailService internalEmail() {
        return new PostfixEmailService(smtpHost, ...);
    }
}

Scenario 2: Environment-Specific Behavior

In development, you want to capture emails for inspection without actually sending them. In staging, you want to send real emails but only to a whitelist of test accounts. In production, you want full sending capability.

EnvironmentSpecific.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
// Development: capture for inspection
public class InMemoryEmailService implements EmailService {
    private final List<SentEmail> sentEmails = new ArrayList<>();
    
    public void sendEmail(String recipient, String subject, String body) {
        sentEmails.add(new SentEmail(recipient, subject, body, Instant.now()));
        log.info("Email captured: {} -> {}", subject, recipient);
    }
    
    // Useful for testing assertions
    public List<SentEmail> getSentEmails() {
        return Collections.unmodifiableList(sentEmails);
    }
}
 
// Staging: whitelist filter
public class WhitelistEmailService implements EmailService {
    private final EmailService delegate;
    private final Set<String> allowedRecipients;
    
    public void sendEmail(String recipient, String subject, String body) {
        if (allowedRecipients.contains(recipient)) {
            delegate.sendEmail(recipient, subject, body);
        } else {
            log.warn("Email to {} blocked (not in whitelist)", recipient);
        }
    }
}
 
// Production: real sending
public class SendGridEmailService implements EmailService {
    // Full production implementation
}

Scenario 3: Graceful Degradation

When your primary email provider experiences an outage, you want to automatically fail over to a backup provider without any code changes.

FailoverExample.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
public class FailoverEmailService implements EmailService {
    private final List<EmailService> providers;
    
    public FailoverEmailService(List<EmailService> providers) {
        if (providers.isEmpty()) {
            throw new IllegalArgumentException("At least one provider required");
        }
        this.providers = new ArrayList<>(providers);
    }
    
    public void sendEmail(String recipient, String subject, String body) 
            throws EmailDeliveryException {
        EmailDeliveryException lastException = null;
        
        for (EmailService provider : providers) {
            if (!provider.isAvailable()) {
                continue;
            }
            
            try {
                provider.sendEmail(recipient, subject, body);
                return; // Success!
            } catch (EmailDeliveryException e) {
                lastException = e;
                log.warn("Provider {} failed, trying next", provider.getClass());
            }
        }
        
        throw new EmailDeliveryException("All providers failed", lastException);
    }
}
 
// Configuration: ordered by preference
new FailoverEmailService(List.of(
    sendGridService,    // Primary
    mailgunService,     // Secondary
    postfixService      // Last resort
));

The Decorator Pattern

Notice how WhitelistEmailService and FailoverEmailService both implement EmailService while also holding a reference to another EmailService. This is the Decorator pattern—a powerful technique for adding behavior to collaborators without modifying them. Abstractions make this pattern possible.

Cognitive Benefits of Abstractions

Beyond the technical benefits, depending on abstractions provides significant cognitive advantages that make code easier to understand and reason about.

Abstraction as Documentation

An interface declaration is a form of documentation that never goes out of date. When you read:

public interface OrderRepository {
    Order findById(OrderId id);
    List<Order> findByCustomer(CustomerId customerId);
    void save(Order order);
    void delete(OrderId id);
}

You immediately understand the capabilities available for order persistence—without reading any implementation code. This is intentional narrowing of scope: the interface tells you exactly what operations are available and hides the 500+ lines of database connection pooling, query optimization, and caching logic in the implementation.

Cognitive Advantages

•Reduced mental load — When reading NotificationService, you only need to understand the EmailService contract, not the internals of SMTP or HTTP API calls.
•Clear boundaries — Interfaces explicitly declare what crosses module boundaries. You know exactly what API surface you're consuming.
•Focused testing verification — Tests can assert against the interface contract. If a new implementation passes the same interface tests, it's a valid substitution.
•Parallel understanding — New team members can understand the system's structure by reading interfaces, then dive into implementations only as needed.
•Change impact analysis — When interfaces are stable, you know that implementation changes are local. Interface changes signal broader impact.

Abstraction as Vocabulary

Interfaces also establish a shared vocabulary for your domain. When your codebase consistently uses terms like PaymentGateway, InventoryService, NotificationChannel, and AuthenticationProvider, team members can communicate using these abstractions:

"The CheckoutService needs a new PaymentGateway implementation for cryptocurrency payments."

This statement is meaningful to everyone on the team—they know the interface, they know what implementation means, and they can discuss the design without diving into code. The abstraction becomes a boundary object for collaborative design discussions.

Architecture as Communication

Great software architecture is as much about human communication as it is about code organization. Abstractions provide the vocabulary for that communication. When you depend on well-named abstractions, you're investing in your team's ability to reason about the system collectively.

Testing with Abstract Dependencies

One of the most immediate practical benefits of depending on abstractions is dramatically simpler testing. Let's see why.

With concrete dependencies:

ConcreteTestingProblem.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// The service creates its own dependencies
public class OrderProcessor {
    private PayPalPaymentClient paypal = new PayPalPaymentClient();
    private StripePaymentClient stripe = new StripePaymentClient();
    
    public void processOrder(Order order) {
        // ... complex logic using paypal and stripe
    }
}
 
// Testing options are limited:
class OrderProcessorTest {
    @Test
    void testProcessOrder() {
        // Option 1: Use real PayPal and Stripe in tests
        // Problems: Slow, requires credentials, makes real charges!
        
        // Option 2: Use reflection to inject mocks
        OrderProcessor processor = new OrderProcessor();
        Field paypalField = processor.getClass().getDeclaredField("paypal");
        paypalField.setAccessible(true);
        paypalField.set(processor, mockPaypal);
        // Problems: Brittle, breaks on refactoring, violates encapsulation
        
        // Option 3: Add setters for testing
        // Problems: Pollutes production API with test concerns
        
        // Option 4: Use PowerMock to mock constructors
        // Problems: Slow, complex, fragile, hides design problems
    }
}

With abstract dependencies:

AbstractTestingSimplicity.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
// The service receives its dependencies
public class OrderProcessor {
    private final PaymentService paymentService;
    
    public OrderProcessor(PaymentService paymentService) {
        this.paymentService = paymentService;
    }
    
    public OrderResult processOrder(Order order) {
        if (order.getTotal().isZero()) {
            return OrderResult.noPaymentNeeded();
        }
        
        PaymentResult result = paymentService.charge(
            order.getPaymentMethod(),
            order.getTotal()
        );
        
        return result.isSuccessful() 
            ? OrderResult.success(result.getTransactionId())
            : OrderResult.failed(result.getErrorMessage());
    }
}
 
// Testing is straightforward:
class OrderProcessorTest {
    
    @Test
    void processOrder_zeroTotal_noPaymentNeeded() {
        // Arrange: Create a processor with any PaymentService (won't be used)
        PaymentService mockPayment = mock(PaymentService.class);
        OrderProcessor processor = new OrderProcessor(mockPayment);
        Order zeroOrder = Order.builder().total(Money.ZERO).build();
        
        // Act
        OrderResult result = processor.processOrder(zeroOrder);
        
        // Assert
        assertThat(result.getStatus()).isEqualTo(OrderStatus.NO_PAYMENT_NEEDED);
        verifyNoInteractions(mockPayment);
    }
    
    @Test
    void processOrder_validOrder_chargesPaymentService() {
        // Arrange: Create a PaymentService that returns success
        PaymentService mockPayment = mock(PaymentService.class);
        when(mockPayment.charge(any(), any()))
            .thenReturn(PaymentResult.success("TXN-123"));
        
        OrderProcessor processor = new OrderProcessor(mockPayment);
        Order order = Order.builder()
            .total(Money.of(99.99, USD))
            .paymentMethod(creditCard)
            .build();
        
        // Act
        OrderResult result = processor.processOrder(order);
        
        // Assert
        assertThat(result.isSuccessful()).isTrue();
        assertThat(result.getTransactionId()).isEqualTo("TXN-123");
        verify(mockPayment).charge(creditCard, Money.of(99.99, USD));
    }
    
    @Test
    void processOrder_paymentFails_returnsFailed() {
        // Arrange: Create a PaymentService that returns failure
        PaymentService mockPayment = mock(PaymentService.class);
        when(mockPayment.charge(any(), any()))
            .thenReturn(PaymentResult.failed("Card declined"));
        
        OrderProcessor processor = new OrderProcessor(mockPayment);
        Order order = Order.builder().total(Money.of(50.00, USD)).build();
        
        // Act
        OrderResult result = processor.processOrder(order);
        
        // Assert
        assertThat(result.isFailed()).isTrue();
        assertThat(result.getErrorMessage()).isEqualTo("Card declined");
    }
}

The Testability Litmus Test

If you struggle to write unit tests without complex setup, mocking frameworks, or special tools, it's often a sign that your code depends on concrete implementations rather than abstractions. Difficult tests are a design feedback signal—they're telling you the dependencies are too rigid.

Common Misconceptions

As you begin applying the principle of depending on abstractions, watch for these common misconceptions that can lead you astray:

Misconception

•"Every class needs an interface" — Creating IUserService for every UserService adds ceremony without benefit if there's truly only one implementation.
•"Abstract = Interface" — Abstractions can also be abstract classes. Interfaces aren't the only way to create seams in your code.
•"More abstraction = better" — Over-abstraction creates indirection that makes code harder to follow without providing flexibility you'll actually use.

Reality

•Introduce abstractions at natural seams — External services, volatile logic, and cross-cutting concerns benefit most. Internal helpers often don't need interfaces.
•Choose the right abstraction mechanism — Use interfaces for pure contracts, abstract classes when you have shared implementation logic.
•Abstract what varies — The goal is flexibility where needed, not abstraction for its own sake. Over-abstraction is as problematic as under-abstraction.

The Header Interface Anti-Pattern

Don't create interfaces that are 1:1 mirrors of a single class's public methods (sometimes called 'header interfaces'). This provides no abstraction—it's just indirection. Valid abstractions emerge from identifying the contract that multiple implementations or consumers share, not from mechanically extracting every class's surface.

The Right Reasons to Create Abstractions:

Multiple implementations exist or are likely — You have or expect PayPal, Stripe, and other payment processors
Testing requires substitution — The concrete implementation is slow, expensive, or has side effects
Decoupling module boundaries — Different teams own different implementations
Configuration varies by environment — Development, staging, and production need different behavior
The dependency is volatile — Third-party APIs change; you want a stable internal contract

Conversely, don't create abstractions when:

The implementation is stable and unlikely to change
There's no testing benefit (simple data classes, static utilities)
The cost of indirection exceeds the benefit of flexibility

Summary and Key Takeaways

We've explored why depending on abstractions—rather than concrete implementations—is a foundational principle of flexible software design. Let's consolidate the key lessons:

Key Takeaways

•Dependencies are inevitable; dependency direction is a choice — Every system has interconnected components. What matters is whether those connections are to concrete implementations or abstract contracts.
•Concrete dependencies create coupling cascades — When you depend on StripePaymentClient, you implicitly depend on everything Stripe depends on. Changes propagate through your codebase.
•Abstractions create firewalls — An interface shields consumers from implementation changes. Modifications to one side don't propagate to the other.
•Abstract dependencies enable substitution — Multiple providers, environment-specific behavior, failover strategies, and decorator patterns all become possible when dependencies are abstract.
•Testing becomes trivial with abstractions — Inject simple test doubles instead of wrestling with mocking frameworks or production services.
•Abstractions serve as documentation and vocabulary — Well-designed interfaces communicate capabilities and establish shared terminology for the team.
•Abstract strategically, not mechanically — Create abstractions where they provide flexibility or testability. Don't add indirection without purpose.

What's next:

Now that we understand why to depend on abstractions, the next page explores how abstractions create flexibility in practice. We'll see concrete patterns for designing systems that can evolve gracefully as requirements change—without requiring rewrites of dependent code.

Page Complete

You now understand the principle of depending on abstractions. This concept—formally known as the Dependency Inversion Principle—is one of the most powerful tools in a software designer's toolkit. In the next page, we'll see how to leverage this principle to create genuinely flexible systems.