What is good software design

Software design basics

Software design is a process of transforming user requirements into some suitable form that aids the programmer in software coding and implementation.

For assessing user requirements, an SRS (Software Requirement Specification) document is created, while for coding and implementation, there is a need of more specific and detailed requirements in software terms. The output of this process can be directly used in the implementation in programming languages.

Software design is the first step in SDLC (Software Design Lifecycle), which moves concentration from problem area to solution area. An attempt is made to indicate how to meet the requirements mentioned in SRS.

Software design levels

Software design yields three levels of results:

  • Architectural design - The architectural design is the highest abstract version of the system. It identifies the software as a system with many component It identifies the software as a system with many components, interacting with one another. At this level, the designers get the idea of ​​the proposed domain solution. s interacting with each other. At this level, the designers get the idea of ​​proposed solution domain.

  • High level design - The high-level design breaks the "single entity-multiple component" concept of the architectural design into less abstracted view of subsystems and modules and shows their interaction with each other. High-level design focuses on how the system can be implemented along with all of its components in the form of modules. It recognizes the modular structure of each subsystem and their relationship and interaction with one another.

  • Detailed design - Detailed design deals with the implementation part of what is seen as a system and its sub-systems in the previous two designs. It is more detailed towards modules and their implementations. It defines the logical structure of each module and their interfaces to communicate with other modules.


Modularization is a technique of dividing a software system into multiple discrete and independent modules that are expected to be capable of performing task (s) independently of one another. These modules can work like basic constructs for all software. Designers tend to design modules in such a way that they can be executed and / or put together separately and independently.

Modular design inadvertently follows the rules of the 'divide and conquer' problem solving strategy, this is because there are many other advantages attached to the modular design of a software.

Advantage of modularization:

  • Smaller components are easier to maintain
  • Program can be divided on the basis of functional aspects
  • Desired level of abstraction can be brought into the program
  • Components with high cohesion can be reused again
  • Simultaneous execution can be made possible
  • desired from security aspect


Back in time, all software are meant to be executed sequentially. By sequential execution, we mean that the coded instruction will be executed one at a time, implying only part of the program is to be activated at any given time. In other words, if a software has several modules, then only one of the entire modules can be found active at any point in time during execution.

In software design, concurrency is implemented by dividing the software into several independent units of execution, such as modules and executing them in parallel. In other words concurrency Represents ability to the software to execute more than part of the code in parallel to each other.

It is necessary for the programmers and designers to realize those modules which can be made to run in parallel.


The spell check feature in word processing is a module of software that runs alongside the word processing itself.

Coupling and Cohesion

When a software program is modularized, its tasks are divided into several modules based on some characteristic. As we will know the modules are set of instructions, put together in order to achieve some task. They are, however, viewed as a single entity, but can refer to each other to work together. There are measures by which the quality of the design of the modules and their interactions among them can be measured. These measures are called coupling and cohesion.


Cohesion is a measure that defines the degree of inner reliability within elements of a module. The greater the cohesion, the better the program design.

There are seven types of cohesion, namely -

  • Co-addition to cohesion - It's unplanned and random cohesion, which could be the result of breaking the program into smaller modules for the sake of modularization. Because it is unplanned, it can cause confusion to the programmer and is generally not accepted.

  • logical cohesion - When logically categorized elements are put together in a module, it is called logical cohesion.

  • Temporal cohesion - When elements of the module are organized so that they are at a similar point in time being processed, it is called as temporal cohesion.

  • procedural cohesion - When elements of the module are grouped together that are Executed Sequentially in order to Execute a task it's called Procedure Cohesion.

  • Communicational cohesion - When elements of the module are grouped together, which are carried out sequentially and working on the same data (information), it is called communication cohesion.

  • sequential cohesion - When elements of the module are grouped since the output of one element serves as an input to another and so on, it is considered sequential cohesion.

  • functional cohesion - It is considered to be the highest degree of cohesion, and it is highly anticipated. Elements of the module in Functional Cohesion are grouped because they all contribute to a single, well-defined function. It can also be reused.


Coupling is a measure that defines the level of inter-reliability among the modules of a program. It tells at what level the modules get involved and interact with each other. The lower the coupling, the better the program.

There are five levels of coupling, namely -

  • Content coupling - When a module can directly access or modify or reference the content of another module, it is called the content level coupling.

  • common coupling - If several modules have read and write access to some global data, it is called common or global coupling.

  • Control coupling - Two modules are called control-coupled when one of them decides the function of the other module or changes its flow of execution.

  • Stamp pairing - When multiple modules share common data structure and work on different part of it, it is called stamp clutch.

  • Data coupling - Data coupling is when two modules interact with each other by means of passing data (as parameters). If a module passes data structure as a parameter, then the receiving module should use all of its components.

Ideally, no pairing is considered to be the best.

Design verification

The output of the software design process is the design documentation, pseudo codes, detailed logical diagrams, process diagrams and detailed description of all functional or non-functional requirements.

The next phase, which is the implementation of the software, depends on all the outputs mentioned above.

It will then be necessary to verify the output before proceeding to the next phase. The early any mistake is detected, the better it is, or the sooner it could not be detected until the product is tested. If the outputs of the design phase are in formal notation form, then the associated tools for verification should be used elsewhere a thorough design review can be used for verification and validation.

Through a structured verification approach reviewers can discover defects that can be caused by overlooking some conditions. A good design review is important to good software design, precision and quality.