Software Architecture

Fields of Study

Applications; Software Engineering; Operating Systems

Abstract

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.

Challenges of Software Architecture

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.

Methodology

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 architecture projects can involve weeks, months, or even years of development. Software architects often develop a basic skeletal system early in the development process. While this early system lacks the depth and reach of the desired program, it provides critical insights into the system's developing functionality. Incremental modifications are then made and tested to ensure that the emerging system is performing properly. Multiple iterations of the system are made until full functionality is achieved. This approach is known as agile software development.

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.

Implications

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.

Bibliography

Bass, Len, Paul Clements, and Rick Kazman. Software Architecture in Practice. 3rd ed. Upper Saddle River: Addison, 2012. Print.

Cervantes, Humberto, and Rick Kazman. Designing Software Architectures: A Practical Approach. Upper Saddle River: Addison, 2016. Print.

Clements, Paul, et al. Documenting Software Architectures: Views and Beyond. 2nd ed. Upper Saddle River: Addison, 2011. Print.

Langer, Arthur M. Guide to Software Development: Designing and Managing the Life Cycle. New York: Springer, 2012. Print.

Mitra, Tilak. Practical Software Architecture: Moving from System Context to Deployment. Indianapolis: IBM, 2015. Print.

Rozanski, Nick, and Eoin Woods. Software Systems Architecture: Working with Stakeholders Using Viewpoints and Perspectives. 2nd ed. Upper Saddle River: Addison, 2012. Print.

Sonmez, John Z. Soft Skills: The Software Developer's Life Manual. Shelter Island: Manning, 2015. Print.

Taylor, Richard N., Nenad Medvidović, and Eric M. Dashofy. Software Architecture: Foundations, Theory, and Practice. Hoboken: Wiley, 2010. Print