Introduction
Software design is a process of transforming user requirements into a suitable form, which helps the programmer code and implement the software. To assess user needs. They formed an SRS (Software Requirement Specification) document but need more specific and detailed software requirements for coding and implementation. The result of this process can do use directly in implementing programming languages. Software design is the first step in the SDLC (Software Design Life Cycle), which shifts focus from the problem domain to the critical part. First, try to specify how to meet the requirements mentioned in SRS.
Software Design Levels
Software design produces three levels of results:
- Architectural Design is the highest abstract kind of system. It identifies software as a system with many components cooperating. At this level, designers gain insight into the domain of the proposed solution.
- High-Level Design: High-Level Design breaks the concept of “single entity-multiple component” architectural Design into a less abstract view of subsystems and modules and describes their interaction. High-level Design focuses on how the system and its components can implement as modules. It Recognizes the modular structure of each subsystem and their affiliation and interaction with each other.
- Detailed Design – Detailed Design deals with implementing what is consider a system and its subsystems in the previous two designs. It is complete towards modules and their implementations. It defines the logical structure of each element and its interfaces to communicate with other modules.
Modularization – Software Design
Modularization is a technique for divide a software system into several discrete and independent modules, which are suppose to be able to perform tasks independently. These modules can work as base builds for all software. Designers tend to design modules to be execute and compiled separately and independently.
Modular Design unintentionally follows the rules of the “divide and conquer” problem-solving strategy, as there are many other benefits associate with modular software design.
Advantages of modularization – Software Design
- Small components are easier to maintain
- he program can do according to functional aspects.
- The desired level of abstraction can do introduce into the program
- High-cohesion members can do reuse
- Concurrent execution may be possible And also
- Chosen from a security point of view
Competition
Back then, all software was suppose to work sequentially. By sequential execution, we mean that the coded instructions will execute one after the other, implying that only part of the program will activate at a given moment. So, for example, let’s say software has multiple modules; only one can be found lively at any time of execution.
In software design, concurrency is implement by dividing software into several independent execution units, such as modules, and executing them in parallel. In other words, concurrency allows the software to run more than one piece of code in parallel with each other.
Programmers and designers must recognize modules that can execute in parallel.
Coupling and Cohesion
Modularised software’s tasks divide into several modules based on specific characteristics. As we know, modules are instructions put together to accomplish particul tasks. However, they are consider a single entity but can refer to each other to work together. As a result, there are metrics that measure the quality of a module’s Design and their interaction with each other.
Cohesion
Cohesion is a measure that expresses the degree of internal reliability within the elements of a module—the greater the cohesion, the better the program design.
There are seven types of cohesion, namely:
- Haphazard cohesion: This is unplan and random cohesion, which can result from splitting the program into smaller modules for modularization. Because it is arbitrary, it can confuse programmers and is generally not accept.
- Logical Cohesion: When logically categorize elements are brought together in a module, it is called logical cohesion.
- Temporal cohesion – When the elements of a module do organize in such a way that they retreat at a similar time, it is called temporal cohesion.
- Procedural Cohesion: When module elements are group and execute sequentially to complete a task, it is called procedural cohesion.
- Communicational cohesion – It is When the module elements are a group. Execute sequentially and work on the same data (information), it is called communicational cohesion.
- Cohesion: When module elements do group because the output of one part serves as the input for another, and so on, it is called sequential cohesion. And also
- Cohesion is consider the highest degree of cohesion and is a high expect Module element in functional cohesion do group because they all contribute to the same well-defined function.
Conclusion
Software design is a reflection of the act of the software application. Good software design effectively shows the flow of functions while the software is running. From input to output, a software design should show all the steps so that the act of the software application can do analyze.