Course contentsShow
← Software Engineering
Lesson 273 of 1,9338. Structural Design PatternsFree lesson

Implementing Facades: Design Decisions

Understand how to design effective facades, including what to expose and how to handle subsystem complexity.

Implementing Facades: Design Decisions

You'll learn how to make smart design choices when building facades that truly simplify subsystem interactions.

What Makes a Good Facade?

When implementing a facade, your main challenge is deciding what to expose and how much complexity to hide. A facade acts as your system's "front desk"—it should handle common requests smoothly while keeping the messy back-office operations out of sight.

Key Design Decisions

What to Expose:

  • Include the operations that 80% of clients actually need
  • Focus on high-level use cases, not low-level details
  • Group related operations into logical methods
  • Use meaningful names that describe what clients want to accomplish, not how the subsystem does it

What to Hide:

  • Internal subsystem dependencies and initialization sequences
  • Complex coordination between subsystem components
  • Error handling and recovery logic specific to the subsystem
  • Implementation details that might change

Handling Remaining Complexity

Not every client needs only simple operations. You have options:

  1. Provide both: Let the facade handle common cases, but allow direct subsystem access for advanced users
  2. Layered facades: Create multiple facades at different abstraction levels
  3. Parameterized methods: Add optional parameters to facade methods for flexibility without exposing subsystem details

The Transparency Trade-off

Should your facade completely hide the subsystem? Not always. Sometimes exposing one or two key subsystem components gives power users flexibility without overwhelming beginners. Think of it like a car's dashboard: most drivers only need the steering wheel and pedals, but mechanics need access to the engine.

Key Takeaway: Design facades by focusing on client needs first—expose simple, task-oriented methods for common use cases while deciding whether to completely encapsulate or selectively expose the subsystem based on your users' sophistication and requirements.