The SOLID Principles of Software Design
A 2-3 day course for programmers of any experience level that describes the SOLID principles of Object-Oriented software design, and the associated principles of component design.
- Programmers of all levels of experience who desire to improve their software design skills._
- The two day version is weighted towards lecture and demonstration with a minimum of exercises.
- The three day version shifts the weight towards in-class practice and exercises, withoutdiminishing the lectures and demonstrations.
After this class students will:
- ...understand that modules should have only one reason to change; and be ableto structure systems to minimize the effects of change.
- ...understand that a good software design allows new features to be added withoutchanging existing code.
- ...be able to construct inheritance and polymorphic hierarchies that adhere to a consistentinterface with their users.
- ...understand how to separate interfaces and operations so that low level changes to notpropagate to higher levels.
- ...have a firm grasp on how to manage the dependencies between source code modules suchthat high level policy does not depend upon low level detail.
- ...be able to allocate modules into reusable components.
- ...understand how to separate functionality between components in order to minimize change.
- ...be able to manage the dependencies between components to minimize crosstalk and deployment thrashing.
- ...be able to organize component structures into developable and releasable structures.
- ...understand how to connect components such that changes propagate in the right direction.
- ...know how to allocate classes to components such that high level components do notdepend on low level components.
- ...be familiar with a set of design quality metrics that can be applied to measure the qualityof module and component structures.
- What goes wrong with Software?
- Design Smells
- Code Smells *
- What is OO?
- History of OO
- Dependency Management
- Dependency Inversion
- Plug-in Architecture
- Code Rot
- Example: The Copy Program
- The SOLID Principles
An in-depth presentation of the principles of class and module design.
- (SRP) The Single Reponsibility Principle
- (OCP) The Open-Closed Principle
- (LSP) The Liskov Substitution Principle
- (ISP) The Interface Segregation Principle
- (DIP) The Dependency Inversion Principle
- Component PrinciplesAn in-depth presentation of the principles of component cohesion and coupling.
- What is a component?
- Cohesion Principles
- (REP) The Release Reuse Equivalence Principle
- (CCP) The Common Closure Principle
- (CRP) The Common Reuse Principle
- Coupling Principles
- (ADP) The Acyclic Dependencies Principle
- (SDP) The Stable Dependencies Principle
- (SAP) The Stable Abstractions Principle
- Design Quality Metrics
Several design exercises and demonstrations using UML as time permits.