Software Design Patterns

Purpose

Guide for applying classic software design patterns in Python and C++ codebases. Patterns help solve common design problems with proven, reusable solutions.

When to Use This Skill

Automatically activates when working on:

• Creating factories or builders
• Implementing plugin systems
• Decoupling components
• Managing object creation complexity
• Adding extensibility to existing code
• Refactoring tightly-coupled code

Pattern Categories

Quick Reference: When to Use Each Pattern

Most Common Patterns (Quick Examples)

Factory Method

# Python
class ControllerFactory:
    _controllers = {"joint": JointController, "cartesian": CartesianController}

    @classmethod
    def create(cls, controller_type: str) -> Controller:
        return cls._controllers[controller_type]()

controller = ControllerFactory.create("joint")

// C++
class ControllerFactory {
public:
    static std::unique_ptr<Controller> Create(const std::string& type) {
        if (type == "joint") return std::make_unique<JointController>();
        if (type == "cartesian") return std::make_unique<CartesianController>();
        throw std::invalid_argument("Unknown type");
    }
};

Builder

# Python - Fluent builder
config = (
    RobotConfigBuilder("Apollo", joint_count=7)
    .with_velocity(2.0)
    .with_collision(False)
    .build()
)

// C++
auto config = RobotConfig::Builder("Apollo", 7)
    .WithVelocity(2.0)
    .WithCollision(false)
    .Build();

Strategy

# Python - Swap algorithms at runtime
class MotionController:
    def __init__(self, generator: TrajectoryGenerator) -> None:
        self._generator = generator

    def set_generator(self, generator: TrajectoryGenerator) -> None:
        self._generator = generator

    def move(self, start: float, end: float) -> np.ndarray:
        return self._generator.generate(start, end)

controller = MotionController(LinearTrajectory())
controller.set_generator(CubicTrajectory())  # Swap at runtime

Observer

# Python - Publish/subscribe
class StatePublisher:
    def __init__(self) -> None:
        self._observers: list[StateObserver] = []

    def subscribe(self, observer: StateObserver) -> None:
        self._observers.append(observer)

    def update_state(self, state: RobotState) -> None:
        for observer in self._observers:
            observer.on_state_change(state)

publisher = StatePublisher()
publisher.subscribe(Logger())
publisher.subscribe(SafetyMonitor())

Decorator

# Python - Add behavior via decorators
@timing
@retry(max_attempts=3)
@log_calls
def send_command(joint_id: int, position: float) -> bool:
    ...

Facade

# Python - Simplify complex subsystem
class RobotFacade:
    def move_to(self, target: Pose) -> bool:
        if not self._safety.is_safe():
            return False
        trajectory = self._motion.plan(target)
        if self._collision.check(trajectory):
            return False
        return self._controller.execute(trajectory)

robot = RobotFacade()
robot.move_to(target_pose)  # Simple interface

Choosing the Right Pattern

Creational Patterns

Structural Patterns

Behavioral Patterns

Anti-Patterns to Avoid

❌ Singleton overuse - Hides dependencies, makes testing hard ❌ God object - One class that does everything ❌ Premature abstraction - Adding patterns before they're needed ❌ Pattern mania - Using patterns for their own sake ❌ Ignoring YAGNI - Building extensibility you'll never use

Pattern Selection Flowchart

Need to create objects?
├── Don't know class until runtime → Factory
├── Many optional parameters → Builder
├── Need exactly one instance → Singleton (carefully!)
└── Need related object families → Abstract Factory

Need to structure objects?
├── Convert interface → Adapter
├── Add behavior dynamically → Decorator
├── Simplify complex API → Facade
└── Tree structure → Composite

Need to manage behavior?
├── Swap algorithms → Strategy
├── Notify on changes → Observer
├── Undo/redo support → Command
└── State-dependent behavior → State

Resource Files

creational-patterns.md

Factory, Abstract Factory, Builder, Prototype, Singleton with full examples

structural-patterns.md

Adapter, Bridge, Composite, Decorator, Facade, Proxy with full examples

behavioral-patterns.md

Strategy, Observer, Command, State, Template Method, Chain of Responsibility

Related Resources

• Refactoring Guru - Design Patterns
• python-dev-guidelines
• cpp-dev-guidelines

Skill Status: COMPLETE ✅ Line Count: < 450 ✅ Progressive Disclosure: Resource files for detailed patterns ✅