Paulo Canelas,
Bradley Schmerl, Alcides Fonesca and Christopher Steven Timperley. How does ROS-based Robot Software Evolve? An Empirical Study on Architectural Evolution. In Proc. the 20th European Conference on Software Architecture (ECSA 2026), Bolzano, Italy. September 7-11, 2026.
https://doi.org/10.7551/mitpress/2705.003.0004.
To Appear.
Abstract: The Robot Operating System (ROS) is the de facto framework for building open-source robotic software systems. Developers architect their system by using reusable components, connecting them via config- uration files and source code. These architectures evolve as developers add, remove, and modify components, connections, and configurations. These changes can lead to architectural misconfigurations detectable by specification languages and analysis tools. However, these focus on snapshots in time without considering how architectures evolve. By un- derstanding this evolution, we can help specification writers estimate the maintenance burden of their descriptions and promote tools toward the most change-prone elements. To that end, we conduct an empirical study of architectural evolution in open-source ROS systems. We develop a differential, cross-language architectural recovery tool that extracts components, connections, and configurations from source code and apply it to 294 repositories, with 1728 packages across 9914 releases, spanning ROS 1 and ROS 2 in C/C++, Python, and XML. As ROS repositories aggregate multiple packages at different maturity stages, we analyze evolution at the repository and package levels. We find that evolution di- verges across levels, with repositories remaining addition-dominant while mature packages consolidate by removing connections and configurations. Furthermore, changes co-occur across elements: component removals are associated with the removal of their connections and configurations.
Paulo Canelas,
Bradley Schmerl, Alcides Fonesca and Christopher Steven Timperley. ROSpec: A Domain-Specific Language for ROS-based Robot Software. In Proc. ACM Programming Languages 9, OOPSLA2, Singapore. p. 29. October 12-18, 2025.
https://doi.org/10.1145/3763169.
Abstract: Component-based robot software frameworks, such as the Robot Operating System (ROS), allow developers to quickly compose and execute systems by focusing on configuring and integrating reusable, off-the-shelf components. However, these components often lack documentation on how to configure and integrate them correctly. Even when documentation exists, its natural language specifications are not enforced, resulting in misconfigurations that lead to unpredictable and potentially dangerous robot behaviors. In this work, we introduce ROSpec, a ROS-tailored domain-specific language designed to specify and verify component configurations and their integration. ROSpecβs design is grounded in ROS domain concepts and informed by a prior empirical study on misconfigurations, allowing the language to provide a usable and expressive way of specifying and detecting misconfigurations. At a high level, ROSpec verifies the correctness of argument and component configurations, ensures the correct integration of components by checking their communication properties, and checks if configurations respect the assumptions and constraints of their deployment context. We demonstrate ROSpecβs ability to specify and verify components by modeling a medium-sized warehouse robot with 19 components, and by manually analyzing, categorizing, and implementing partial specifications for components from a dataset of 182 misconfiguration questions extracted from a robotics Q&A platform.
π
Andres Diaz-Pace, Catia Trubani and
David Garlan. Data-driven Understanding of Design Decisions in Pattern-based Microservices Architecture. In Proceedings of the 19th European Conference on Software Architecture (ECSA), Limassol, Cyprus. September 15-19, 2025.
https://doi.org/10.1007/978-3-032-02138-0_18.
Best Paper Award.
Abstract: The adoption of architectural patterns has recently been assessed in relation to their impact on the performance of microservice-based applications. For example, offloading common functionalities of
multiple microservices to a gateway may lead to a system response time
improvement. However, for a given system requirement, e.g., the latency
of services or the utilization of resources, the benefit of choosing an architectural pattern is not guaranteed. Therefore, it becomes important
to collect data about the parameters that contribute to the effective use
of patterns, thus understanding the relationships between design decisions and performance requirements. In this work, we propose a data-driven approach to assess the quantitative impact of design decisions
for a given pattern on the achievement of performance tradeoffs. Our
approach seeks to control the pattern parameters that cause variations,
i.e., sensitivity, in performance tradeoffs. Starting from a dataset including parameters related to three microservices patterns (i.e., Gateway
Offloading, Command and Query Responsibility Segregation, and Anticorruption Layer) and their performance characteristics, we do apply
machine learning techniques (i.e., PRIM and CART) to infer constraints
on the parameter values. This is helpful to understand and reduce the
performance sensitivity of pattern configurations. Our results support
software architects in making informed decisions by providing insights
on the parameters related to the behavior of microservices patterns.
Paulo Canelas,
Bradley Schmerl, Alcides Fonesca and Christopher Steven Timperley. The Usability Argument for ROS-based Robot Architectural Description Languages. In Proc. the 15th annual workshop on the intersection of HCI and PL. February 17-18, 2025.
Abstract: Component-based architectures in robotics, like the Robot Operating System (ROS), simplify system development by integrating reusable, off-the-shelf components. However, these components often lack sufficient documentation on their use and the architectures they form, leading to architectural misconfigurations. General-purpose Architectural Description Languages (ADLs) effectively provide properties to detect misconfigurations but are burdensome to use, as they require mapping new language-specific concepts to the ROS domain. This work introduces rospec, a novel ADL embedding ROS-specific knowledge to help developers specify and detect architectural misconfigurations. By mapping the language's syntax with ROS concepts, we argue that practitioners can more easily understand and reason about specifications written in the language. We provide an example and compare it with a general-purpose ADL.
Abstract: Robotics systems are complex, safety-critical systems that can con- sist of hundreds of software components that interact with each other dynamically during run time. Software components of robot- ics systems often exhibit reactive, periodic, and state-dependent behavior. Incorrect component composition can lead to unexpected behavior, such as components passively waiting for initiation mes- sages that never arrive. Model-based software analysis is a common technique to identify incorrect behavioral composition by checking desired properties of given behavioral models that are based on component state machines. However, writing state machine models for hundreds of software components manually is a labor-intensive process. This motivates work on automated model inference. In this paper, we present an approach to infer behavioral models for systems based on the Robot Operating System (ROS) using static analysis by exploiting assumptions about the usage of the ROS API and ecosystem. Our approach is based on searching for common behavioral patterns that ROS developers use for implementing reac- tive, periodic, and state-dependent behavior using the ROS frame- work API. We evaluate our approach and our tool ROSInfer on five complex real-world ROS systems with a total of 534 components. For this purpose we manually created 155 models of components from the source code to be used as a ground truth and available data set for other researchers. ROSInfer can infer causal triggers for 87 % of component architectural behaviors in the 534 components.
Abstract: Over the past decade, a number of automated techniques
and tools have been developed for optimizing architectural
designs with respect to quality-attribute goals. In these systems,
the optimization process is typically seen as a black box, since it
is not possible for a human to have access to the decisions that led
to a particular solution generated by an optimization tool. Even
when these decisions are available for inspection, the amount of
information can be overwhelming for the architect. As a result,
humans might not completely understand the rationale behind
a given solution or trust that a tool made correct decisions. To
mitigate this problem, we propose a semi-automated approach
for generating textual explanations for any architectural solution
produced by a tool. This kind of explanation provides a summary
of the key architectural tactics that were applied to achieve an
optimized architecture that satisfies a set of quality-attribute objectives.
In this paper, we discuss two procedures for determining
the key tactics to be explained. As an initial experiment, we used a
popular optimization tool to generate solutions and explanations
for a small but non-trivial design space involving performance,
reliability, and cost objectives. We also performed an exploratory
user study to assess the effectiveness of these explanations.
Abstract: Robot systems are growing in importance and complexity. Ecosystems for robot software, such as the ROS, provide libraries of reusable software components that can be configured and composed into larger systems. To support compositionality, ROS uses late binding and architecture configuration via "launch files" that describe how to initialize the components in a system.
However, late binding often leads to systems failing silently due to misconfiguration, for example by misrouting or dropping messages entirely.
In this paper we present ROSDiscover, which statically recovers the run-time architecture of ROS systems to find such architecture misconfiguration bugs. First, ROSDiscover constructs component level architectural models (ports, parameters) from source code. Second, architecture configuration files are analyzed to compose the system from these component models and derive the connections in the system. Finally, the reconstructed architecture is checked against architectural rules described in first-order logic to identify potential misconfigurations.
We present an evaluation of ROSDiscover on real world, off-the-shelf robotic systems, measuring the accuracy, effectiveness, and practicality of our approach. To that end, we collected the first data set of architecture configuration bugs in ROS from popular open-source systems and measure how effective our approach is for detecting configuration bugs in that set.
Abstract: Self-adaptive systems increasingly need to reason about and adapt both structural and behavioral system aspects, such as in mobile service robots, which must reason about missions that they need to achieve and the architecture of the software executing them. Deciding how to best adapt these systems to run time changes is challenging because it entails considering mutual dependencies between the software architecture that the system is running and the outcome of plans for completing tasks, while also considering multiple trade-offs and uncertainties. Considering all these aspects in planning for adaptation often yields large solution spaces which cannot be adequately explored at run time.
We address this challenge by proposing a planning approach able to consider the impact of mutual dependencies between software architecture and task planning on the satisfaction of mission goals. The approach is able to reason quantitatively about the outcome of adaptation decisions handling both the reconfiguration of the system's architecture and adaptation of task plans under uncertainty and in a rich trade-off space.
Our results show: (i) feasibility of run-time decision-making for self-adaptation in an otherwise intractable solution space by dividing-and-conquering adaptation into architecture reconfiguration and task planning sub-problems, and (ii) improved quality of adaptation decisions with respect to decision making that does not consider dependencies between architecture and task planning.
Ivano Malavolta, Grace A. Lewis,
Bradley Schmerl, Patricia Lago and
David Garlan. How do you Architect your Robots? State of the Practice and Guidelines for ROS-based System. In Proceedings of the 42nd International Conference on Software Engineering: Software Engineering in Practice. May 23-29, 2020.
https://doi.org/10.1145/3377813.3381358.
Abstract: The Robot Operating System (ROS) is the de-facto standard for robotic software.
If on one hand ROS is helping roboticists, e.g., by providing a standardized communication platform, on the other hand ROS-based systems are getting larger and more complex and could benefit from good software architecture practices.
This paper presents an observational study aimed at (i) unveiling the state of the practice for architecture of ROS-based systems and (ii) providing guidance to roboticists about how to properly architect ROS-based systems. To achieve these goals, we (i) build a dataset of 335 GitHub repositories containing real open-source ROS-based systems, (ii) mine the repositories for extracting the state of the practice about how roboticists are architecting them, and (iii) synthesize a catalog of 49 evidence-based guidelines for architecting ROS-based systems.
The guidelines have been validated by 77 roboticists working on real-world open-source ROS-based systems.
Abstract: Microservice application developers try to mitigate
the impact of partial outages typically by implementing
service-to-service interactions that use well-known resiliency
patterns, such as Retry, Fail Fast, and Circuit Breaker. However,
those resiliency patternsΓ’β¬βas well as their available open-source
implementationsΓ’β¬βare often documented informally, leaving it up
to application developers to figure out when and how to use those
patterns in the context of a particular microservice application.
In this paper, we take a first step towards improving on this
situation by introducing a model checking-based approach in
which we use the PRISM probabilistic model checker to analyze
the behavior of the Retry and Circuit Breaker resiliency patterns
as continuous-time Markov chains (CTMC). This approach has
enabled us to quantify the impact of applying each resiliency
pattern on multiple quality attributes, as well as to determine
how to best tune their parameters to deal with varying service
availability conditions, in the context of a simple client-service
interaction scenario.
Abstract: Implementing a solution for a design decision that
precisely satisfies the trade-off between quality attributes can be
extremely challenging. Further, typically quality attribute tradeoffs
are not represented as first-class entities in development
artifacts. Hence, decisions might be suboptimal and lack requirements
traceability as well as changeability. We propose Tradeoff-
oriented Development (ToD), a new concept to automate
the selection and integration of reusable implementations for
a given design decision based on quality attribute trade-offs.
Implementations that vary in quality attributes and that solve
reoccurring design decisions are collected in a design decision
library. Developers declaratively specify the quality attribute
trade-off, which is then used to automatically select the best
fitting implementation. We argue that thereby, software could
satisfy the trade-offs more precisely, requirements are traceable
and changeable, and advances in implementations automatically
improve existing software.
π
Abstract: Designing software in a way that provides guarantees about run-time behavior while achieving an acceptable balance between multiple extra-functional properties is still an open problem. Tools and techniques to inform engineers about poorly-understood design spaces are needed. To tackle this problem, we propose an approach that combines synthesis of spaces of system design alternatives from formal specifications of architectural styles with quantitative verification applied to every point of the generated solution space. The main contribution of this paper is a formal framework for specification-driven synthesis and analysis of design spaces that provides formal guarantees about the correctness of system behaviors and satisfies quantitative properties (e.g., defined over system qualities). We illustrate our proposal by analyzing the configuration space of a Tele Assistance System (TAS) using a prototype implementation of our approach.
Abstract: In an organization, the interactions users have with software leaves patterns or traces of the parts of the systems accessed. These interactions can be associated with the underlying software architecture. The first step in detecting problems like insider threat is to detect those traces that are anomalous.
In this paper, we present a method to find anomalous users leveraging these interaction traces, categorized by user roles. We propose a model based approach to cluster user sequences and find outliers. Such a technique could be useful in finding potentially anomalous users, insiders, or compromised accounts.We show that the approach works on a simulation of a large scale system based on and Amazon Web application style.
Abstract: Recent research in embedded and cyber-physical
systems has developed theories and tools for integration of
heterogeneous components and models. These efforts, although
important, are insufficient for high-quality and error-free systems
integration since inconsistencies between system elements may
stem from factors not directly represented in models (e.g.,
analysis tools and expert disagreements). Therefore, we need to
broaden our perspective on integration, and devise approaches
in three novel directions of integration: modeling methods, data
sets, and humans. This paper summarizes the latest advances, and
discusses those directions and associated challenges in integration
for cyber-physical systems.
Abstract: Computations are pervasive across many domains, where end users have to compose various heterogeneous computational entities to perform professional activities. Service-Oriented Architecture (SOA) is a widely used mechanism that can support such forms of compositions as it allows heterogeneous systems to be wrapped as services that can then be combined with each other. However, current SOA orchestration languages require writing scripts that are typically too low-level for end users to write, being targeted at professional programmers and business analysts. To address this problem, this paper proposes an approach based on an architectural-style for service orchestration using an end user specification style called SCORE. SCORE uses high-level constructs that can be tailored for different domains and automatically translated into executable constructs by tool support. We demonstrate the usefulness of SCORE across two domains β dynamic network analysis and neuroscience, where users are intelligence analysts and scientists respectively. They can use an architectural style based vocabulary as a basis of their domain-specific
Abstract: In this paper, we argue that the reality of today's software systems requires us to consider uncertainty as a first-class concern in the design, implementation, and deployment of those systems. We further argue that this induces a paradigm shift, and a number of research challenges that must be addressed.
Abstract: One common approach to self-adaptive systems is to incorporate a control layer that monitors a system, supervisorily detects problems, and applies adaptation strategies to fix problems or improve system behavior. While such approaches have been found to be quite effective, they are typically limited to carrying out a single adaptation at a time, delaying other adaptations until the current one finishes. This in turn leads to a problem in which a time-critical adaptation may have to wait for an existing long-running adaptation to complete, thereby missing a window of opportunity for that adaptation. In this paper we improve on existing practice through an approach in which adaptations can be preempted to allow for other time-critical adaptations to be scheduled. Scheduling is based on an algorithm that maximizes time-related utility for a set of concurrently executing adaptations.
David Garlan, Kathleen M. Carley,
Bradley Schmerl, Michael W. Bigrigg and
Orieta Celiku. Using Service-Oriented Architectures for Socio-Cultural Analysis. In Proceedings of the 21st International Conference on Software Engineering and Knowledge Engineering (SEKE2009), Boston, USA. July 1-3, 2009.
Abstract: An emergent domain that raises some unique engineering challenges is that of software architectures to convert large bodies of unstructured data to human-usable knowledge, such as in the domain of socio-cultural information analysis. We report on an architecture based on Service-Oriented Architectures that we are applying in this domain. We list the requirements that such an architecture must support, describe our architecture for addressing them, and outline what we believe are the important engineering and research issues that must still be overcome.
Abstract: Notations and techniques for architectural modeling and analysis have matured considerably over the past two decades. However, to date these approaches have primarily focused on architectural properties and behavior that can be precisely defined. In this paper we argue that it is possible to augment existing architecture description languages (ADLs) to support reasoning and analysis in the presence of uncertainty. Specifically, we outline two basic extensions to formal architecture descriptions that take advantage of probabilistic specifications to support architecture-based analyses such as simulation, detection of behavioral drift, and reasoning about the expected outcomes of uncertain behavior. An important property of these specifications is that they allow incremental refinement Γ―ΒΏΒ½ as more is known about the behavior of the system, specifications can be extended without invalidating previous analyses.
Thomas LaToza,
David Garlan, James Herbsleb and Brad Myers. Program Comprehension as Fact Finding. In Proceedings of the 6th Joint Meeting of the European Software Engineering Conference and the ACM SIGSOFT Symposium on the Foundations of Software Engineering (ESEC/FSE 2007), Dubrovnik, Croatia. pp. 361-370. September 3-7, 2007. Available from the ACM Digital Library:
http://doi.acm.org/10.1145/1287624.1287675.
Abstract: Little is known about how developers think about design during
code modification tasks or how experienced developersβ design
knowledge helps them work more effectively. We performed a lab
study in which thirteen developers worked for 3 hours understanding
the design of a 54 KLOC open source application. Participants
had from 0 to 10.5 years of industry experience and were
grouped into three βexpertsβ and ten βnovices.β We observed that
participants spent their time seeking, learning, critiquing, explaining,
proposing, and implementing facts about the code such as
βgetFoldLevel has effectsβ. These facts served numerous roles,
such as suggesting changes, constraining changes, and predicting
the amount of additional investigation necessary to make a
change. Differences between experts and novices included that
the experts explained the root cause of the design problem and
made changes to address it, while novice changes addressed only
the symptoms. Experts did not read more methods but also did not
visit some methods novices wasted time understanding. Experts
talked about code in terms of abstractions such as βcachingβ while
novices more often described code statement by statement. Experts
were able to implement a change faster than novices. Experts
perceived problems novices did not and were able to explain
facts novices could not. These findings have interesting implications
for future tools.
George Fairbanks, Kevin Bierhoff and Desmond D'Souza. Software Architecture at a Large Financial Firm. In Proceedings of ACM SIGPLAN Conference on Object Oriented Programs, Systems, Languages, and Applications (OOPSLA) 2006, Portland, OR, USA. October 22-27, 2006.
https://doi.org/10.1145/1176617.1176729.
Abstract: System builders have historically used informal software architecture models to understand options, make choices, and communicate with others. Research into software architecture over the past fifteen years has indicated that more precise architecture models may be beneficial. At a large financial firm, we applied precise software architecture techniques on four software projects and this experience has revealed a number of practical issues. We made the following observations across the projects: 1) Architecture models can be used to bridge gaps between business requirements and technology, 2) A small collection of techniques and a detail knob are practical and useful in a variety of projects, 3) Architecture modeling techniques amplify the skills of the architects, 4) A model of domain concepts and relationships is helpful when building architecture models, and 5) It is difficult to know when to stop adding detail to your architecture model. We believe that these observations motivate future research and can help practitioners make software architecture more effective in practice.
Abstract: The backbone of many architectures is an architectural style that provides a domain-specific design vocabulary and set of constraints on how that vocabulary can be used. Hence, designing a sound and appropriate architectural style becomes an important and intellectually challenging activity. Unfortunately, although there are numerous tools to help in the analysis of individual architectures, relatively less work has been done on tools to help the style designer. In this paper we show how to map an architectural style, expressed formally in an architectural description language, into a relational model that can be automatically checked for properties such as whether a style is consistent, whether a style satisfies some predicate over the architectural structure, whether two styles are compatible for composition, and whether one style refines another.
David Garlan and
Bradley Schmerl. An Architecture for Personal Cognitive Assistance. In 18th International Conference on Software Engineering and Knowledge Engineering, San Francisco Bay, USA. July 5-7, 2006.
Abstract: Current desktop environments provide weak support for carrying out complex user-oriented tasks. Although individual applications are becoming increasingly sophisticated and featurerich, users must map their high-level goals to the low-level operational vocabulary of applications, and deal with a myriad of routine tasks (such as keeping up with email, keeping calendars and web sites up-to-date, etc.). An alternative vision is that of a personal cognitive assistant. Like a good secretary, such an assistant would help users accomplish their high-level goals, coordinating the use of multiple applications, automatically handling routine tasks, and, most importantly, adapting to the individual needs of a user over time. In this paper we describe the architecture and its implementation for a personal cognitive assistant called RADAR. Key features include (a) extensibility through the use of a plug-in agent architecture (b) transparent integration with legacy applications and data of today?s desktop environments, and (c) extensive use of learning so that the environment adapts to the individual user over time.
David Garlan and
Bradley Schmerl. Architecture-driven Modelling and Analysis. In Proceedings of the 11th Australian Workshop on Safety Related Programmable Systems (SCS'06), Tony Cant (Ed.), Melbourne, Australia. Conferences in Research and Practice in Information Technology, Vol. 69. 2006.
Abstract: Over the past 15 years there has been increasing recognition that careful attention to the design of a systemοΏ½s software architecture is critical to satisfying its requirements for quality attributes such as performance, security, and dependability. As a consequence, during this period the field of software architecture has matured significantly. However, current practices of software architecture rely on relatively informal methods, limiting the potential for fully exploiting architectural designs to gain insight and improve the quality of the resulting system. In this paper we draw from a variety of research results to illustrate how formal approaches to software architecture can lead to enhancements in software quality, including improved clarity of design, support for analysis, and assurance that implementations conform to their intended architecture.
Abstract: Developing dependable software systems requires enforcing conformance between architecture and implementation during software development and evolution. We address this problem with a multi-pronged approach: (a) automated refinement of a component-and-connector (C&C) architectural view into an initial implementation, (b) enforcement of architectural structure at the programming language level, (c) automated abstraction of a C&C view from an implementation, and (d) semi-automated incremental synchronization between the architectural and the implementation C&C views.
We use an Architecture Description Language (ADL), Acme, to describe the architecture, and ArchJava, an implementation language which embeds a C&C architecture specification within Java implementation code. Although both Acme and ArchJava specify C&C views, a number of structural differences may arise. Our approach can detect structural differences which correspond directly to implementation-level violations of the well thoughtout architectural intent. Furthermore, supplementing the C&C view extracted from the implementation with architectural types and styles can uncover additional violations.
Marwan Abi-Antoun, Jonathan Aldrich,
David Garlan,
Bradley Schmerl, Nagi Nahas and Tony Tseng. Software Architecture with Acme and ArchJava (Research Demonstration). In Proceedings of the 27th International Conference on Software Engineering, St. Louis, MS. May, 2005.
Abstract: We demonstrate a tool to incrementally synchronize an Acme architectural model described in the Acme Architectural Description Language (ADL) with an implementation in ArchJava, an extension of the Java programming language that includes explicit architectural modeling constructs.
David Garlan, William K. Reinholtz,
Bradley Schmerl,
Nicholas Sherman and Tony Tseng. Bridging the Gap between Systems Design and Space Systems Software. In Proceedings of the 29th Annual IEEE/NASA Software Engineering Workshop (SEW-29), Greenbelt, MD. April 6-7, 2005.
Abstract: A challenging problem for software engineering practitioners is moving from high-level system architectures produced by system engineers to deployable software produced by software engineers. In this paper we describe our experience working with NASA engineers to develop an approach and toolset for automating the generation of space systems software from architectural specifications. Our experience shows that it is possible to leverage the space systems domain, formal architectural specifications, and component technology to provide retargetable code generators for this class of software.
Abstract: Over the past decade a number of architecture description languages (ADLs) have been proposed to facilitate modeling and analysis of software architecture. While each claims to have various benefits, to date there have been few studies to assess the relative merits of these approaches. In this paper we describe our experience using two ADLs to model a system initially described in UML, and compare their effectiveness in identifying system design flaws. We also describe the techniques we used for extracting architectural models from a UML system description.
Abstract: Software architectural modeling is crucial to the development of high-quality software. Software engineering tool support is required for this activity, so that models can be developed, viewed, analyzed, and refined to implementations. This support needs to be provided in a flexible and extensible manner so that the tools can fit into a company s process and can use particular, perhaps company-defined, domain-specific architectural styles. Early architecture development environments were restricted to supporting particular architectural styles, and were not easy to tailor to other styles or domains. In this research demonstration, we describe AcmeStudio, a styleneutral architecture development environment that can (1) allow architects to tailor the environment for particular domains; (2) be used as a framework for integrating domain-specific architectural analyses; and (3) can be extended to integrate with other tools that are used in a company s software development process. We illustrate the main features of AcmeStudio and provide some insight into how we have tailored it to real-world domains specific to NASA and Ford Motor Company.
Abstract: One of the challenging problems for software developers is guaranteeing that a system as built is consistent with its architectural design. In this paper we describe a technique that uses run time observations about an executing system to construct an architectural view of the system. With this technique we develop mappings that exploit regularities in system implementation and architectural style. These mappings describe how low-level system events can be interpreted as more abstract architectural operations. We describe the current implementation of a tool that uses these mappings, and show that it can highlight inconsistencies between implementation and architecture.
Kevin Steppe,
David Garlan, Greg Bylenok,
Bradley Schmerl and Nataliya Shevchenko. Tool Support for Model Based Architectural Design for Automotive Control Systems. In First European Workshop on Model Driven Architecture with Emphasis on Industrial Application, Enschede, The Netherlands. March 17-19, 2004.
Abstract: In conjunction with Ford Motor Company, we built a tool to support multilevel architectural design. The tool, called Synergy, allows Ford to visually design architectures of vehicle control components. The components are imported from existing Simulink models; then the tool automatically generates a detailed view showing all required connections and ports. The resulting model is exported to Simulink for further analysis. In this paper we describe the conceptual and technical challenges encountered in building Synergy and our design choices for solving them.
Kevin Steppe, Greg Bylenok,
David Garlan,
Bradley Schmerl, Kanat Abirov and Nataliya Shevchenko. Two-tiered Architectural Design for Automotive Control Systems: An Experience Report. In Automotive Software Workshop on Future Generation Software Architectures in the Automotive Domain, San Diego, CA. January 10-12, 2004. (
Workshop Proceedings).
Abstract: An attractive approach to architecture-based design is to structure the development process into two tiers. The top tier represents the abstract design (or architecture) of a system in terms of abstract components. The bottom tier refines that design by making specific implementation decisions, such as platform, middleware, and component implementations. While attractive in principle, there has been relatively little industrial-based experience to shed light on problems and solutions involved in such an approach. In this paper we describe our experience in developing tools to introduce a two-tiered model-based approach to the design of Ford Motor Company s automotive control systems, highlighting the principle challenges, and evaluating the effectiveness of our solutions for them.
Abstract: A large financial company, struggling with legacy systems that did not interoperate, performed a pilot project to teach software architecture to an enthusiastic application development team. Experienced mentors, including the author, worked with the application team for seven months who completed their engineering goal successfully. However, the mentors were unsuccessful in their attempt to train any of the six members of application team to create architecture models on their own, though they were able to create them collaboratively with the mentors. This surprising result is due to the application team's strong preference for concrete artifacts over abstract ones. Even more surprising, an application developer from a different project, 'Developer X', read the architecture modeling documentation on an internal website and, without mentoring, created good architecture models within a few days. In light of this failure to teach software architecture, two short-term strategies are suggested for the use of software architecture in companies and long-term strategies are discussed.
Abstract: Increasingly systems are composed of parts: software components, and the interaction mechanisms (connectors) that enable them to communicate. When assembling systems from independently developed and potentially mismatched parts, wrappers may be used to overcome mismatch as well as to remedy extra-functional deficiencies. Unfortunately the current practice of wrapper creation and use is ad hoc, resulting in artifacts that are often hard to reuse or compose, and whose impact is difficult to analyze. What is needed is a more principled basis for creating, understanding, and applying wrappers. Focusing on the class of connector wrappers (wrappers that address issues related to communication and compatibility), we present a means of characterizing connector wrappers as protocol transformations, modularizing them, and reasoning about their properties. Examples are drawn from commonly practiced dependability enhancing techniques.
Abstract: Traditional mechanisms that allow a system to detect and recover from errors are typically wired into applications at the level of code where they are hard to change, reuse, or analyze. An alterna-tive approach is to use externalized adaptation: one or more mod-els of a system are maintained at run time and external to the ap-plication as a basis for identifying problems and resolving them. In this paper we provide an overview of recent research in which we use architectural models as the basis for such problem diagno-sis and repair. These models can be specialized to the particular style of the system, the quality of interest, and the dimensions of run time adaptation that are permitted by the running system.
Abstract: The High-Level Architecture (HLA) provides a common architecture for distributed modeling and simulation. In its original form, the HLA allows a number of simulations to be joined together into a federation using a single run time infrastructure. Recently there has been an interest in joining multiple such federations together using a mediating unit, called an HLA
JoΓ£o Sousa and
David Garlan. Aura: an Architectural Framework for User Mobility in Ubiquitous Computing Environments. In Software Architecture: System Design, Development, and Maintenance (Proceedings of the 3rd Working IEEE/IFIP Conference on Software Architecture), Jan Bosch, Morven Gentleman, Christine Hofmeister and Juha Kuusela (Eds.), Kluwer Academic Publishers. pp. 29-43. August 25-31, 2002.
https://doi.org/10.1007/978-0-387-35607-5_2.
Abstract: Ubiquitous computing poses a number of challenges for software architecture. One of the most important is the ability to design software systems that accommodate dynamically-changing resources. Resource variability arises naturally in a ubiquitous computing setting through user mobility (a user moves from one computing environment to another), and through the need to exploit time-varying resources in a given environment (such as wireless bandwidth). Traditional approaches to handling resource variability in applications attempt to address the problem by imposing uniformity on the environment. We argue that those approaches are inadequate, and describe an alternative architectural framework that is better matched to the needs of ubiquitous computing. A key feature of the architecture is that user tasks become first class entities. User proxies, or Auras, use models of user tasks to set up, monitor and adapt computing environments proactively. The architectural framework has been implemented and currently being used as a central component of Project Aura, a campus-wide ubiquitous computing effort.
Shang-Wen Cheng,
David Garlan,
Bradley Schmerl,
JoΓ£o Sousa,
Bridget Spitznagel and Peter Steenkiste. Using Architectural Style as a Basis for Self-repair. In Software Architecture: System Design, Development, and Maintenance (Proceedings of the 3rd Working IEEE/IFIP Conference on Software Architecture), Jan Bosch, Morven Gentleman, Christine Hofmeister and Juha Kuusela (Eds.), Kluwer Academic Publishers. pp. 45-59. August 25-31, 2002.
https://doi.org/10.1007/978-0-387-35607-5_3.
Abstract: An increasingly important requirement for software systems is the capability to adapt at run time in order to accommodate varying resources, system errors, and changing requirements. For such self-repairing systems, one of the hard problems is determining when a change is needed, and knowing what kind of adaptation is required. Recently several researchers have explored the possibility of using architectural models as a basis for run time monitoring, error detection, and repair. Each of these efforts, however, has demonstrated the feasibility of using architectural models in the context of a specific style. In this paper we show how to generalize these solutions by making architectural style a parameter in the monitoring/repair framework and its supporting infrastructure. The value of this generalization is that it allows one to tailor monitoring/ repair mechanisms to match both the properties of interest (such as performance or security), and the available operators for run time adaptation.
Abstract: In an increasing number of domains software is now required to be self-adapting and self-healing. While in the past such abilities were incorporated into software on a per system basis, proliferation of such systems calls for more generalized mechanisms to manage dynamic adaptation. General mechanisms have the advantage that they can be reused in numerous systems, analyzed separately from the system being adapted, and easily changed to incorporate new adaptations. Moreover, they provide a natural home for encoding the expertise of system designers and implementers about adaptation strategies and policies. In this paper, we show how architecture description languages and tools can be extended to provide such generalized dynamic adaptation mechanisms.
Abstract: Grid applications must increasingly self-adapt dynamically to changing environments. In most cases, adaptation has been implemented in an ad hoc fashion, on a perapplication basis. This paper describes work which generalizes adaptation so that it can be used across applications by providing an adaptation framework. This framework uses a software architectural model of the system to analyze whether the application requires adaptation, and allows repairs to be written in the context of the architectural model and propagated to the running system. In this paper, we exemplify our framework by applying it to the domain of load-balancing a client-server system. We report on an experiment conducted using our framework, which illustrates that this approach maintains architectural requirements.
Shang-Wen Cheng,
David Garlan,
Bradley Schmerl,
JoΓ£o Sousa,
Bridget Spitznagel, Peter Steenkiste and Ningning Hu. Software Architecture-based Adaptation for Pervasive Systems. In International Conference on Architecture of Computing Systems (ARCS'02): Trends in Network and Pervasive Computing, H Schmeck, T Ungerer and L Wolf (Eds.), Karlsruhe, Germany, Springer-Verlag. Lecture Notes in Computer Science, Vol. 2299. April 8-11, 2002.
https://doi.org/10.1007/3-540-45997-9_7.
Abstract: An important requirement for pervasive computing systems is the ability to adapt at runtime to handle varying resources, user mobility, changing user needs, and system faults. In this paper we describe an approach in which dynamic adaptation is supported by the use of software architectural models to monitor an application and guide dynamic changes to it. The use of externalized models permits one to make reconfiguration decisions based on a global per-spective of the running system, apply analytic models to determine correct re-pair strategies, and gauge the effectiveness of repair through continuous system monitoring. We illustrate the application of this idea to pervasive computing systems, focusing on the need to adapt based on performance-related criteria and models.
David Garlan,
Bradley Schmerl and
Jichuan Chang. Using Gauges for Architecture-Based Monitoring and Adaptation. In Proceedings of the Working Conference on Complex and Dynamic Systems Architecture. December 12-14, 2001.
Abstract: An increasingly important requirement for complex systems is the capability to adapt at runtime in order to accommodate variable resources, system errors, and changing requirements. An essential aspect of adaptation is the ability to observe a system's runtime behavior and interpret those observations in terms that permit a high-level understanding of the system's status. In this paper we describe mechanisms for monitoring a running system, interpreting monitored data in terms of the system's architecture, and analyzing the system architecture to ascertain if the system's runtime behavior fits within the envelope of acceptable behavior. We illustrate the use of these mechanisms for the important special case of system performance monitoring.
Abstract: Increasingly, systems are composed from independently developed parts, and mechanisms that allow those parts to interact (connectors). In many situations, specialized forms of interaction are needed to bridge component mismatches or to achieve extra-functional properties (e.g., security, performance, reliability), making the design and implementation of these interaction mechanisms a critical issue. Unfortunately, system developers have few options: they must live with available, but often inadequate, generic support for interaction (such as RPC), or they must handcraft specialized mechanisms at great cost. In this paper we describe a partial solution to this problem, whereby interaction mechanisms are constructed compositionally. Specifically, we describe a set of operators that can transform generic communication mechanisms (such as RPC and publish-subscribe) to incrementally add new capabilities. We show how these transformations can be used to realize complex interactions (such as Kerberized RPC) and to generate implementations of the new connector types at relatively low cost.
Shang-Wen Cheng and
David Garlan. Mapping Architectural Concepts to UML-RT. In Proceedings of the 2001 International Conference on Parallel and Distributed Processing Techniques and Applications (PDPTA'2001), Las Vegas, NV. June, 2001.
Abstract: Complex software systems require expressive notations for representing their software architectures. Two competing paths have emerged, one using a specialized notation for architecture - or architecture description language (ADL), the other using notations applied generally throughout design, such as UML. The latter has a number of benefits, including familiarity to developers, close mappings to implementations, and commercial tool support. However, it remains an open question how best to use object-oriented notations for architectural description and whether they are sufficiently expressive as currently defined. In this paper, we present a mapping between Acme?a notation designed for expressing architectures - and the UML Real-Time Profile - an object-oriented design notation. Specifically, we describe (a) how to map Acme descriptions to descriptions in the UML Real-Time Profile, and (b)the places where this mapping breaks down.
Abstract: Being able to find, adapt, and incorporate disparate components to form working, reliable applications is the goal of component-based software engineering. To date, there has been a lot of research, among other things, on locating components, reasoning about component compatibility, and methods for interoperability. Pervasive computing raises a number of new challenges for component-based software engineering that heretofore have been given little attention, such as mobility, adaptability, and resource awareness. In this paper we motivate and discuss the need for research in these areas, and discuss how our work in the Aura group at Carnegie Mellon University helps to address these issues.
Abstract: The use of largely isolated workstations and laptops as the primary carrier of personal computing is giving way to a world of pervasive computing populated by ubiquitous networks of heterogeneous computing and information facilities. In such a world the boundaries between a userβs personal computation space and other peopleβs is no longer well defined. As a result, collaboration becomes the dominant mode of computing β in essence, all systems become the basis for on-going computer-supported cooperative work.
Abstract: Complex software systems require expressive notations for representing their software architectures. Two competing paths have emerged. One is to use a specialized notation for architecture -- or architecture description language (ADL). The other is to adapt a general-purpose modeling notation, such as UML. The latter has a number of benefits including familiarity to developers, close mapping to implementations, and commercial tool support. However, it remains an open question as to how best to use object-oriented notations for architectural description, and, indeed, whether they are sufficiently expressive, as currently defined. In this paper we take a systematic look at these questions, examining the space of possible mappings from ADLs into object notations. Specifically, we describe (a) the principle strategies for representing architectural structure in UML; (b) the benefits and limitations of each strategy; and (c) aspects of architectural description that are intrinsically difficult to model in UML using the strategies.
David Garlan. Software Architecture and Object-Oriented Systems. In Proceedings of the IPSJ Object-Oriented Symposium 2000. August, 2000.
Abstract: Over the past decade software architecture has emerged as an important subfield of software engineering. During that time there has been considerable progress in developing the technological and methodological base for treating architectural design as an engineering discipline, including specialized architectural description languages, tools, analytic techniques, handbooks, and methods. In this paper I survey the main features of the field, and then compare software architecture with object-oriented systems to illustrate some of the important similarities and differences between the two fields.
Abstract: Over the past decade software architecture has received increasing attention as an important subfield of software engineering. During that time there has been considerable progress in developing the technological and methodologi-cal base for treating architectural design as an engineering discipline. However, much remains to be done to achieve that goal. Moreover, the changing face of technology raises a number of new challenges for software architecture. This paper examines some of the important trends of software architecture in research and practice, and speculates on the important emerging trends, challenges, and aspirations.
David Garlan and
Zhenyu Wang. A Case Study in Software Architecture Interchange. In Proceedings of Coordination'99, Springer-Verlag. 1999.
Abstract: An important issue for the specification and design of software architectures is how to combine the analysis capabilities of multiple architectural definition languages (ADLs) and their supporting toolsets. In this paper, we describe our experience of integrating three ADLs: Wright, Rapide, and Aesop. We discovered that it is possible achieve interoperability in ADL tools for a non-trivial subset of the systems describable by these languages, even though the languages have different views about architectural structure and semantics. To carry out the integration we used the Acme architectural interchange language and its supporting tools.
Robert Allen,
David Garlan and James Ivers. Formal Modeling and Analysis of the HLA Component Integration Standard. In Proceedings of the Sixth International Symposium on the Foundations of Software Engineering (FSE-6), Lake Buena Vista, Florida, ACM. November, 1998.
https://doi.org/10.1145/291252.288251.
Abstract: An increasingly important trend in the engineering of complex systems is the design of component integration standards. Such standards define rules of interaction and shared communication infrastructure that permit composition of systems out of independently-developed parts. A problem with these standards is that it is often difficult to understand exactly what they require and provide, and to analyze them in order to understand their deeper properties. In this paper we use our experience in modeling the High Level Architecture (HLA) for Distributed Simulation to show how one can capture the structured protocol inherent in an integration standard as a formal architectural model that can be analyzed to detect anomalies, race conditions, and deadlocks.
Abstract: A software architecture should expose important system properties for consideration and analysis. Performance-related properties are frequently of interest in determining the acceptability of a given software design. In this paper we show how queueing network modeling can be adapted to support performance analysis of software architectures. We also describe a tool for transforming a software architecture in a particular style into a queueing network and analyzing its performance.
Robert Allen, Remi Douence and
David Garlan. Specifying and Analyzing Dynamic Software Architectures. In Proceedings of the 1998 Conference on Fundamental Approaches to Software Engineering (FASE'98), Lisbon, Portugal, Springer. Lecture Notes in Computer Science, Vol. 1382. March, 1998.
https://doi.org/10.1007/bfb0053581. An expanded version of the paper Specifying Dynamism in Software Architectures, which appeared in the Proceedings of the Workshop on Foundations of Component-Based Software Engineering, September 1997.
Abstract: A critical issue for complex component-based systems design is the modeling and analysis of architecture. One of the complicating factors in developing architectural models is accounting for systems whose architecture changes dynamically (during run time). This is because dynamic changes to architectural structure may interact in subtle ways with on-going computations of the system.
In this paper we argue that it is possible and valuable to provide a modeling approach that accounts for the interactions between architectural reconfiguration and non-reconfiguration system functionality, while maintaining a separation of concerns between these two aspects of a system. The key to the approach is to use a uniform notation and semantic base for both reconfiguration and steady-state behavior, while at the same time providing syntactic separation between the two. As we will show, this permits us to view the architecture in terms of a set of possible architectural snapshots, each with its own steady-state behavior. Transitions between these snapshots are accounted for by special reconfiguration-triggering events.
David Garlan. Higher-Order Connectors. In Proceedings of Workshop on Compositional Software Architectures. January, 1998.
Abstract: A critical issue for architectural design is the nature of the glue, or connectors, with which a system's parts are combined. Thus an important first step toward improving our ability to compose parts is to make to make connectors explicit semantic enties, where they can be documented, analyzed, and (sometimes) used to generate code. A number of notations for software architecture do precisely this. However, a key second step is to understand operations over connectors. In principle, such operations would permit one to produce new connectors out of old ones, adapt existing connectors to new contexts of use, and factor out common properties of connectors so they can be reused. In this paper we argue that the use of ``higher order connectors'' is one way to achieve this goal.
David Garlan, Robert T. Monroe and David Wile. Acme: An Architecture Description Interchange Language. In Proceedings of CASCON'97, Toronto, Ontario. pp. 169-183. November, 1997.
https://doi.org/10.1145/1925805.1925814. One of the 14 high-impact papers from the first decade of CASCON, 2010.
Abstract: Numerous architectural description languages (ADLs) have been developed, each providing complementary capabilities for architectural development and analysis. Unfortunately, each ADL and supporting toolset operates in isolation, making it difficult to integrate those tools and share architectural descriptions. ACME is being developed as a joint effort of the software architecture research community as a common interchange format for architecture design tools. ACME provides a structural framework for characterizing architectures, together with annotation facilities for additional ADL-specific information. This scheme permits subsets of ADL tools to share architectural information that is jointly understood, while tolerating the presence of information that falls outside their common vocabulary. In this paper we describe ACME's key features, rationale, and technical innovations.
Robert Allen and
David Garlan. Formal Modeling and Analysis of the HLA RTI. In Summary Report of the 1997 Spring Simulation Interoperability Workshop, Orlando, Florida, Institute for Simulation and Training. pp. 1153-1161. March, 1997. IST-CF-97-01.2.
Abstract: The HLA RTI is a complex artifact, supporting several classes of interaction (e.g., federation management, object management, time management). A critical challenge in producing an RTI architectural framework (and its associated simulation interface specifications) is to develop confidence that its specification is well-formed and complete. In this paper we describe on-going work in formally modelling the HLA both to document the standard more precisely, as well as to analyze it for anomalies, omissions, inconsistencies, and ambiguities. The technical basis for this work is the use of a formal architectural description language, called Wright, and its accompanying toolset.
Abstract: Software architecture is receiving increasing attention as a powerful way to deal with the complexity of large software systems. It has emerged as a distinct form of abstraction for software systems with its own set of design issues, vocabulary, and goals. Like designers in other disciplines, software architects can gain significant leverage by using powerful design environments and tools. Powerful design tools generally encapsulate a relatively small amount of design expertise that provides the important functionality of the tool within a relatively large support infrastructure. In this position paper I argue that in order to make the development of specialized architectural design tools practical it must be relatively easy and inexpensive to capture and make use of the desired design expertise. I then briefly describe an emerging approach for capturing this design expertise so that it can be used to incrementally configure architectural design environments.
Abstract: Although numerous mechanisms for promoting software reuse have been proposed and implemented over the years, most have focused on the reuse of implementation code. There is much conjecture and some empirical evidence, however, that the most effective forms of reuse are generally found at more abstract levels of software design. In this paper we discuss software reuse at the architectural level of design. Specifically, we argue that the concept of 'architectural style' is useful for supporting the classification, storage, and retrieval of reusable architectural design elements. We briefly describe the Aesop system's Software Shelf, a tool that assists designers in selecting appropriate design elements and patterns based on stylistic information and design constraints.
π
Abstract: Many would argue that future breakthroughs in software productivity will depend on our ability to combine existing pieces of software to produce new applications. An important step towares this goal is the development of new techniques to detect and cope with mismatches in the assembled parts. Some problems of composition are due to low-level issues of interoperability, such as mismatches in programming languages or database schemas. However, in this paper we highlight a different, and in many ways more pervasive, class of problem: architectural mismatch. Specifically, we use our experience in building a family of software design environments from existing parts to illustrate a variety of types of mismatch that center around the assumptions a reusable part makes about the structure of the application in which is to appear. Based on this experience we show how an architectural view of the mismatch problem exposes some fundamental, thorny problems for software composition and suggests possible research avenues needed to solve them.
Robert Allen. Formalism and Informalism in Architectural Style: A Case Study. In Proceedings of the First International Workshop on Architectures for Software Systems. April, 1995.
Abstract: Increasingly, developers look to software architecture to help them control the complexity of their systems. When developing a particular system, designers tend not to explore all possible alternatives for its architecture. Instead, they use specific patterns and idioms that are effective for the domain in which they are working. We term such a collection of patterns and idioms an architectural style.
Unfortunately, with few exceptions current exploitation of architectural style is informal and ad hoc. In this paper we consider an alternative to the ad hoc description of architectural styles, a formal description based on the inherent structure of software architectures. We explore this solution by describing Justo and Cunha's message passing style in Wright, an architecture description language based on CSP.
Abstract: A central aspect of architectural design is the use of recurring organizational patterns and idioms- or architectural styles. Examples include generic system organizations such as those based on dataflow or layers, as well as specific organizational structures such as the classical decomposition of a compiler, the OSI communication stack, and the MVC user interface paradigm.
The principled use of architectural styles has a number of practical benefits. First, it promotes design reuse: routine solutions with well-understood properties can be reapplied to new problems with confidence. Second, it can lead to significant code reuse: often the invariant aspects of an architectural style lend themselves to shared implementations. Third, it is easier for others to understand a system's organization if conventionalized structures are used. For example, even without giving details, characterization of a system as a 'client-server' organization immediately conveys a strong image of the kinds of pieces and how they fit together. Fourth,use of standardized styles supports interoperability. Examples include CORBA object-oriented architecture, and event-based tool integration. Fifth, by constraining the design space, an architectural style often permits specialized,style-specific analyses. For example, it is possible to analyze pipe-filter systems for schedulability, throughput, latency, and deadlock-freedom. Such analyses might not be meaningful for an arbitrary, ad hoc architecture - or even one constructed in a different style. Sixth, it is usually possible to provide style-specific visualizations: this makes it possible to provide graphical and textual renderings that match engineers' domain-specific intuitions about how their designs should be depicted.
David Garlan, Robert Allen and John Ockerbloom. Exploiting Style in Architectural Design Environments. In Proceedings of SIGSOFT'94: The Second ACM SIGSOFT Symposium on the Foundations of Software Engineering, ACM Press. December, 1994.
https://doi.org/10.1145/193173.195404.
Abstract: As the design of software architectures emerges as a discipline within software engineering, it will become increasingly important to support architectural description and analysis with tools and environments. In this paper we describe a system for developing architectural design environments that exploit architectural styles to guide software architects in producing specific systems. The primary contributions of this research are:
- A generic object model for representing architectural designs;
- The characterization of architectural styles as speculations of this object model;
- A toolkit for creating an open architectural design environment from a description of a specific architectural style.
We use our experience in implementing these concepts to illustrate how style-oriened architectural design raises new challenges for software support environments.
Abstract: Large software systems require decompositional mechanisms in order to make them tractable. Traditionally, MILs and IDLs have played this role by providing notations based on definition/use bindings. In this paper we argue that current MIL/IDLs based on definition/use have some serious drawbacks. A significant problem is that they fail to distinguish between 'implementation' and 'interaction' relationships between modules. We propose an alternative model in which components interact along well-defined lines of communication - or connectors. Connectors are defined as protocols that capture the expected patterns of communication between modules. We show how this leads to a scheme that is much more expressive for architectural relationships, that allows the formal definition of module interaction, and that supports its own form of automated checks and formal reasoning.
π
Robert Allen and
David Garlan. Formalizing Architectural Connection. In Proceedings of the Sixteenth International Conference on Software Engineering, Sorrento, Italy. pp. 71-80. May, 1994.
https://doi.org/10.1109/ICSE.1994.296767. Awarded ICSE2004 Best Paper (ICSE-10).
Abstract: As software systems become more complex the overall system structure, or software architecture, becomes a central design problem. An important step towards an engineering discipline of software is a formal basis for describing and analyzing these designs. In this paper we present a theory for one aspect of architectural description: the interactions between components. the key idea is to define architectural connectors as explicit semantic entities. These are specified as a collection of protocols that characterize each of the participant roles in an interaction and how these roles interact. We illustrate how this scheme can be used to define a variety of common architectural connectors. We provide a formal semantics and show how this leads to a sound deductive system in which architectural compatibility can be checked in a way analogous to type checking in programming languages.
David Garlan and Mary Shaw. Software Development Assignments for a Software Architecture Course. In Software Engineering Resources: Proceedings of the ACM/IEEE International Workshop on Software Engineering Education. May, 1994.
Abstract: As software systems grow in size and complexity their design problem extends beyond algorithms and data structures to issues of system design. These issues|the software architecture level of software design|are becoming increasingly important to the practicing software engineer. Consequently, it is important to nd eective ways to teach this material. To meet this need we developed a course, 'Architectures for Software Systems,' and have taught it four times. In this paper we describe the principal software development assignments that this course uses to develop skill at applying architectural principles to the design and implementation of software systems. The major challenges in designing such assignments are (1) making sure that students spend their time on architectural issues rather than coding, and (2) helping students establish and maintain a desired architectural style. We address these issues by providing working examples as starting points. These examples are usable in other courses.
Abstract: Problem Space versus Solution Space Requirements engineering is concerned fundamen tally with the shape of the problem space. Its primary goal is to determine the dimensions of the problem that the software system is to solve. In contrast, software architecture is concerned with the shape of the solution space. Its primary goal is to determine the structure of a solution to a problem posed by a set of requirements. Thus, understanding the role of software architecture in requirements engineering is largely a matter of understanding the dynamic relationship between identification of a problem to be solved and a description of its solution.
Gregory Abowd, Robert Allen and
David Garlan. Using Style to Understand Descriptions of Software Architecture. In Proceedings of SIGSOFT'93: Foundations of Software Engineering, ACM Press. Software Engineering Notes, Vol. 18, No. 5, pp. 9-20. December, 1993.
https://doi.org/10.1145/256428.167055.
Abstract: The software architecture of most systems is described informally and diagrammatically. In order for these descriptions to be meaningful at all, figures are understood by interpreting the boxes and lines in specific, conventionalized ways. The imprecision of these interpretations has a number of limitations. In this paper we consider these convetionalized interpretations as architectural styles and provide a formal framework for their uniform definition. In addition to providing a template for precisely defining new architectural styles, this framework allows for the proof that the notational constraints on a style are sufficient to guarantee the meanings of all described systems and provides a unified semantic base through which different stylistic interpretations can be compared.