Rigidity
-the tendency for software to be difficult to change, even in simple ways
-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
-Often the
breakage occurs in areas that have no conceptual relationship with the area that was changed.
Immobility
the inability to reuse code in other parts of your project because the code in question has
too much baggage
Viscosity
the inability of something to flow
Two types of software viscosity
-viscosity of the design
-viscosity of the environment.
High viscosity
When the design preserving methods are harder to employ than the hacks
When does the viscosity of the environment happen?
when the development environment is slow and inefficient.
Needless complexity
-when developers anticipate changes to the requirements and put facilities in the software to deal with those potential changes.
-The design becomes littered with constructs that are never used.
Needless repetition
When the same code appears over and over again, in slightly different forms, the developers are missing an abstraction
Opacity
-the tendency of a module to be difficult to understand.
-Code can be written in a clear
and expressive manner, or it can be written in an opaque and convoluted manner.
Basic design principles
-DRY (Dont repeat yourself)
-KISS (Keep it simple, stupid)
-YAGNI ( You ain’t gonna need it)
-MVP (Minimum viable product)
KISS – Keep it simple, stupid
Simplicity is key. Complexity should be avoided
YAGNI – You ain’t gonna need it
functionality should only be added when it is required
MVP – Minimum viable product
the scope of a piece of work is limited to the smallest set of
requirements towards a functioning deliverable
High cohesion
everything in the module should work towards the same goa
Loose coupling
independent from other modules (
Cohesion
-a measure of the degree to which the elements of the module are functionally
related
-It is the internal glue that keeps the module together
Functional cohesion
Everything that is needed for the task is available inside the
module
Sequential cohesion
An element outputs some data that becomes the input for other element
Communicational cohesion
Two elements operate on the same input data or contribute towards the same output data.
