Architectural Design in Software Engineering
Software architecture refers to the basic structures of a software system and the discipline of creating structures and systems like these. — structure includes elements of the software, interrelationships, and property of both elements and relationships. Today’s topic is architectural design in software engineering.
What is Architectural design in software engineering?
Software architecture shows the structure of the system and hides details of implementation, focusing on how components of the system interact with each other. In contrast, software design focuses on the implementation of the system, often delving into considerable detail. Software Design and Architecture concerns tend to overlap as expected. But rather than losing energy in defining rules for distinguishing them, treating them as two parts of one process is smarter. Development teams sometimes make decisions that are more architectural when designing software. On the other hand, it is often helpful to focus a little more on design and see how it helps to make the set architecture true.
Computer architectures can be conceived on two abstraction levels:
- Architecture in small involves person software architecture. At this point, we are concerned with the way a variable is decomposed into an individual program.
- Architecture in the broad is concerned with the architecture of complex enterprise systems that include other components of systems, programs, and programs. Such business networks are spread through numerous machines, which may be owned and operated by different businesses.
Architectural Design Process
The architectural design process is for defining the subsystems that make up a system and the mechanism for the control and communication of the sub-systems. A summary of the software architecture is the product of this design process. Architectural design is an early stage in the design process for the system. This represents the connection between processes of specification and design and is often performed in conjunction with other specification activities. This includes defining major components of the system and their communications.
architecture styles and patterns. While general architecture includes design within its scope, the same can not be said for design — in short, not all design is architectural. This is the software architect ‘s job to draw the line between architecture and the comprehensive design of the applications.
Three benefits of designing and documenting software architecture explicitly:
- Communication with stakeholders: Architecture may be used by system stakeholders as a focus for discussion.
- System analysis: Well-documented architecture allows us to analyze whether the system can fulfill its non-functional needs.
- Large-scale reuse: The software can be reusable across a range of devices or entire product lines.
Using easy, informal block diagrams, which display entities and relationships, software architecture is most frequently represented. Pros: simple, useful to communicate with the stakeholders, great for planning projects. Cons: lack of semblance, types of relationships between entities, the identifiable property of architectural entities.
The current software architecture trends are pointing to the fact that design tends to evolve. A software architect can not know it all upfront and provide a complete architecture for the system. Eventually, the concept evolves during the stages of implementation. As the system is implemented the architect of the software can learn from it and test it against the requirements of the real world.
Architectural Styles in Software Engineering
To represent software design the software needs the architectural design. IEEE describes the architectural design as “the process of defining a set of hardware and software components and their interfaces to create a framework for computer system creation.” Computer-based architecture can exhibit one of the many architectural styles.
Each style will describe a category of the system comprising:
- A set of components (eg: a database, computational modules) that perform a system-required function.
- The series of connectors will help the components organize, interact, and collaborate.
- Conditions on how to combine components to shape the framework.
- Semantic models which help the designer understand the system’s overall properties.
Use architectural styles to provide a foundation for all system components.
Data centered architectures:
A data store resides at the center of this architecture and is frequently accessed by the other components that update, add, remove, or change the data present in the store. The figure shows a typical data centering style. A central server is accessed via the application program. Variation of this approach is used to turn the repository into a blackboard when customer-related data or customer-related data changes the customer software notifications. This architecture, centered in data, will promote integrability. This means the existing components can be changed, and new client components can be added to the architecture without other clients’ permission or concern.
Data flow architectures:
This type of architecture is used when input data is to be transformed through a series of computational manipulative components into output data. The figure reflects pipe-and-filter architecture as it uses pipe and filter as well as a group of components called pipe-connected filters. Pipes are used to forwarding data from one component to another. That filter can operate independently and is designed to take data input from a certain form and generate data output from a given form to the next filter. The filters don’t need any knowledge of neighboring filters operating. If the data flow degenerates into a single transform line, then it is called batch sequential.
Call and Return architectures:
It is used to create an easy-to-scale and edit program. There are several sub-styles within the group. Two are listed below.
Remote procedure call architecture: Such components are used to present code distributed across multiple computers on a network in a main program or subprogram.
Main program or subprogram architectures: The main structure of the program decomposes into several subprograms or functions into a hierarchy of checks. Key software includes a variety of sub-programs that can activate additional components.
Object-Oriented architecture: A system ‘s components encapsulate data and the operations required to manipulate the data. Coordination and communication between the components shall be established through the passing message.
Layered architecture: For each layer doing a well-defined set of operations, several different layers are described. Every layer can do certain operations that are increasingly closer to the setting of machine instructions.
Components will obtain the user interface operations on the outer layer and components will conduct the interfacing operating system on the inner layers (communication and synchronization with OS)
Intermediate layers to the functions of utility services and application software.
Software Architecture & Design Introduction
Software architecture and design introduction are defined as : The architecture of a system describes its major components, their relationships (structures), and how they interact with each other. Software architecture and design include several contributory factors such as Business strategy, quality attributes, human dynamics, design, and IT environment. We can separate Architecture and Design software into two distinct phases: Architecture software and Software Design. Throughout Architecture, functional criteria cast non-functional decisions and distinguish them. Functional requirements are achieved in Design.
Interface Design in Software Engineering
Interface design in software engineering or user interface development is the design of hardware and software user interfaces, such as computers, home appliances, mobile devices, and other electronic devices, with an emphasis on improving usability and user experience. The user interface is the front-end view of the program through which the user interacts to use the device. The software interface is part of the software, which is designed to provide the software’s user experience. UI provides a basic human-computer interaction platform. Based on the underlying combination of hardware and software, the UI can be graphical, text-based, audio-video based. UI can be either hardware or software, or a combination of both.
Procedural Design in Software Engineering
The procedural design in software engineering is often understood as a process of software design that mainly uses control commands such as sequence, condition, repetition, applied to the predefined data.
- Sequences help to accomplish the processing steps that are important to any algorithm specification.
- Conditions provide the facilities according to some logical statements for achieving selected processing.
- During the computation process, repeats serve to achieve loopings.
Software Architecture Design Steps
Following are the steps of software architecture design steps:
- Requirements to be analyzed.
- Defines system use cases.
- Identify the processors/modules for use cases to implement.
- Choose a hardware platform and operating system.
- Assign requirements to each processor/module.
- Defines Processor-level sequence diagrams.