Software Design Fundamentals

Software development is the process of translating user requirements into some suitable form that assists the programmer in coding and implementing the software.

To assess user requirements, an SRS (Software Requirements Specification) document is created, while for coding and implementation, more specific and detailed requirements from a software point of view are needed. The output of this process can be directly used for implementation in programming languages.

Software development is the first step in SDLC (Software Development Life Cycle) that shifts focus from the problem area to the solution area. He is trying to indicate how to fulfill the requirements specified in the SRS.

Software development levels
Software development gives three levels of results:

Architectural design – architectural design is the highest abstract version of the system. It identifies software as a system with many components interacting with each other. At this level, designers receive an idea of the proposed solution.
High -level design. The design of a high level breaks the concept of architectural design “One object-non-component” into a less abstracted representation of subsystems and modules and displays their interaction with each other. High -level design is focused on how the system, along with all its components, can be implemented in the form of modules. It recognizes the modular structure of each subsystem and their relationship and interaction with each other.
A detailed design – detailed design deals with part of the implementation of what is considered as a system and its subsystems in the previous two projects. More details about modules and their implementations. It determines the logical structure of each module and their interfaces for communication with other modules.
Modularization is a method of dividing the software system into several separate and independent modules, which are expected to be able to perform the task (and) independently. These modules can work as basic designs for all software. Designers, as a rule, design modules so that they can be performed and / or compile separately and independently.

The modular design is unintentional follows the rules of the Strategy “Separate and conquer”, because there are many other advantages associated with the modular software design.

The advantage of modularity:

Smaller components are easier to support
The program can be divided based on functional aspects
The desired level of abstraction can be added to the program
Components with high cozhesia can be re -used again
Perhaps simultaneous execution
At one time, all software should be performed sequentially. Under sequential execution, we mean that the encoded instruction will be carried out one after another, which implies activation of only one part of the program at any time. Let’s say there are several modules in the software, then only one of all the modules can be found active at any time.

In the development of software, parallelism is realized by dividing the software into several independent units of execution, such as modules, and their parallel execution. In other words, parallelism provides software with the ability to perform more than one part of the code parallel to each other.

Programmers and designers need to recognize those modules in which parallel execution can be performed.

The function of checking spelling in a text processor is a software module that works along the text processor itself.

Clutch and clutch
When the software is modular, its tasks are divided into several modules based on some characteristics. As we know, the modules are a set of instructions collected together to solve some problems. Nevertheless, they are considered as a whole, but can refer to each other for collaboration. There are measures by which you can measure the quality of the design of the modules and their interaction between them. These measures are called clutch and cohesion.

Cohesion is a measure that determines the degree of intracedousness inside the elements of the module. The greater cohesion, the better the design of the program.

There are seven types of cohesion, namely –

Random rallying is an unplanned and random rally, which may be the result of the division of the program into smaller modules for modularity. Since this is unplanned, this can be misleading programmers and is usually not accepted.
Logical cohesion – when logically categorized elements are combined into a module, this is called logical cohesion.
Empoal Cohesion – when the module elements are organized so that they are processed at the same time, this is called temporary cohesion.
Procedure unity – when the module elements are grouped together, which are performed sequentially to complete the task, this is called procedural unity.
Communication cohesion – when the module elements are grouped together, which are performed sequentially and work with the same data (information), this is called communication cohesion.
Conservative clutch – when the module elements are grouped, because the output of one element serves as an entrance for another, etc., this is called a sequential clutch.

Communication is a measure that determines the level of interdependence between the program modules. He reports at what level the modules interact and interact with each other. The lower the connection, the better the program.

Previous PostNextNext Post