With clearly defined design rules, new developers can come up to speed quickly on how the software is supposed to work and how they should structure their code. When design rules are monitored, tight scheduling does not erode the architecture and, if it does, the consequences of time pressure can be tracked architectural technical debt and monitored. Design rules make managing large, complex software systems easier because there are clear rules on how different elements can and cannot interact.
Distributed teams outsourcing, offshoring can be counted on to produce higher quality code because they have rules to follow. Without design rules, it is impossible to manage the long-term health and maintainability of the software. Software architecture degrades over time with successive revisions.
This is typically called architecture erosion. Without clear rules, developers can and will change the software with unintended consequences. Architecture erosion also leads to maintainability issues. Bad dependencies are introduced which leads to code that is hard to understand and change. This is typically referred to as brittle code. Some of the other consequences of a lack of design rules include lower reliability, less modularity, lower performance, and lower interoperability. Design rules give actionable insight into violations of the intended architecture that are a consequence of normal development.
The first step is finding an easy way to communicate the architecture to the entire team. The key to this modularity is the use of design rules that must be followed and that allow designers and software developers to creatively solve complex problems.
Design rules are also key to the computer software industry. Design rules are a way to specify the allowed nature of the relationship between various subsystems. Design rules have two purposes:. There are many benefits to design rules. Design rules are an easy way for the software architecture to be communicated to the entire development team.
With clearly defined design rules, new developers can come up to speed quickly on how the software is supposed to work and how they should structure their code. When design rules are monitored, tight scheduling does not erode the architecture and, if it does, the consequences of time pressure can be tracked architectural technical debt and monitored.
Design rules make managing large, complex software systems easier because there are clear rules on how different elements can and cannot interact. Distributed teams outsourcing, offshoring can be counted on to produce higher quality code because they have rules to follow.
Without design rules, it is impossible to manage the long-term health and maintainability of the software. A component diagram shows the subsystems and their import dependencies. If appropriate, indicate its relationship to elements in the logical or process view. The Data View This view describes the architecturally significant persistent elements in the data model. It describes an overview of the data model and its organization in terms of the tables, views, indexes, triggers and stored procedures used to provide persistence to the system.
It also describes the mapping of persistent classes from the Logical View to the data structure of the database. It typically includes: The mapping from key persistent design classes, especially where the mapping is non-trivial. The architecturally significant parts of the system which have been implemented in the database, in the form of stored procedures and triggers. Important decisions in other views which have data implications, such as choice of transaction strategy, distribution, concurrency, fault tolerance.
For example, the choice to use database-based transaction management relying on the database to commit or abort transactions requires that the error handling mechanism used in the architecture include a strategy for recovering from a failed transaction by refreshing the state of persistence objects cached in memory in the application. You should present architecturally significant data model elements, describe their responsibilities, as well as a few very important relationships and behaviors triggers, stored procedures, etc.
This section describes architecturally-defining volumetric and responsiveness characteristics of the system. The information presented may include: The number of key elements the system will have to handle such as the number of concurrent flights for an air traffic control system, the number of concurrent phone calls for a telecom switch, the number of concurrent online users for an airline reservation system, etc.
The key performance measures of the system, such as average response time for key events; average, maximum and minimum throughput rates, etc. The footprint in terms of disk and memory of the executables - essential if the system is an embedded system which must live within extremely confining constraints.
Most of these qualities are captured as requirements; they are presented here because they shape the architecture in significant ways and warrant special focus. For each requirement, discuss how the architecture supports this requirement.
In this section, list the key quality dimensions of the system that shape the architecture. The information presented may include: Operating performance requirements, such as mean-time between failure MTBF.
Quality targets, such as "no unscheduled down-time" Extensibility targets, such as "the software will be upgradeable while the system is running". Portability targets, such as hardware platforms, operating systems, languages. For each dimension, discuss how the architecture supports this requirement. You can organize the section by the different views logical, implementation, and so on , or by quality.
When particular characteristics are important in the system, for example, safety, security or privacy, the architectural support for these should be carefully delineated in this section. Architectural Goals and Constraints The architecture will be formed by considering: functional requirements, captured in the Use-Case Model, and non-functional requirements, captured in the Supplementary Specifications However, these are not the only influences that will shape the architecture: there will be constraints imposed by the environment in which the software must operate; by the need to reuse existing assets; by the imposition of various standards; by the need for compatibility with existing systems, and so on.
Evaluation criteria are also derived from Change Cases which document likely future changes to: the system's capabilities and properties the way the system is used the system's operating and support environments Change Cases clarify those properties of the system described by subjective phrases such as, "easy to extend", "easy to port", "easy to maintain", "robust in the face of change", and "quick to develop".
Change Cases try to predict changes: such predictions rarely turn out to be exactly true. Changes can arise from many sources, for example: Business drivers: new and modified business processes and goals Technology drivers: adaptation of the system to new platforms, integration with new components Changes in the profiles of the average user Changes in the integration needs with other systems Scope changes arising from the migration of functionality from external systems The Use-Case View The Use-Case View presents a subset of the Artifact: Use-Case Model , presenting the architecturally significant use-cases of the system.
Architecturally Significant Design Packages For each significant package, include a subsection with the following information Its name. Architecturally Significant Design Elements To assist in deciding what is architecturally significant, some examples of qualifying elements and their characteristics are presented: A model element that encapsulates a major abstraction of the problem domain, such as: A flight plan in an air-traffic control system.
An employee in a payroll system. A subscriber in a telephone system. A model element that is used by many other model elements.
Zach Miller. John Shea. Daniel IT. Previous Page. Next Page. Useful Video Courses. Software Engineering Basics 80 Lectures 7. More Detail. Previous Page Print Page.
Save Close. Defines the consistency and coherence of the overall design. This includes the way components or modules are designed. Defines the capability for components and subsystems to be suitable for use in other applications.
0コメント