Software Architecture

Applications; Software Engineering; Operating Systems

Software architecture refers to the specific set of decisions that software engineers make to organize the complex structure of a computer system under development. Sound software architecture helps minimize the risk of the system faltering as well as optimizing its performance, durability, and reliability.

Building architects deal with static structures that maintain their structural integrity over the long term. In contrast, the architecture of a computer program must be able to change, grow, and be modified. “Software architecture” refers to the internal operations of a system under development and how its elements will ultimately function together. It is a blueprint that helps software engineers avoid and troubleshoot potential problems. These problems are far easier to address while the system is in development rather than after it is operational.

Software architects examine how a system's functional requirements and nonfunctional requirements relate to each other. Functional requirements control what processes a system is able to perform. Nonfunctional requirements control the overall operation of a program rather than specific behaviors. They include performance metrics such as manageability, security, reliability, maintainability, usability, adaptability, and resilience. Nonfunctional requirements place constraints on the system's functional requirements.

The main challenge for the software architect is to determine which requirements should be optimized. If a client looking for a new software program is asked what requirements are most critical—usability, performance, or security, for instance—they are most likely going to say all of them. Because this cannot be done without exorbitant costs, the software architect prioritizes the list of requirements, knowing that there must be trade-offs in the design of any application. If, for instance, the project is a long-term home-loan application program or a website for purchasing airplane tickets, the architect will most likely focus on security and modification. If the project is short term, such as a seasonal marketing campaign or a website for a political campaign, the architect will focus instead on usability and performance.

Software architecture design is an early-stage Abstract process that allows for the testing of an assortment of scenarios in order to maximize the functionality of a system's most critical elements. Well-planned software architecture helps developers ascertain how the system will operate and how best to minimize potential risks or system failures. In most cases, software architecture factors in modifiability, allowing the system to grow over time to prevent obsolescence and anticipate future user needs.

Software architects work to understand how the system will ultimately operate to meet its performance requirements. Programs should be designed to be flexible enough to grow into more sophisticated and more specialized operations. Plug-ins can be used to add features to existing systems. By designing software functions as discrete elements, software architects can make the system easier to adapt. This design principle is known as separation of concerns. It allows one element of the program to be upgraded without dismantling the entire superstructure, for example. This has the potential to save considerable time and money. Component-based development is a related idea that borrows from the industrial assembly-line model. It involves using and reusing standardized software components across different programs.

Software architecture aims to balance the end user's needs with the system's behavioral infrastructure and the expectations of the company that will support the software. Software architects start the development process by looking at the broadest possible implications of a proposed system's elements and their relationships to one another. This distinguishes them from code developers, whose vision is often relatively narrow and specified. Software architects evaluate the critical needs of the software, consider the needs of both the client and the end user, and draft system blueprints that maximize those requirements while managing the practical concerns of time and cost.

—Joseph Dewey