Software Design | Software Engineering

Udacity Offer 50 OFF

Software Design and its Activities

Software design deals with transforming the client requirements, as described in the SRS document, into a form (set of documents) that is suitable for implementation in a programming language. A good software design is rarely arrived by using a single step procedure but rather through several iterations through a series of steps.

3 Software Design Levels

1) Architectural Design
2) Preliminary (High-Level) Design
3) Detailed Design

Architectural Design

The architectural design is the highest summarize version of the system. This determines the software or application as a method with many components interacting with each. At this level, the designers get the idea or thought of a suggested clarification domain or province.

Preliminary (High-Level) Design

High-level design means identification of different modules and the control relationships among them and the definition of the interfaces among these modules. The outcome of the high-level design is called software architecture or the program structure. Many different types of notations have been used to represent a high-level design. A popular way is to use a tree-like diagram called the Structure Chart to represent the control hierarchy in the high-level design.

Detailed Design

During detailed design, the data structure and the algorithms of the different modules are designed. The outcome of the detailed design stage is usually known as the module-specification document.

Difference between Analysis and Design

  • The aim of analysis is to understand the problem with a view to eliminate any deficiencies in the requirement specification such as incompleteness, inconsistencies, etc.
  • The aim of design is to produce a model that will provide a seamless transition to the coding phase, i.e. once the requirements are analyzed and found to be satisfactory, a design model is created which can be easily implemented.

Items developed during Software Design Phase

For a design to be easily implemented in a conventional programming language, the following items must be designed during the design phase.

  • Different modules required to implement the design solution.
  • Control relationship among the identified modules. The relationship is also known as the invocation relationship or the call relationship among modules.
  • Interface among different modules. The interface among different modules identifies the exact data items exchanged among the modules.
  • Data structures of the individual modules.
  • Algorithms required to implement each individual module.

Characteristics of a Good Software Design

For a design to be easily implemented in a conventional programming language, the following items must be designed during the design phase.

The definition of “a good software design” can vary depending on the application being designed. Most researchers and software engineers agree on a few desirable characteristics that every good software design for a general application must possess. The characteristics are listed below:

  • Correctness: A good design should correctly implement all the functionalities identified in the SRS document.
  • Understandability: A good design is easily understandable.
  • Efficiency: It should be efficient.
  • Maintainability: It should be easily amenable to change.

The correctness is considered as most important goodness criterion in design. A design has to be correct to be acceptable. Given that a design solution is correct, understandability of design is possibly the most important issue to be considered while judging the goodness of a design. A design that is easy to understand is also easy to develop, maintain and change. Thus, unless a design is easily understandable, it would require tremendous effort to implement and maintain it.

Features of a Design Document

In order to facilitate understandability, the design should have the following features:

  • It should use consistent and meaningful names for various design components.
  • The design should be modular. The term modularity means that it should use a cleanly decomposed set of modules.
  • It should neatly arrange the modules in a hierarchy, e.g. in a tree-like diagram.

Read Further: Wikipedia

  1. Software Development Life Cycle – All Models
  2. Requirements Elicitation
  3. Software Requirement Specification

This Post Has One Comment

Leave a Reply