Design Principles
Learn SOLID, DRY, KISS, YAGNI, and other principles for building maintainable software.
Adapter Pattern
Read →Learn the Adapter pattern: allow incompatible interfaces to work together. Convert interface of a class into another interface clients expect.
Builder Pattern
Read →Learn the Builder pattern: construct complex objects step by step. Separate construction from representation and create objects with many optional parameters.
Command Pattern
Read →Learn the Command pattern: encapsulate a request as an object, allowing you to parameterize clients with different requests, queue operations, and support undo.
Composite Pattern
Read →Learn the Composite pattern: compose objects into tree structures to represent part-whole hierarchies. Treat individual objects and compositions uniformly.
Composition Over Inheritance
Read →Model behaviour with combinable units so change remains explicit and testable.
Decorator Pattern
Read →Learn the Decorator pattern: attach additional responsibilities to objects dynamically. Provide a flexible alternative to subclassing for extending functionality.
DRY, KISS & YAGNI
Read →Balance reuse, simplicity, and restraint to keep systems adaptable.
Factory Pattern
Read →Learn the Factory pattern: create objects without specifying the exact class. Understand Factory Method and Abstract Factory patterns with examples.
KISS — Keep It Simple, Ship It
Read →Design for clarity first; optimise for comprehension, then extensibility.
Observer Pattern
Read →Learn the Observer pattern: define a one-to-many dependency between objects. When one object changes state, all dependents are notified automatically.
Proxy Pattern
Read →Learn the Proxy pattern: provide a surrogate or placeholder for another object to control access to it. Understand virtual, protection, and remote proxies.
Separation of Concerns
Read →Partition systems by the decisions they protect to keep change local and safe.
Singleton Pattern
Read →Learn the Singleton pattern: ensure a class has only one instance and provide global access to it. Understand when to use it and common pitfalls.
SOLID Principles
Read →Five guiding heuristics to keep software modular, testable, and change-ready.
Strategy Pattern
Read →Learn the Strategy pattern: define a family of algorithms, encapsulate each one, and make them interchangeable. Strategy lets the algorithm vary independently from clients.
YAGNI — You Aren't Gonna Need It
Read →Invest in capabilities when evidence demands them, not when imagination suggests them.