Composition Simplifying a subsystem

Facade

Give a workflow one clear way in.

A video-call application needs to check a room and microphone selection, connect to the room, and enable audio. The Join button, invitation screen, and reconnect action all need that sequence. Each caller wants to join a call, but each has to remember the recipe.

Put the recipe behind one operation, and keep its result honest when only part of the setup succeeds.

TypeScriptGoPythonSame setup contract · across the comparison

01 / A task instead of a recipe

The caller wants to join the call.

A single handler can check the inputs, connect, and enable the microphone directly. For one short, stable caller, keeping those calls together is easy to understand. A class is not required merely because three services are involved.

The pressure comes from repeated knowledge. One screen enables audio before the room is ready. Another forgets validation. Every caller now has to remember the ordering and decide what to say when the second or third step fails.

A facade offers a simpler interface to a subsystem, shaped around what its callers need to do. Here, call.join(request) owns the sequence. Rules still validate; the transport still connects; the audio service still enables a microphone. The facade coordinates their work.

The caller owns the room, device choice, trigger, and response to the outcome. It can stop knowing the internal call order. It cannot stop caring whether the requested setup actually completed.

02 / The shape in the comparison

One request, three collaborators.

Start with the basic coordinating function. The practical form holds the same collaborators and translates connection and microphone errors into task-level outcomes. That translation is a convenience added here, closer to the work Adapter teaches; owning the sequence over several collaborators is what makes this a facade. The complete form includes deterministic memory services so you can run every branch.

The contract checks room first, then microphone, for exact emptiness. Whitespace is preserved. Validation failure calls neither setup service. Connection failure stops before audio. Microphone failure leaves the connection intact and preserves any earlier microphone setting.

A successful receipt means the room is connected and the requested microphone is active. Repeating the same room reuses the connection. Joining a different room fails until the session is reset. Those promises come from these memory services, not from the pattern.

Read in

Compare with

One entry point owns validate → connect → enable microphone. This small function already has the facade relationship and propagates collaborator errors.

TypeScriptReading

call.ts

export type JoinRequest = Readonly<{ room: string; microphone: string }>;
export interface Services {
	rules: { check(request: JoinRequest): void };
	transport: { connect(room: string): void };
	audio: { enable(microphone: string): void };
}
export function joinBasic(services: Services, request: JoinRequest): void {
	services.rules.check(request);
	services.transport.connect(request.room);
	services.audio.enable(request.microphone);
}

GoAlongside

call.go

type JoinRequest struct{ Room, Microphone string }
type JoinRules interface{ Check(JoinRequest) error }
type Transport interface{ Connect(string) error }
type Audio interface{ Enable(string) error }
type Services struct {
	Rules     JoinRules
	Transport Transport
	Audio     Audio
}

func JoinBasic(s Services, r JoinRequest) error {
	if err := s.Rules.Check(r); err != nil {
		return err
	}
	if err := s.Transport.Connect(r.Room); err != nil {
		return err
	}
	return s.Audio.Enable(r.Microphone)
}

Read complete examples without JavaScript

call.ts

// Local synchronous illustration: no network connection or microphone access.
export type JoinRequest = Readonly<{ room: string; microphone: string }>;
export interface Services {
	rules: { check(request: JoinRequest): void };
	transport: { connect(room: string): void };
	audio: { enable(microphone: string): void };
}
export function joinBasic(services: Services, request: JoinRequest): void {
	services.rules.check(request);
	services.transport.connect(request.room);
	services.audio.enable(request.microphone);
}

export type JoinReceipt = Readonly<{ room: string; microphone: string }>;
export class CallFacade {
	private readonly services: Services;
	constructor(services: Services) {
		this.services = services;
	}
	join(request: JoinRequest): JoinReceipt {
		this.services.rules.check(request);
		try {
			this.services.transport.connect(request.room);
		} catch {
			throw new Error('Room connection failed');
		}
		try {
			this.services.audio.enable(request.microphone);
		} catch {
			throw new Error('Connected; microphone setup failed');
		}
		// Connecting succeeded even when enabling audio failed. There is no rollback.
		return { room: request.room, microphone: request.microphone };
	}
}

export const failures = ['none', 'connection', 'microphone'] as const;
export type Failure = (typeof failures)[number];
export type MemorySnapshot = { room: string | null; microphone: string | null; events: string[] };
export function createMemorySubsystem() {
	let room: string | null = null,
		microphone: string | null = null;
	let events: string[] = [],
		failure: Failure = 'none';
	const services: Services = {
		rules: {
			check(request) {
				events.push('validate');
				if (request.room === '') throw new Error('Room must not be empty');
				if (request.microphone === '') throw new Error('Microphone must not be empty');
			}
		},
		transport: {
			connect(next) {
				events.push('connect');
				if (failure === 'connection' || (room !== null && room !== next))
					throw new Error('Cannot connect');
				room = next; // Repeating the same join reuses this connection in the model.
			}
		},
		audio: {
			enable(next) {
				events.push('microphone');
				if (failure === 'microphone') throw new Error('Cannot enable microphone');
				microphone = next;
			}
		}
	};
	return {
		services,
		beginAttempt(next: Failure) {
			failure = next;
			events = [];
		},
		snapshot(): MemorySnapshot {
			return { room, microphone, events: [...events] };
		}
	};
}

export function runExample(): string[] {
	const memory = createMemorySubsystem();
	const call = new CallFacade(memory.services);
	const lines: string[] = [];
	for (const failure of ['microphone', 'none'] as const) {
		memory.beginAttempt(failure);
		try {
			const result = call.join({ room: 'design-room', microphone: 'Desk mic' });
			lines.push(`Joined ${result.room}; microphone ${result.microphone}`);
		} catch (error) {
			lines.push(error instanceof Error ? error.message : 'Join failed');
		}
		const state = memory.snapshot();
		lines.push(`room=${state.room ?? 'none'}; microphone=${state.microphone ?? 'off'}`);
	}
	return lines;
}

for (const line of runExample()) console.log(line);

call.go

package main

import (
	"errors"
	"fmt"
)

type JoinRequest struct{ Room, Microphone string }
type JoinRules interface{ Check(JoinRequest) error }
type Transport interface{ Connect(string) error }
type Audio interface{ Enable(string) error }
type Services struct {
	Rules     JoinRules
	Transport Transport
	Audio     Audio
}

func JoinBasic(s Services, r JoinRequest) error {
	if err := s.Rules.Check(r); err != nil {
		return err
	}
	if err := s.Transport.Connect(r.Room); err != nil {
		return err
	}
	return s.Audio.Enable(r.Microphone)
}


type JoinReceipt struct{ Room, Microphone string }
type CallFacade struct{ services Services }

func NewCallFacade(s Services) CallFacade { return CallFacade{services: s} }
func (f CallFacade) Join(r JoinRequest) (JoinReceipt, error) {
	if err := f.services.Rules.Check(r); err != nil {
		return JoinReceipt{}, err
	}
	if err := f.services.Transport.Connect(r.Room); err != nil {
		return JoinReceipt{}, errors.New("Room connection failed")
	}
	if err := f.services.Audio.Enable(r.Microphone); err != nil {
		return JoinReceipt{}, errors.New("Connected; microphone setup failed")
	}
	return JoinReceipt{Room: r.Room, Microphone: r.Microphone}, nil
}


type MemorySnapshot struct {
	Room, Microphone *string
	Events           []string
}

// Single-threaded doubles. Failures happen before the corresponding state change.
type MemorySubsystem struct {
	room, microphone *string
	events           []string
	failure          string
}

func NewMemorySubsystem() *MemorySubsystem { return &MemorySubsystem{events: []string{}} }
func (m *MemorySubsystem) Services() Services {
	return Services{Rules: m, Transport: m, Audio: m}
}
func (m *MemorySubsystem) BeginAttempt(failure string) { m.failure = failure; m.events = []string{} }
func (m *MemorySubsystem) Check(r JoinRequest) error {
	m.events = append(m.events, "validate")
	if r.Room == "" {
		return errors.New("Room must not be empty")
	}
	if r.Microphone == "" {
		return errors.New("Microphone must not be empty")
	}
	return nil
}
func (m *MemorySubsystem) Connect(room string) error {
	m.events = append(m.events, "connect")
	if m.failure == "connection" || (m.room != nil && *m.room != room) {
		return errors.New("Cannot connect")
	}
	m.room = &room
	return nil
}
func (m *MemorySubsystem) Enable(microphone string) error {
	m.events = append(m.events, "microphone")
	if m.failure == "microphone" {
		return errors.New("Cannot enable microphone")
	}
	m.microphone = &microphone
	return nil
}
func copyString(p *string) *string {
	if p == nil {
		return nil
	}
	value := *p
	return &value
}
func (m *MemorySubsystem) Snapshot() MemorySnapshot {
	return MemorySnapshot{
		Room:       copyString(m.room),
		Microphone: copyString(m.microphone),
		Events:     append([]string{}, m.events...),
	}
}

func main() {
	memory := NewMemorySubsystem()
	call := NewCallFacade(memory.Services())
	for _, failure := range []string{"microphone", "none"} {
		memory.BeginAttempt(failure)
		result, err := call.Join(JoinRequest{Room: "design-room", Microphone: "Desk mic"})
		if err != nil {
			fmt.Println(err)
		} else {
			fmt.Printf("Joined %s; microphone %s\n", result.Room, result.Microphone)
		}
		state := memory.Snapshot()
		room, microphone := "none", "off"
		if state.Room != nil {
			room = *state.Room
		}
		if state.Microphone != nil {
			microphone = *state.Microphone
		}
		fmt.Printf("room=%s; microphone=%s\n", room, microphone)
	}
}

call.py

"""Coordinate a bounded call-setup workflow behind one task-level operation."""

from dataclasses import dataclass
from typing import Literal, Protocol


@dataclass(frozen=True)
class JoinRequest:
    room: str
    microphone: str


class JoinRules(Protocol):
    def check(self, request: JoinRequest) -> None: ...


class Transport(Protocol):
    def connect(self, room: str) -> None: ...


class Audio(Protocol):
    def enable(self, microphone: str) -> None: ...


@dataclass(frozen=True)
class Services:
    rules: JoinRules
    transport: Transport
    audio: Audio


def join_basic(services: Services, request: JoinRequest) -> None:
    services.rules.check(request)
    services.transport.connect(request.room)
    services.audio.enable(request.microphone)



@dataclass(frozen=True)
class JoinReceipt:
    room: str
    microphone: str


class CallFacade:
    def __init__(self, services: Services) -> None:
        self._services = services

    def join(self, request: JoinRequest) -> JoinReceipt:
        self._services.rules.check(request)
        try:
            self._services.transport.connect(request.room)
        except Exception as error:
            raise RuntimeError("Room connection failed") from error
        try:
            self._services.audio.enable(request.microphone)
        except Exception as error:
            raise RuntimeError("Connected; microphone setup failed") from error
        return JoinReceipt(request.room, request.microphone)


Failure = Literal["none", "connection", "microphone"]
failures: tuple[Failure, ...] = ("none", "connection", "microphone")


@dataclass
class MemorySnapshot:
    room: str | None
    microphone: str | None
    events: list[str]


class MemorySubsystem:
    def __init__(self) -> None:
        self.room: str | None = None
        self.microphone: str | None = None
        self.events: list[str] = []
        self.failure: Failure = "none"

    def services(self) -> Services:
        return Services(self, self, self)

    def begin_attempt(self, failure: Failure) -> None:
        self.failure = failure
        self.events = []

    def check(self, request: JoinRequest) -> None:
        self.events.append("validate")
        if request.room == "":
            raise ValueError("Room must not be empty")
        if request.microphone == "":
            raise ValueError("Microphone must not be empty")

    def connect(self, room: str) -> None:
        self.events.append("connect")
        if self.failure == "connection" or (self.room is not None and self.room != room):
            raise RuntimeError("Cannot connect")
        self.room = room

    def enable(self, microphone: str) -> None:
        self.events.append("microphone")
        if self.failure == "microphone":
            raise RuntimeError("Cannot enable microphone")
        self.microphone = microphone

    def snapshot(self) -> MemorySnapshot:
        return MemorySnapshot(self.room, self.microphone, list(self.events))



def run_example() -> list[str]:
    memory = MemorySubsystem()
    call = CallFacade(memory.services())
    lines: list[str] = []
    for failure in ("microphone", "none"):
        memory.begin_attempt(failure)
        try:
            result = call.join(JoinRequest("design-room", "Desk mic"))
            lines.append(f"Joined {result.room}; microphone {result.microphone}")
        except Exception as error:
            lines.append(str(error))
        state = memory.snapshot()
        lines.append(f"room={state.room or 'none'}; microphone={state.microphone or 'off'}")
    return lines




if __name__ == "__main__":
    for line in run_example():
        print(line)

FacadeExample.java

import java.util.ArrayList;
import java.util.List;

record JoinRequest(String room, String microphone) {}

interface JoinRules {
    void check(JoinRequest request);
}

interface Transport {
    void connect(String room);
}

interface Audio {
    void enable(String microphone);
}

record Services(JoinRules rules, Transport transport, Audio audio) {}

final class BasicJoin {
    private BasicJoin() {}

    static void join(Services services, JoinRequest request) {
        services.rules().check(request);
        services.transport().connect(request.room());
        services.audio().enable(request.microphone());
    }
}

record JoinReceipt(String room, String microphone) {}

final class CallFacade {
    private final Services services;

    CallFacade(Services services) {
        this.services = services;
    }

    JoinReceipt join(JoinRequest request) {
        services.rules().check(request);
        try {
            services.transport().connect(request.room());
        } catch (RuntimeException error) {
            throw new IllegalStateException("Room connection failed", error);
        }
        try {
            services.audio().enable(request.microphone());
        } catch (RuntimeException error) {
            throw new IllegalStateException("Connected; microphone setup failed", error);
        }
        return new JoinReceipt(request.room(), request.microphone());
    }
}

final class MemorySubsystem implements JoinRules, Transport, Audio {
    private String room;
    private String microphone;
    private final List<String> events = new ArrayList<>();
    private String failure = "none";

    Services services() {
        return new Services(this, this, this);
    }

    void beginAttempt(String nextFailure) {
        failure = nextFailure;
        events.clear();
    }

    @Override
    public void check(JoinRequest request) {
        events.add("validate");
        if (request.room().isEmpty()) throw new IllegalArgumentException("Room must not be empty");
        if (request.microphone().isEmpty()) throw new IllegalArgumentException("Microphone must not be empty");
    }

    @Override
    public void connect(String nextRoom) {
        events.add("connect");
        if (failure.equals("connection") || (room != null && !room.equals(nextRoom))) {
            throw new IllegalStateException("Cannot connect");
        }
        room = nextRoom;
    }

    @Override
    public void enable(String nextMicrophone) {
        events.add("microphone");
        if (failure.equals("microphone")) throw new IllegalStateException("Cannot enable microphone");
        microphone = nextMicrophone;
    }

    MemorySnapshot snapshot() {
        return new MemorySnapshot(room, microphone, new ArrayList<>(events));
    }
}

record MemorySnapshot(String room, String microphone, List<String> events) {}

public final class FacadeExample {
    private FacadeExample() {}

    static List<String> runExample() {
        MemorySubsystem memory = new MemorySubsystem();
        CallFacade call = new CallFacade(memory.services());
        List<String> lines = new ArrayList<>();
        for (String failure : List.of("microphone", "none")) {
            memory.beginAttempt(failure);
            try {
                JoinReceipt result = call.join(new JoinRequest("design-room", "Desk mic"));
                lines.add("Joined " + result.room() + "; microphone " + result.microphone());
            } catch (RuntimeException error) {
                lines.add(error.getMessage());
            }
            MemorySnapshot state = memory.snapshot();
            lines.add("room=" + (state.room() == null ? "none" : state.room())
                + "; microphone=" + (state.microphone() == null ? "off" : state.microphone()));
        }
        return lines;
    }

    public static void main(String[] args) {
        for (String line : runExample()) System.out.println(line);
    }
}

call.rs

use std::cell::RefCell;
use std::rc::Rc;

pub struct JoinRequest {
    pub room: String,
    pub microphone: String,
}
pub trait JoinRules {
    fn check(&self, r: &JoinRequest) -> Result<(), String>;
}
pub trait Transport {
    fn connect(&self, room: &str) -> Result<(), String>;
}
pub trait Audio {
    fn enable(&self, microphone: &str) -> Result<(), String>;
}
pub struct Services {
    pub rules: Box<dyn JoinRules>,
    pub transport: Box<dyn Transport>,
    pub audio: Box<dyn Audio>,
}
pub fn join_basic(s: &Services, r: &JoinRequest) -> Result<(), String> {
    s.rules.check(r)?;
    s.transport.connect(&r.room)?;
    s.audio.enable(&r.microphone)
}

#[derive(Debug, PartialEq, Eq)]
pub struct JoinReceipt {
    pub room: String,
    pub microphone: String,
}
pub struct CallFacade {
    services: Services,
}
impl CallFacade {
    pub fn new(services: Services) -> Self {
        Self { services }
    }
    pub fn join(&self, r: &JoinRequest) -> Result<JoinReceipt, String> {
        self.services.rules.check(r)?;
        self.services
            .transport
            .connect(&r.room)
            .map_err(|_| "Room connection failed")?;
        self.services
            .audio
            .enable(&r.microphone)
            .map_err(|_| "Connected; microphone setup failed")?;
        Ok(JoinReceipt {
            room: r.room.clone(),
            microphone: r.microphone.clone(),
        })
    }
}

#[derive(Clone, Debug, PartialEq, Eq, Default)]
pub struct MemorySnapshot {
    pub room: Option<String>,
    pub microphone: Option<String>,
    pub events: Vec<String>,
}
#[derive(Default)]
struct State {
    view: MemorySnapshot,
    failure: String,
}
#[derive(Clone, Default)]
pub struct MemorySubsystem {
    state: Rc<RefCell<State>>,
}
impl MemorySubsystem {
    pub fn new() -> Self {
        Self::default()
    }
    pub fn services(&self) -> Services {
        Services {
            rules: Box::new(self.clone()),
            transport: Box::new(self.clone()),
            audio: Box::new(self.clone()),
        }
    }
    pub fn begin_attempt(&self, failure: &str) {
        let mut s = self.state.borrow_mut();
        s.failure = failure.into();
        s.view.events.clear();
    }
    pub fn snapshot(&self) -> MemorySnapshot {
        self.state.borrow().view.clone()
    }
}
impl JoinRules for MemorySubsystem {
    fn check(&self, r: &JoinRequest) -> Result<(), String> {
        self.state.borrow_mut().view.events.push("validate".into());
        if r.room.is_empty() {
            return Err("Room must not be empty".into());
        }
        if r.microphone.is_empty() {
            return Err("Microphone must not be empty".into());
        }
        Ok(())
    }
}
impl Transport for MemorySubsystem {
    fn connect(&self, room: &str) -> Result<(), String> {
        let mut s = self.state.borrow_mut();
        s.view.events.push("connect".into());
        if s.failure == "connection" || s.view.room.as_ref().is_some_and(|current| current != room)
        {
            return Err("Cannot connect".into());
        }
        s.view.room = Some(room.into());
        Ok(())
    }
}
impl Audio for MemorySubsystem {
    fn enable(&self, microphone: &str) -> Result<(), String> {
        let mut s = self.state.borrow_mut();
        s.view.events.push("microphone".into());
        if s.failure == "microphone" {
            return Err("Cannot enable microphone".into());
        }
        s.view.microphone = Some(microphone.into());
        Ok(())
    }
}

fn main() {
    let memory = MemorySubsystem::new();
    let call = CallFacade::new(memory.services());
    for failure in ["microphone", "none"] {
        memory.begin_attempt(failure);
        match call.join(&JoinRequest {
            room: "design-room".into(),
            microphone: "Desk mic".into(),
        }) {
            Ok(result) => println!("Joined {}; microphone {}", result.room, result.microphone),
            Err(error) => println!("{}", error),
        }
        let state = memory.snapshot();
        println!(
            "room={}; microphone={}",
            state.room.as_deref().unwrap_or("none"),
            state.microphone.as_deref().unwrap_or("off")
        );
    }
}

Reading the TypeScriptStructural collaborators and exceptions

The Services interface describes three small objects. CallFacade stores that bundle and calls it in order. A thrown validation error propagates; separate catch blocks normalize the two setup failures. The returned receipt is a new object containing the submitted string values.

The lab owns one memory subsystem per experiment. Creating another facade around the same services would share their state. Creating another subsystem gives an independent session.

Reading the GoInterfaces and explicit early returns

Each collaborator implements the method its interface requires. Join checks each returned error before calling the next service. The returned receipt and error express the same task outcome as the TypeScript version.

The memory subsystem is used by one goroutine at a time. Pointer fields distinguish no connection or microphone from a supplied string. Snapshot copies those values and the event slice, so inspecting an earlier attempt does not change the session.

Reading the PythonProtocols, dataclasses, and explicit exceptions

Protocols describe the three collaborator roles, while frozen dataclasses hold the request, receipt, services bundle, and snapshot. CallFacade keeps the same Services bundle and passes validation errors through while normalizing setup failures.

MemorySubsystem implements all three protocols. Its snapshot copies the event list, so a caller can inspect an attempt without mutating the session.

03 / Follow a partial setup

Connected does not yet mean ready to speak.

Watch a failed connection, then a failed microphone setup, then a successful retry. Step through keeps each result available for inspection. Try it lets you change the request and fail either subsystem while retaining the session between attempts.

Before running the microphone failure, predict the room and audio state separately.

Playback controls

Facade

One call. An honest outcome.

Join room → one setup operation

Validate· Not reached
Connect· Not reached
Microphone· Not reached

Call sessionDisconnected

Room connectionNone

MicrophoneOff

No setup attempted.

01/ 04

Before joining

One request starts the setup.

The caller supplies a room and microphone. Neither subsystem is ready yet.

Reduced motion: choose a scene to see its completed state.

Read this scene

The caller supplies a room and microphone. Neither subsystem is ready yet.

Room: none. Microphone: off. Called: nothing yet.

Try the example by reading

A connection failure stops before audio setup. If connection succeeds and microphone setup fails, the room stays connected. Retrying in the same session can enable the microphone and finish the task.

Connected, but ready to speak?

Start with microphone failure. Predict which subsystem changes. Then remove the failure and retry in the same session.

Join room → one setup operation

Validate· Not reached
Connect· Not reached
Microphone· Not reached

Call sessionDisconnected

Room connectionNone

MicrophoneOff

No setup attempted.

No setup attempted yet.

Join a room to see which steps ran and what state they left.

Editing inputs does not run setup; the scene describes the last submitted attempt. This model reuses the same room connection on retry. Reset before joining a different room.

After a successful join, try changing from Desk mic to Headset with microphone failure selected. Desk mic remains active. “Microphone setup failed” describes the attempted change; it does not mean the earlier device was turned off.

04 / Describe the outcome

What can the caller honestly say?

The smaller interface should reduce coordination work while preserving the information needed to recover. Start from a fresh session and choose the response that agrees with the state after audio setup fails.

05 / Who owns the workflow

Keep setup and ownership visible.

Application setup constructs the services and passes them to a facade scoped to one call session. Event handlers submit a request through that boundary. The collaborators still own connection and device behavior; specialists can have separate lower-level operations when they need them.

A real call joins asynchronously. Its contract needs cancellation, timeouts, cleanup on leaving, and a decision about concurrent attempts. A later microphone selection must not be overwritten by a stale completion.

Retried setup also needs a documented identity and lifetime. Here the room string identifies the one retained connection, and the doubles fail before mutating the failed step. Real services can fail after work completes or lose the response. Repeating the request may then require more than calling the same method again.

One method is not a transactionMake partial completion part of the contract

There is no disconnect or compensating action in this example. When audio fails, the connection remains. A production workflow might deliberately keep the connection, offer a listen-only state, or disconnect. Each choice needs explicit behavior and tests.

The teaching facade uses readable error messages. A production API can use structured outcomes to distinguish invalid input, connection failure, and connected-with-audio-failure, while preserving underlying diagnostics for investigation. Callers should not parse display copy as a machine protocol.

Build UIs?Every Join button that calls three services in a row is a facade in the wrong place, and one day a reconnect banner will need the same sequence.

Where it already is in your components

The Join button is a facade you have already written, in the wrong place. Its click handler calls the rules service, the transport, and the audio service in a row, and keeps a flag for each step so the screen can say something. That handler owns the sequence from section 01 and the error handling from section 02, so the component is the only thing that knows connect comes before enable, or that an error thrown after the connected flag was set means the room is fine. The reconnect banner needs the same sequence, and the easy thing is to paste it. The textbook sample below is that handler, once in React with a useState per flag and once in Svelte with a $state per flag.

When you have to own it

Move the sequence behind CallFacade.join and let the component own only what the screen needs. In React that is a useJoinCall hook; in Svelte a createJoinCall function a component calls once. Each holds one facade for the session, exposes join(request), derives a status from the receipt or from the failure, and remembers the device the last successful join enabled. The hook coordinates; the facade owns the sequence, so the reconnect banner calls the same join.

Keep the submitted request distinct from fields the user is still editing: the status carries the request it was built from, so the screen names the room that was joined rather than whatever the input says now. A connection failure means this attempt did not reach audio setup. A microphone failure after connecting should leave the joined room visible and offer a recovery consistent with the device state. On a fresh session that can mean “Connected; microphone off.” After a failed device change it may mean “Connected; still using Desk mic.” Do not infer either state from a generic error alone. The lab keeps the last attempt visible until another request is submitted.

A browser integration would need its own device permission, media-track lifecycle, and stale-request handling. The UI race conditions lesson explores ownership of competing results.

The Join button: three services called in a row from a click handler, with a flag per step and the facade’s sequence leaking into the component.

ReactAlready in your code

JoinButton.tsx

import { useState } from 'react';
import type { Services } from '../call';

// The three services from section 01, handed in by whoever owns the session.
export function JoinButton({ services }: { services: Services }) {
	const [room, setRoom] = useState('');
	const [microphone, setMicrophone] = useState('');
	// Three flags, one per step, each set by hand. Nothing keeps them consistent.
	const [joining, setJoining] = useState(false);
	const [connected, setConnected] = useState(false);
	const [microphoneOn, setMicrophoneOn] = useState(false);
	const [error, setError] = useState<string | null>(null);

	// async because a real connect awaits the network; the lesson's memory services answer at once.
	async function join() {
		setJoining(true);
		setError(null);
		// validate → connect → enable microphone, stopping at the first failure. The sequence
		// and its error handling are the facade's job (section 02) leaking into a click handler.
		// A reconnect banner would repeat every line of it.
		try {
			services.rules.check({ room, microphone });
			services.transport.connect(room);
			setConnected(true);
			services.audio.enable(microphone);
			setMicrophoneOn(true);
		} catch (cause) {
			setError(cause instanceof Error ? cause.message : 'Join failed');
		} finally {
			setJoining(false);
		}
	}

	return (
		<>
			<input value={room} onChange={(e) => setRoom(e.target.value)} />
			<input value={microphone} onChange={(e) => setMicrophone(e.target.value)} />
			<button onClick={() => void join()} disabled={joining}>
				Join
			</button>
			{/* Which step failed? Only the message knows, and only if you parse it. */}
			{error && <p>{error}</p>}
			{/* room is whatever the field says now, not what was submitted. */}
			{connected && (
				<p>
					Joined {room}; microphone {microphoneOn ? 'on' : 'off'}
				</p>
			)}
		</>
	);
}

06 / Already in your toolbox

Recognize a smaller surface for a larger task.

Node’s stream.pipeline() connects streams and generators, forwards errors, and reports completion. The caller supplies the pieces while the utility coordinates their flow. Its cleanup and reuse rules are documented promises of that utility.

React’s createRoot returns an object with render and unmount. Application code asks React to manage content through that narrow public surface. Its lifecycle remains part of the contract: unmounting detaches the root, and that root cannot render again.

Both are facade-like relationships you can read from documented public APIs.

07 / What the extra layer buys

What does the caller get to stop knowing?

A facade earns its place when multiple callers share a meaningful subsystem task, or when the general subsystem API exposes more decisions than a common operation needs. Its value is the responsibility it centralizes, not the number of objects behind it.

When joining requires one more readiness check, callers can keep submitting the same request if its promise stays intact. If the product changes to connecting without enabling audio, the task’s promise changes too; a facade cannot hide that semantic change from callers that depend on it.

Keep a direct function for a short, stable sequence. Avoid a broad PlatformFacade that accumulates unrelated account, billing, and device methods. Split entry points around coherent tasks and owners, and give specialist operations meaningful names instead of unexplained boolean flags.

Distinguish the nearby patterns

Adapter translates an interface into the one a caller requires. Proxy controls access to a represented object. Our facade introduces a task over several service operations.

Mediator coordinates interactions among participants. These services simply respond to facade calls; they do not communicate with each other through it. Template method fixes an algorithm’s sequence while selected steps vary through overrides. The emphasis here is a convenient subsystem boundary.

Dependency injection supplies the collaborators. The facade decides how to use them to fulfill the task. An injected bundle alone is setup, not the simpler workflow.

08 / Take the idea with you

Name the task and its promise.

Explain the design without the pattern name: “I put call setup in one place so each entry screen follows the same sequence. Its outcome distinguishes a connection failure from a connected room whose microphone setup failed.”

Now name one workflow in your own code. What does each caller have to remember? Which decisions could an entry point own? Which partial outcome must remain visible even if the underlying steps are hidden?

Finally, replay the microphone failure from memory. Say which room is connected, which microphone is active, and why returning an error does not restore the earlier session. Then repeat the reasoning after a successful join followed by a failed device change.

Connections to follow nextRelated lessons

Adapter translates one interface into the one a caller expects; a facade gives callers a task over several collaborators.

Mediator owns the rules between participants that talk to each other; these services only answer the facade.

Dependency injection explains how application setup supplies the services the facade coordinates.