Good Production Code Flashcards
What does SOLID stand for?
- Single Responsability
- Open Closed
- Liskov’s Substitution
- Interface
- Segregation
- Dependency Inversion
What is the Single Responsibility Principle?
There should NEVER be more than ONE reason for a class to change → ONE JOB
What are (3) indicators for the Single Responsibility Principle?
- Many public functions
- Unrelated functions
- Various class clients
What is a class client?
A class using another class’s public funtions
How to follow the Single Responsibility Principle?
Division into multiple simple classes with…
- composition
- aggregation
- dependency
What is the Open Closed Principle?
Classes should be open for extension but closed for modification.
→ Never modify a class in order to handle a new one
What are (2) indicators for the Open Closed Principle?
- Modification needed to handle a new class
3. Switch-Case to check object type
How to follow the Open Closed Principle?
- (Abstract classes)
2. Interfaces
When is it okay to use switch-case?
In a Factory Pattern to ask “Who do you wanna be?”
Explain the Dependency Inversion Principle
Never depend on (call) a concrete class! Always depend on your own abstractions.
What are (2) indicators for the Dependency Inversion Principle?
- Dependency on concrete classes
2. Long chain of dependencies (coupling)
How to follow the Dependency Inversion Princliple?
- Dependency upon high level abstractions with low level implementation
- Interfaces as Boundaries between layers
What patterns use the Dependency Inversion Principle?
- Adapter
- Template
- Strategy
Explain the adapter pattern
Integration (use) of any class without your own Interface and without modifying the target class
Explain the template pattern
Seperation of algorithm and its implementations with inheritance
Explain the strategy pattern
Algorithm and Implementation depend on Abstraction (Interface and Composition)
Was is the Interface Segregation Principle?
Don’t force clients to depend upon interfaces they do not use.
→ No fat interfaces!
What is a client interface?
Public Function
→ Service proposed to other classes
What are (3) indicators for unterface segregation?
- Fat interface
- High coupling
- Complex classes
What is a fat interface?
One that has many public functions
How to follow interface segregation?
Split up interfaces so they are…
- Thin
- Client-specific
- Independent
What general problem is described by abstraction inconsistency?
Bad functions and classes are everywhere!
→ abstraction naming and behaviour are inconsistent
What (3) can you do to avoid abstraction inconsistency?
- never assume behaviour but test it and read the doc
- Principle of Least Astonishment for naming and method signatures
- abstraction hierarchy → one level of abstraction per class/function
Explain Liskov’s Substitution Principle in your own words!
A child class should have the same public behaviour as it’s parent. Thus it should be able to replace it at any time.
What happens when you don’t follow Liskov’s Substitution Principle?
- Rigid and fragile system
- Open-Closed Principle violated (switch-case needed)
- Silent bugs
What is the public behaviour of an object?
What it’s doing → Behaviour that it’s clients depend on
What is the private behaviour of an object?
How it works
What are pre/post conditions?
State of an object before/after a function call
- Must be true to execute
- Will be true after execution
What is a silent bug?
One that is not visible during runtime (no crash)
What is the newspaper metaphor?
Classes should be structured from abstraction to detail
What is the state of an object?
Value of it’s variables at a certain time
What are the advantages of “assert” over “throw new exception”? When do you use it in terms of Liskov’s Substitution Principle?
You can disable “assert” to improve runtime
Used before and after function computation to test pre/post conditions
