Rigidity
The tendency for software to be difficult to change, even in simple ways.
Fragility
The tendency of software to break in many places every time it is changed.
Immobility
the inability to reuse code in other parts of your project because the code in question has
too much baggage.
Needless complexity
It occurs when developers anticipate changes to the requirements and put facilities in the
software to deal with those potential changes.
Needless repetition
It occurs when developers miss an abstraction.
Opacity
the tendency of a module to be difficult to understand.
DRY
Duplication is a waste of time and effort
KISS
Complexity should be avoided
YAGNI
Functionality should only be added if needed.
MVP – Minimum viable product
Limit requirements to a manageable amount that can be designed, developed, tested and delivered.
Software Module
A software module should show tight cohesion and low coupling
Encapsulate what varies
If the business logic of some piece of code is likely to change often, that piece of code should be
isolated from the rest of the system.
Refactoring
a systematic process of improving code without creating new functionality
Program to an interface
Objects should not be instantiated as members of a concrete class.
Favour object composition over inheritance
We should rather have “has a” relations between classes than “is a”.
-Single responsibility principle (SRP)
A class should have only one reason to change.
Open/Closed principle (OCP)
It should be possible to extend classes and methods but not modify them.
Liskov substitution principle (LSP)
It should be possible to instantiate an object as a member of a child class but declare it as a
member of its parent class.
Interface segregation principle (ISP)
No derived class should be forced to implement methods that it will never use.
Dependency inversion principle (DIP)
Modules in a system should depend on an abstraction and not on each other.
Creational Patterns
Mechanisms that increase flexibility and reuse.
Structural Patterns
Objects and classes can be assembled into larger units
Behavioural Patterns
Take care of communication between objects.
