Architecting Service-Oriented Systems
(August 2011) This report presents guidelines for architecting service-oriented systems and the effect of architectural principles on system quality attributes. (CMU/SEI-2011-TN-008)
Combining Architecture-Centric Engineering with the Team Software Process
(December 2010) ACE methods and the TSP provides an iterative approach for delivering high quality systems on time and within budget. The combined approach helps organizations that must set an architecture/developer team in motion using mature, disciplined engineering practices that produce quality software quickly. (CMU/SEI-2010-TR-031)
Realizing and Refining Architectural Tactics: Availability
(August 2009) Tactics are fundamental elements of software architecture that an architect employs to meet a system's quality requirements. This report describes an updated set of tactics that enable the architect to build availability into a system. (CMU/SEI-2009-TR-006)
(September 2007) This report describes how architectural tactics are based on the parameters of quality attribute models. (CMU/SEI-2007-TR-002)
Using ArchE in the Classroom: One Experience
(September 2007) The ArchE (Architecture Expert) tool serves as a software architecture design assistant. This report describes the use of a pre-alpha release of ArchE in a graduate-level software architecture class at Clemson University. (CMU/SEI-2007-TN-001)
Using Aspect-Oriented Programming to Enforce Architecture
(September 2007) This report illustrates how to use AOP (aspect-oriented programming) to ensure conformance to architectural design, proper use of design patterns and programming best practices, conformance to coding policies and naming conventions. (CMU/SEI-2007-TN-019)
A Practical Example of Applying Attribute-Driven Design (ADD), Version 2.0
(February 2007) This 2007 report describes an example application of the ADD method, an approach to defining a software architecture in which the design process is based on the quality attribute requirements the software must fulfill. (CMU/SEI-2007-TR-005)
Attribute-Driven Design (ADD), Version 2.0
(November 2006) This report revises the steps of the Attribute-Driven Design (ADD) method and offers practical guidelines for carrying out each step. (CMU/SEI-2006-TR-023)
Elements of a Usability Reasoning Framework
(September 2005) This note describes an ARL implementation of two usability scenarios: displaying progress feedback and allowing cancel. (CMU/SEI-2005-TN-030)
Discovering Architectures from Running Systems: Lessons Learned
(December 2004) This report describes a technique that uses automatically generated runtime observations of an executing system to construct an architectural view of the system. (CMU/SEI-2004-TR-016)
Security and Survivability Reasoning Frameworks and Architectural Design Tactics
(September 2004) The SEI approach to disciplined software architecture design includes a collection of quality attribute reasoning frameworks. This 2004 report is an initial attempt to use the same method for the related quality attributes of security and survivability. (CMU/SEI-2004-TN-022)
Integrating Software-Architecture-Centric Methods into the Rational Unified Process
(July 2004) This report presents a summary of the RUP (Rational Unified Process) and examines the potential uses of the SEI's architecture-centric methods. (CMU/SEI-2004-TR-011)
Preliminary Design of ArchE: A Software Architecture Design Assistant
(September 2003) This 2003 report presents a procedure for moving from a set of quality attribute scenarios to an architecture design that satisfies those scenarios. (CMU/SEI-2003-TR-021)
Deriving Architectural Tactics: A Step Toward Methodical Architectural Design
(March 2003) This 2003 technical report provides the status on the work being done by the SEI to understand the relationship between quality requirements and architectural design. (CMU/SEI-2003-TR-004)
Analyzing Enterprise JavaBeans Systems Using Quality Attribute Design Primitives
(October 2001) This report introduces the notion of quality attribute design primitives, which are architectural building blocks that target the achievement of one or sometimes several quality attribute requirements. (CMU/SEI-2001-TN-025)
Achieving Usability Through Software Architecture
(March 2001) This paper outlines an approach to improving the usability of software systems by means of software architectural decisions. (CMU/SEI-2001-TR-005)
Quality Attribute Design Primitives
(December 2000) This report addresses mechanisms that significantly affect quality attribute behavior and have sufficient content for analysis. (CMU/SEI-2000-TN-017)
Application of the Architecture-Based Design Method to the Electronic House, An
(October 2000) This report elaborates an example of the application of the ABD (Architecture-Based Design) method to designing software architecture. (CMU/SEI-2000-SR-009)
The Architecture Based Design Method
(January 2000) This paper presents the Architecture Based Design (ABD) method for designing the high-level software architecture for a product line or long-lived system. (CMU/SEI-2000-TR-001)
(June 1999) This report presents a description of architecture-centric system development. (CMU/SEI-1999-TR-007)
Len Bass, Mark Klein, Felix Bachmann
This paper discusses the understanding of quality attributes and their application to the design of a software architecture. We present an approach to characterizing quality attributes and capturing architectural patterns that are used to achieve these attributes. For each pattern, it is important not only how the pattern achieves a quality attribute goal but also what impact the pattern has on other attributes. We embody this investigation of quality into the Attribute Driven Design Method for designing software architecture.
Tool Support for Architecture Analysis and Design
The needs of software architectural design and analysis have led to a desire to create CASE tools to support the processes. Such a tool should help: to document an architecture; to reuse architectural artifacts; to aid in exploring architectural alternatives; and to support architectural metrics. This position paper first presents a set of requirements that an ideal tool for architectural design and analysis, and then presents a tool—called SAAM tool—that meets most, but not all, of these requirements. SAAM tool embodies both SAAM (Software Architecture Analysis Method) and an architectural description framework which describes architectural elements according to their static and temporal features. The tool serves several purposes. It supports and documents the results of architectural design and analysis efforts at varying degrees of resolution, it acts as a repository of both designs and design rationales in the form of scenarios, it applies metrics to architectures, and it visualizes architectures with respect to architectural metrics.
Understanding Architectural Influences and Decisions in Large-System Projects
Why does a system exhibit the architecture that it does? What influences affected the architectural decisions made by its designer(s)? We hypothesize that these influences flow from the system’s requirements, the organization’s culture and goals, and the designers’ experience and background. We posit that the influences are at least partially enumerable, as are the architectural decisions that they precipitate. This paper discusses the approach taken in a pilot study to uncover the correlation, if any, between architectural influences and architectural decisions in large-scale, software-intensive development projects.
From Domain Models to Architectures
This presentation was given at the Workshop on Software Architecture, USC Center for Software Engineering, Los Angeles, 1994, by Paul Clements.
Kurt Wallnau, Scott Hissam, Robert Seacord
This book describes specific engineering practices needed to integrate preexisting components with preexisting specifications successfully, illustrating the techniques described with case studies and examples.
Paul Clements, Bob Krut, Ed Morris, Kurt Wallnau
Technology to support system comprehension tends to reflect either a “bottom-up” or “top-down” approach. Bottom- up approaches attempt to derive system models from source code, while top-down approaches attempt to map abstract “domain” concepts to concrete system artifacts. While both approaches have merit in theory, in practice the top-down approach has not yielded scalable, cost-effective technology. One problem with the top-down approach is that it is very expensive to develop domain models, and it is difficult to develop models that are sufficiently general to be applied to multiple systems (and hence amortize the development cost). This paper describes the Gadfly, an approach for developing narrowly-focused, reusable domain models that can be integrated and (re)used to aid in the process of top-down system comprehension.
For more information
Please tell us what you
think with this short
(< 5 minute) survey.