“Design is not just what it looks like and feel like, Design
is how it works!! “ – Steve Jobs. This quote tells the story itself,
design is the most fundamental foundation for any successful software
development. This is the process of transforming user requirement into a
simpler and understandable form that helps the coders in coding and
implementing the software system and solution.
For understanding user requirement we use SRS (Software
Requirement Specification), similarly we need more specific document for coding
and implementation, and the end result can directly be used into
implementation.
Software designing helps us creating solution domain
from problem domain. Software designing yields three levels of results in any
software development approach. First is Architectural design, it is the
highest abstract version of the system. It analyze the software as a system
with many components interacting with each other. At this level, the designers
get the idea of proposed solution domain
Next is the High-level design, which breaks the “single
entity-multiple component” concept of architectural design into less abstracted
view of sub systems and modules and identifies their interaction with each
other. Here we focus on how the system and all its components can be
implemented in form of Modules. It depicts modular
structure of each sub system and their relation and interaction among each
other
Finally we do Detail Design, here we deal with the
implementation part of what is seen as a system and its sub system in the
earlier two phases. It is more detailed towards modules and their
implementations. We define logical structure for each module and their
interfaces to communicate with other modules.
We divide a software system into multiple discrete and
independent modules, which are expected to be capable of performing tasks
independently. This technique is known as modularization, these modules may
work as basic constructs for the entire software. Module design follow the
“Divide and conquer” problem solving approach. It helps us easily maintain the
smaller components and desired level of abstraction can be brought into the
program. Module designing also ensures division of program based on functional
aspects and helps in concurrent execution of the modules.
In past days,
software development process was based on sequential execution, i.e. if a
software has multiple modules, then only one of all the modules can be found
active at any time of instance. We can implement concurrency by splitting the
software into multiple independent units if execution, like modules and execute
them in parallel. So for efficient software development, it is important for designers to
recognize those modules, which can be made to execute in parallel.
When we modularized a software program, we divide the problem
into several modules on the basis of some characteristics. These modules must
be so designed that the quality of a design of modules and interaction they can
be properly used for the ease of the system. First we need to check the degree
of intra-dependability within elements of a module, we call this Cohesion.
The greater the cohesion, the better is the program design. Secondly, we need
to analyze the level of inter-dependability among modules of a program, we call
this
Coupling. It tells at what level the modules interfere and interact
with each other. The lower the coupling, the better the program.