Principles for Software Design and Architectures
Principles are the guidelines that make code easy to read and change: SOLID, DRY, KISS, separation of concerns and composition over inheritance, together with clean code habits and refactoring. They are the lowest level of design and the first thing to apply before reaching for patterns.
Stage: Design Principles · Part of the Software Design and Architecture roadmap · Last reviewed 19 November 2026
What to learn in Principles
- Refactor a large class by applying the single responsibility principle
- Use the open-closed principle to add behaviour without editing old code
- Explain the Liskov substitution principle with a violating example
- Name functions and variables so intent is obvious
- Remove duplication without creating a premature abstraction
- Make small, safe refactoring steps backed by tests
Principles interview questions
What does the Liskov substitution principle require?
Objects of a subtype must be usable wherever the base type is expected without breaking correctness. A subclass should not strengthen preconditions or weaken guarantees. A Square that inherits Rectangle but breaks width and height behaviour is the classic violation.
When is duplication better than abstraction?
When two pieces of code look alike but change for different reasons, merging them couples unrelated concerns. Wait until a pattern is clear, often after three occurrences, so the abstraction fits real shared behaviour.
Where Principles fits in the Software Design and Architecture roadmap
Principles belongs to the Design Principles stage (intermediate level), which takes about 30 hours. Write maintainable code.
Other units in this stage
Back to the full Software Design and Architecture roadmap