Page 128 - DCAP405_SOFTWARE_ENGINEERING

Unit 8: Design Engineering

Fragility: When you make a change, unexpected parts of the system break. Notes
Immobility: It is hard to reuse in another application because it cannot be disentangled
from the current application.

Open Close Principle

Software entities like classes, modules and functions should be open for extension but closed for
modifications.
OPC is a generic principle. You can consider it when writing your classes to make sure that when
you need to extend their behavior you don’t have to change the class but to extend it. The same
principle can be applied for modules, packages, libraries. If you have a library containing a set
of classes there are many reasons for which you’ll prefer to extend it without changing the code
that was already written (backward compatibility, regression testing). This is why we have to
make sure our modules follow Open Closed Principle.
When referring to the classes Open Close Principle can be ensured by use of Abstract Classes and
concrete classes for implementing their behavior. This will enforce having Concrete Classes
extending Abstract Classes instead of changing them. Some particular cases of this are Template
Pattern and Strategy Pattern.

Dependency Inversion Principle

High-level modules should not depend on low-level modules. Both should depend on
abstractions.
Abstractions should not depend on details. Details should depend on abstractions.
Dependency Inversion Principle states that we should decouple high level modules from low
level modules, introducing an abstraction layer between the high level classes and low level
classes. Further more it inverts the dependency: instead of writing our abstractions based on
details, we should write the details based on abstractions.
Dependency Inversion or Inversion of Control are better know terms referring to the way in
which the dependencies are realized. In the classical way when a software module (class,
framework) need some other module, it initializes and holds a direct reference to it. This will
make the 2 modules tight coupled. In order to decouple them the first module will provide a
hook (a property, parameter) and an external module controlling the dependencies will inject
the reference to the second one.
By applying the Dependency Inversion the modules can be easily changed by other modules just
changing the dependency module.

Did u know? What is Inversion of Control Container?

Factories and Abstract Factories can be used as dependency frameworks, but there are
specialized frameworks for that, known as Inversion of Control Container.

Interface Segregation Principle

Clients should not be forced to depend upon interfaces that they don’t use.
This principle teaches us to take care how we write our interfaces. When we write our interfaces
we should take care to add only methods that should be there. If we add methods that should not

LOVELY PROFESSIONAL UNIVERSITY 121