Software architecture critics in the Argo design environment

Software architecture is one promising approach to the development of large software systems [21][29][36][38]. Software architectures are high-level design representations of software systems that focus on composition of software components and how those components interact. Software architecture deals with software components, operating system resources, and source code modules. Software architecture relationships deal with communication between components, allocation of operating system resources to components, and dependencies between source code modules and conceptual components. Ideally, off-the-shelf components are reused, but in practice some components must be customized or developed from scratch [22]. Software architects customize these components by specifying interfaces and choosing values for parameters such as memory allocations, operating system process priorities, and buffer lengths. This component-based approach to development relies on notations that abstract the details of implementation and allow the architect to focus on essential design decisions. Decision making is an essential activity performed by software architects in designing software systems. The resulting design must satisfy the requirements and not violate constraints imposed by the problem domain and implementation technologies. Requirements are typically stated in terms of needed functionality, limitations on resource use, and non-functional requirements such as extensibility, portability, or scalability. In addition to hard constraints and requirements on the design, there are numerous soft constraints, or rules of thumb, that address qualities of the system that are desirable but not strictly required. Often there are several desirable qualities that conflict with each other or that cannot be precisely measured. Even after all constraints are taken into account, the architect has a very large and poorly structured space of possible designs to explore. Software architects base design decisions on knowledge of available software components and resources and their characteristics. For example, in architecting a web page editing tool, one spell-checking component may be fast but difficult to extend to handle HTML syntax, while another might be more flexible but require a run-time licensing fee. The alternative of developing a new spelling component demands time, budget, and specific technical skills. Architects also need to take into account industry and organizational standards and estimate whether their designs will be understandable and maintainable. Architects acquire the diverse knowledge they need from a variety of sources, both technical and organizational. In sum, software architectures evolve incrementally as the result of many interrelated design decisions potentially made over extended periods of time. We envision software architecture design as a situated design process in which architects explore paths through a space of alternatives [40]. Particular software architectures can be thought of as a product of one of these paths. Decisions at any point can critically affect Software Architecture Critics in the Argo Design Environment