Software Design

Software Design is a process to transform user requirements into some suitable form, which helps the programmer in software coding and implementation. For assessing user requirements, an SRS (Software Requirement Specification) document is created, whereas for coding and implementation, there is a need for more specific and detailed requirements in software terms. The output of this process can directly be used in implementation in programming languages. Software design is the first step in SDLC (Software Design Life Cycle), which moves the concentration from the problem domain to the solution domain. It tries to specify how to fulfill the requirements mentioned in SRS.

source: Csharp Star

Software Design Process

Software design is both a process and a model. The design process is a sequence of steps that enables the designer to describe all aspects of the software for building. Creative skill, past experience, a sense of what makes "good" software, and an overall commitment to quality are examples of critical success factors for a competent design. It is important to note, however, that the design process is not always a straightforward procedure; the design model can be compared to an architect's plans for a house. It begins by representing the totality of the thing to be built (e.g., a three-dimensional rendering of the house); slowly, the thing is refined to provide guidance for constructing each detail (e.g., the plumbing lay). Similarly, the design model that is created for software provides a variety of different views of the computer software. Basic design principles enable the software engineer to navigate the design process. Davis suggests a set of principles for software design, which have been adapted and extended in the following list:

• The design process should not suffer from "tunnel vision." A good designer should consider alternative approaches, judging each based on the requirements of the problem, and the resources available to do the job.
• The design should be traceable to the analysis model. Because a single element of the design model can often be traced back to multiple requirements, it is necessary to have a means for tracking how requirements have been satisfied by the design model.
• The design should not reinvent the wheel. Systems are constructed using a set of design patterns, many of which have likely been encountered before. These patterns should always be chosen as an alternative to reinvention. Time is short, and resources are limited; design time should be invested in representing (truly new) ideas by integrating patterns that already exist (when applicable).
• The design should "minimize the intellectual distance" between the software and the problem as it exists in the real world. That is, the structure of the software design should, whenever possible, mimic the structure of the problem domain.
• The design should exhibit uniformity and integration. A design is uniform if it appears fully coherent. In order to achieve this outcome, rules of style and format should be defined for a design team before design work begins. A design is integrated if care is taken in defining interfaces between design components.
• The design should be structured to accommodate change. The design concepts discussed in the next section enable a design to achieve this principle.
• The design should be structured to degrade gently, even when aberrant data, events, or operating conditions are encountered. Well-designed software should never "bomb"; it should be designed to accommodate unusual circumstances, and if it must terminate processing, it should do so gracefully.
• Design is not coding; coding is not design. Even when detailed procedural designs are created for program components, the level of abstraction of the design model is higher than the source code. The only design decisions made at the coding level should address the small implementation details that enable the procedural design to be coded.
• The design should be assessed for quality as it is being created, not after the fact. A variety of design concepts and design measures are available to assist the designer in assessing quality throughout the development process.
• The design should be reviewed to minimize conceptual (semantic) errors. There is sometimes a tendency to focus on minutiae when the design is reviewed, missing the forest for the trees. A design team should ensure that major conceptual elements of the design (omissions, ambiguity, inconsistency) have been addressed before worrying about the syntax of the design model.

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 components interacting with each other. At this level, the designers get an idea of the proposed solution domain.
• High-level Design- The high-level design breaks the ‘single entity-multiple component’ concept of architectural design into a less-abstracted view of sub-systems and modules and depicts their interaction with each other. The high-level design focuses on how the system, along with all of its components, can be implemented in form of modules. It recognizes the modular structure of each sub-system and their relation and interaction with each other.
• 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 its interfaces to communicate with other modules.

See Also

• Software Architecture
• Enterprise Architecture
• Client Server Architecture
• Software Development Life Cycle (SDLC)
• Software Design
• Software-Defined WAN (SD-WAN)
• Software Project Management