Manuel Abreu, Luís Garrote, Luís Conde Bento,
Bradley Schmerl, Urbano J Nunes and
David Garlan. Formal Verification of Deep Neural Networks for Classification in Industrial Environments. In Proc. the 16th International Conference on Information Science and Technology, Coimbra, Portugal. October 1-6, 2026.
Abstract: Deep Learning methods, particularly Convolutional Neural Networks (CNN), have become widely adopted in indus- trial computer vision applications due to their strong image classification capabilities. In industrial environments, reliable object recognition is essential for automated systems such as warehouse automation and sorting processes, where incorrect classifications may lead to operational failures and reduced system reliability. Despite their performance, CNN-based models remain vulnerable to adversarial perturbations, raising concerns regarding their deployment in safety-critical applications. Industrial vision systems deployed in safety-critical environ- ments must operate reliably under adversarial perturbations and common perception degradations. This work presents a robustness analysis of image classification models for industrial environments using RGB and RGB-D data. An industrial object dataset containing seven classes was constructed through an ob- ject detection and extraction pipeline, resulting in object-centered image samples. Two CNN-based architectures were developed and evaluated: a baseline RGB model and a multimodal RGB-D model. Model robustness was analyzed through both formal verifica- tion and corruption-based robustness evaluation. Formal verifi- cation was performed using the alpha-beta-CROWN framework under different perturbation magnitudes, assessing whether the CNNs preserve their predictions under bounded perturbations. In addition, corruption-based experiments following the ImageNet- C protocol were conducted to evaluate model behavior under common image degradations.
🏆
Maria Casimiro,
Valentim Romão, Paolo Romano, Luis Rodrigues and
David Garlan. Ripple: A Long-Sighted Self-Adaptation Approach to Retrain Machine Learning-Enabled Systems. In Proc. 21st International Conference on Software Engineering for Adaptive and Self-Managing Systems (SEAMS), Rio de Janiero, Brazil. April 13-14, 2026.
https://doi.org/3788550.3794867.
Awarded Best Student Paper.
Abstract: Machine Learning (ML)-enabled systems are now ubiquitous. These systems leverage ML models that require frequent re-trainings, which can lead to unsustainable costs. To prevent superfluous retrains and optimize system performance in the long run, we introduce Ripple, a system that leverages probabilistic model checking techniques to automate the decision of when to retrain the ML models employed by an ML-enabled system. The main challenge tackled by Ripple is estimating how the predictive quality of an ML model varies over long-term horizons, both when it is and when it is not retrained. Ripple introduces Look-Ahead Adaptation Impact Predictors (LA-AIPs) that are used in combination with a probabilistic model checker to determine whether to retrain the ML model. This allows Ripple to optimize system performance in the long term, contributing to creating more sustainable ML-enabled systems. We demonstrate Ripple’s feasibility via a fraud detection system use case, showcasing its ability to plan for the long term and to account for retrain latency, improving over myopic adaptation approaches.
Genaina Nunes Rodrigues, Betty H.C. Cheng,
David Garlan, Paola Inverardi, Jeff Kramer and Sol Zilberman. SEAMS 2026 Community Debate: How Ethical Can an Ethics-Aware Controller Be? Can we Trust it? In Proc. the 21st International Conference on Software Engineering for Adaptive and Self-Managing Systems (SEAMS 2026), Rio de Janiero, Brazil. April 13-14, 2026.
https://doi.org/3788550.3795539.
Abstract: As software systems become increasingly autonomous and capable of synthesizing their own adaptive strategies, embedding ethical reasoning into self-adaptive controllers raises fundamental ques- tions about trust, responsibility, and moral agency. When adapta- tion unfolds under uncertainty, system decisions inevitably reflect implicit values originating from design choices, training data, and operational contexts. This challenges traditional assumptions about where ethical judgment resides and whether ethics-aware systems should follow fixed moral principles or dynamically negotiate ethi- cal trade-offs at runtime. This paper presents a collective contribution from a commu- nity debate panel of four eminent researchers at the 21st Interna- tional Conference on Software Engineering for Adaptive and Self- Managing Systems (SEAMS), each offering a distinct perspective on the trustworthiness, challenges, implications, and opportunities shaping the emerging horizon of ethics-aware controllers.
Abstract: Software systems are composed of interacting processes that share data between each other in order to satisfy system properties. When these processes deviate and are unavailable to transmit data—due to events such as software bugs, hardware failures, or security attacks—a resilient system will continue delivering safety-critical services. Identify- ing the processes required to satisfy system properties is not a trivial task as there may exist multiple alternative dataflow paths that each satisfy the property. In this work, we propose a formal modeling and analysis technique to compute the sets of minimal processes required to satisfy dataflow properties. The computation of these sets is reduced to a maximum satisfiability problem via modeling in AlloyMax, a for- mal modeling language that performs bounded model checking. We then present a method to formally define the resilience criteria for a system by constraining the minimal dataflow required under maximum system deviations. The efficacy of this work is then evaluated with four case studies motivated from real-world systems with promising results.
🏆
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.
Abstract: Distributed Denial of Service (DDoS) attacks have grown in complexity, with attackers dynamically adapting their strategies to maximize disruption. Dynamic DDoS adversaries evolve their attacks by changing targets, modifying botnet infrastructure, or altering traffic patterns to evade detection and maintain attack effectiveness. This dynamic nature poses significant challenges for DDoS defense, particularly in developing scalable and robust adaptive systems capable of real-time response. This paper introduces a novel, robust, multilayered defense system called DosSink that integrates detection and mitigation through variational autoencoders (VAE) and actor-critic deep reinforcement learning (DRL). The VAE effectively reduces the feature space which may make the learning intractable and characterizes traffic to estimate the risk score for each flow. At the same time, the DRL agent uses these risk scores to optimize mitigation policies that include traffic limiting, flow redirection, or puzzle-based source verification actions. Feedback from puzzle inquiries refines VAE risk assessments, enhancing detection accuracy. Key innovations of this framework include (1) the VAE's adaptability as an anomaly detector that evolves with DRL actions, avoiding reliance on static rules or predefined thresholds and enhancing the robustness of the overall system adaptation; (2) the separation of traffic characterization (VAE) and decisionmaking (DRL), improving scalability by reducing the state space; and (3) real-time adaptability to evolving attackers' strategies through dynamic collaboration between the VAE and DRL. Our evaluation experiments show that this framework accurately identifies malicious traffic flows, with a true positive rate of over 98% and a false positive rate below 1 %. Moreover, it efficiently learns the optimal mitigation strategy in under 20, 000 episodes across most experimental settings.
Abstract: Temporal logic specifications play an important role in a wide range of software analysis tasks, such as model checking, automated synthesis, program comprehension, and runtime monitoring. Given a set of positive and negative examples, specified as traces, LTL learning is the problem of synthesizing a specification, in linear temporal logic (LTL), that evaluates to true over the positive traces and false over the negative ones. In this paper, we propose a new type of LTL learning problem called constrained LTL learning, where the user, in addition to positive and negative examples, is given an option to specify one or more constraints over the properties of the LTL formula to be learned. We demonstrate that the ability to specify these additional constraints significantly increases the range of applications for LTL learning, and also allows efficient generation of LTL formulas that satisfy certain desirable properties (such as minimality). We propose an approach for solving the constrained LTL learning problem through an encoding in first-order relational logic and reduction to an instance of the maximal satisfiability (MaxSAT) problem. An experimental evaluation demonstrates that ATLAS, an implementation of our proposed approach, is able to solve new types of learning problems while performing better than or competitively with the state-of-the-art tools in LTL learning.
Abstract: Neural networks are often overconfident about their pre-dictions, which undermines their reliability and trustworthiness. In this work, we present a novel technique, named Error-Driven Uncertainty Aware Training (EUAT), which aims to enhance the ability of neural models to estimate their uncertainty correctly, namely to be highly uncertain when they output inaccurate predictions and low uncertain when their output is accurate. The EUAT approach oper-ates during the model's training phase by selectively employing two loss functions depending on whether the training examples are cor-rectly or incorrectly predicted by the model. This allows for pursu-ing the twofold goal of i) minimizing model uncertainty for correctly predicted inputs and ii) maximizing uncertainty for mispredicted in-puts, while preserving the model's misprediction rate. We evaluate EUAT using diverse neural models and datasets in the image recognition domains considering both non-adversarial and adversarial settings. The results show that EUAT outperforms existing approaches for uncertainty estimation (including other uncertainty-aware training techniques, calibration, ensembles, and DEUP) by providing uncertainty estimates that not only have higher quality when evaluated via statistical metrics (e. g., correlation with residuals) but also when employed to build binary classifiers that decide whether the model's output can be trusted or not and under distributional data shifts.
Abstract: Cyber-physical systems (CPS) with reinforcement learning (RL)-based controllers are increasingly being deployed in complex phys- ical environments such as autonomous vehicles, the Internet-of-Things (IoT), and smart cities. An important property of a CPS is tolerance; i.e., its ability to function safely under possible disturbances and un- certainties in the actual operation. In this paper, we introduce a new, expressive notion of tolerance that describes how well a controller is ca- pable of satisfying a desired system requirement, specified using Signal Temporal Logic (STL), under possible deviations in the system. Based on this definition, we propose a novel analysis problem, called the tol- erance falsification problem, which involves finding small deviations that result in a violation of the given requirement. We present a novel, two- layer simulation-based analysis framework and a novel search heuristic for finding small tolerance violations. To evaluate our approach, we con- struct a set of benchmark problems where system parameters can be configured to represent different types of uncertainties and disturbances in the system. Our evaluation shows that our falsification approach and heuristic can effectively find small tolerance violations.
🏆
Abstract: This work focuses on the problem of hyper-parameter tuning (HPT) for robust (i.e., adversarially trained) models, shedding light on the new challenges and opportunities arising during the HPT process for robust models. To this end, we conduct an extensive experimental study based on three popular deep models and explore exhaustively nine (discretized) hyper-parameters (HPs), two fidelity dimensions, and two attack bounds, for a total of 19208 configurations (corresponding to 50 thousand GPU hours).
Through this study, we show that the complexity of the HPT problem is further exacerbated in adversarial settings due to the need to independently tune the HPs used during standard and adversarial training: succeeding in doing so (i.e., adopting different HP settings in both phases) can lead to a reduction of up to 80% and 43% of the error for clean and adversarial inputs, respectively. We also identify new opportunities to reduce the cost of HPT for robust models. Specifically, we propose to leverage cheap adversarial training methods to obtain inexpensive, yet highly correlated, estimations of the quality achievable using more robust/expensive state-of-the-art methods. We show that, by exploiting this novel idea in conjunction with a recent multi-fidelity optimizer (taKG), the efficiency of the HPT process can be enhanced by up to 2.1x.
Abstract: The emergence of powerful automated design tools in many domains is changing the nature of design, as human-intensive activities can be increasingly off-loaded to those tools. Rather than having a human consider only handful of options, as has been done historically, such tools now enable the generation of a large space of potential designs, exhibiting different tradeoffs among competing qualities of merit, and supporting systematic exploration of the design space. At the same time, this paradigm raises new challenges centered on enabling humans to effectively navigate that generated space in order to select a design that best meets their requirements. In this paper we describe our experience in the domain of generative manufacturing, in which we developed a novel design environment for airplane parts manufacturing that incorporates a number of sophisticated design tools and attempts to tackle the emergent problems of design space exploration that are faced by designers of those parts. We use this experience to highlight the challenges that we faced and reflect on their applicability more generally to tool-assisted software design environments.
Abstract: Cyber-physical systems (CPS) are subject to environmental uncertainties such as adverse operating conditions, malicious attacks, and hardware degradation. These uncertainties may lead to failures that put the system in a sub-optimal or unsafe state. Systems that are resilient to such uncertainties rely on two types of operations: (1) graceful degradation, for ensuring that the system maintains an acceptable level of safety during unexpected environmental conditions and (2) recovery, to facilitate the resumption of normal system functions. Typically, mechanisms for degradation and recovery are developed independently from each other, and later integrated into a system, requiring the designer to develop an additional, ad-hoc logic for activating and coordinating between the two operations.
In this paper, we propose a self-adaptation approach for improving system resiliency through automated triggering and coordination of graceful degradation and recovery. The key idea behind our approach is to treat degradation and recovery as requirement-driven adaptation tasks: Degradation can be thought of as temporarily weakening original (i.e., ideal) system requirements to be achieved by the system, and recovery as strengthening the weakened requirements when the environment returns within an expected operating boundary. Furthermore, by treating weakening and strengthening as dual operations, we argue that a single requirement-based adaptation method is sufficient to enable coordination between degradation and recovery. Given system requirements specified in signal temporal logic (STL), we propose a run-time adaptation framework that performs degradation and recovery in response to environmental changes. We describe a prototype implementation of our framework and demonstrate the feasibility of the proposed approach using a case study in unmanned underwater vehicles.
Abstract: Designing a software architecture that satisfies a set of quality-attribute requirements has traditionally been a challenging activity for human architects, as it involves the exploration and assessment of alternative design decisions. The development of automated optimization tools for the architecture domain has opened new opportunities, because these tools are able to explore a large space of alternatives, and thus extend the architect's capabilities. In this context, however, architects need to efficiently navigate through a large space and understand the main relations between design decisions and feasible quality-attribute tradeoffs in a maze of possible alternatives. Although Machine Learning (ML) techniques can help to reduce the complexity of the task by sifting through the data generated by the tools, the standard techniques often fall short because they cannot offer architectural insights or relevant answers to the architect's questions. In this paper, and based on previous experiences, we argue that ML techniques should be adapted to the architecture domain, and propose a conceptual framework towards that goal. Furthermore, we show how the framework can be instantiated by adapting clustering techniques to answer architectural questions regarding a client-server design space.
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: This paper presents Fortis, a tool for automated, formal analysis and repair of robust discrete systems. Given a system model, an environment model, and a safety property, the tool can be used to automatically compute robustness as the amount of deviations in the environment under which the system can continue to guarantee the property. In addition, Fortis enables automated repair of a given system to improve its robustness against a set of intolerable deviations through a process called robustification. With these techniques, Fortis enables a new process for developing robust-by-design systems. The paper presents the overall design of Fortis as well as the key details behind the robustness analysis and robustification techniques. The applicability and performance of Fortis are illustrated through experimental results over a set of case study systems, including a radiation therapy system, an electronic voting machine, network protocols, and a transportation fare system.
🏆
Abstract: Microservice-based architectures consist of numer- ous, loosely coupled services with multiple instances. Service meshes aim to simplify traffic management and prevent mi- croservice overload through circuit breaking and request retry mechanisms. Previous studies have demonstrated that the static configuration of these mechanisms is unfit for the dynamic environment of microservices. We conduct a sensitivity analysis to understand the impact of retrying across a wide range of scenarios. Based on the findings, we propose a retry controller that can also work with dynamically configured circuit breakers. We have empirically assessed our proposed controller in various scenarios, including transient overload and noisy neighbors while enforcing adaptive circuit breaking. The results show that our proposed controller does not deviate from a well-tuned configura- tion while maintaining carried response time and adapting to the changes. In comparison to the default static retry configuration that is mostly used in practice, our approach improves the carried throughput up to 12x and 32x respectively in the cases of transient overload and noisy neighbors.
Abstract: When designing and evolving software architectures, architects need to consider large design spaces of architectural decisions. These decisions tend to impact the quality attributes of the system, such as performance, security, or reliability. Relevant quality attributes might influence each other and usually need to be traded off by architects. When exploring a design space, it is often challenging for architects to understand what tradeoffs exist and how they are connected to architectural decisions. This is particularly problematic in architectural spaces generated by automated optimization tools, as the underlying tradeoffs behind the decisions that they make are unclear. This paper presents an approach to explore quality-attribute tradeoffs via clustering and visualization techniques. The approach allows architects to get an overview of the main tradeoffs and their links to architectural configurations. We evaluated the approach in a think-aloud study with 9 participants from academia and industry. Our findings show that the proposed techniques can be useful in understanding feasible tradeoffs and architectural changes affecting those tradeoffs in large design spaces.
Abstract: The feature interaction problem occurs when two or
more independently developed components interact with each
other in unanticipated ways, resulting in undesirable system
behaviors. Feature interaction problems remain a challenge for
emerging domains in cyber-physical systems (CPS), such as the
Internet of Things and autonomous drones. Existing techniques
for resolving feature interactions take a “winner-takes-all†approach, where one out of the conflicting features is selected
as the most desirable one, and the rest are disabled. However,
when multiple of the conflicting features fulfill important system
requirements, being forced to select one of them can result in
an undesirable system outcome. In this paper, we propose a new
resolution approach that allows all of the conflicting features
to continue to partially fulfill their requirements during the
resolution process. In particular, our approach leverages the
idea of adaptive requirement weakening, which involves one or
more features temporarily weakening their level of performance
in order to co-exist with the other features in a consistent
manner. Given feature requirements specified in Signal Temporal
Logic (STL), we propose an automated method and a runtime
architecture for automatically weakening the requirements to
resolve a conflict. We demonstrate our approach through case
studies on feature interactions in autonomous drones.
Abstract: Modern software systems are deployed in a highly dynamic, uncertain environment. Ideally, a system that is robust should be capable of establishing its most critical requirements even in the presence of possible deviations in the environment. We propose a technique called behavioral robustification, which involves systematically and rigorously improving the robustness of a design against potential deviations. Given behavioral models of a system and its environment, along with a set of user-specified deviations, our robustification method produces a redesign that is capable of satisfying a desired property even when the environment exhibits those deviations. In particular, we describe how the robustification problem can be formulated as a multi- objective optimization problem, where the goal is to restrict the deviating environment from causing a violation of a desired property, while maximizing the amount of existing functionality and minimizing the cost of changes to the original design. We demonstrate the effectiveness of our approach on case studies involving the robustness of an electronic voting machine and safety-critical interfaces.
Abstract: In the literature on hyper-parameter tuning, a number of recent solutions rely on low-fidelity observations (e. g., training with sub-sampled datasets) in order to efficiently identify promising configurations to be then tested via high-fidelity observations (e. g., using the full dataset). Among these, HyperBand is arguably one of the most popular solutions, due to its efficiency and theoretically provable robustness. In this work, we introduce HyperJump, a new approach that builds on HyperBand's robust search strategy and complements it with novel model-based risk analysis techniques that accelerate the search by skipping the evaluation of low risk configurations, i. e., configurations that are likely to be eventually discarded by HyperBand. We evaluate HyperJump on a suite of hyper-parameter optimization problems and show that it provides over one-order of magnitude speed-ups, both in sequential and parallel deployments, on a variety of deep-learning, kernel-based learning and neural architectural search problems when compared to HyperBand and to several state-of-the-art optimizers.
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: Machine Learning (ML) models are now commonly
used as components in systems. As any other component, ML
components can produce erroneous outputs that may penalize
system utility. In this context, self-adaptive systems emerge as
a natural approach to cope with ML mispredictions, through
the execution of adaptation tactics such as model retraining. To
synthesize an adaptation strategy, the self-adaptation manager
needs to reason about the cost-benefit tradeoffs of the applicable
tactics, which is a non-trivial task for tactics such as model
retraining, whose benefits are both context- and data-dependent.
To address this challenge, this paper proposes a probabilistic
modeling framework that supports automated reasoning about
the cost/benefit tradeoffs associated with improving ML components of ML-based systems. The key idea of the proposed approach is to decouple the problems of (i) estimating the expected
performance improvement after retrain and (ii) estimating the
impact of ML improved predictions on overall system utility.
We demonstrate the application of the proposed framework by
using it to self-adapt a state-of-the-art ML-based fraud-detection
system, which we evaluate using a publicly-available, real fraud
detection dataset. We show that by predicting system utility stemming from retraining a ML component, the probabilistic model
checker can generate adaptation strategies that are significantly
closer to the optimal, as compared against baselines such as
periodic retraining, or reactive retraining.
Abstract: Machine Learning (ML) is increasingly used in domains such
as cyber-physical systems and enterprise systems. These systems typically operate in non-static environments, prone to unpredictable changes that can adversely impact the accuracy of the ML models, which are usually in the critical path of the systems. Mispredictions of ML components
can thus affect other components in the system, and ultimately impact overall system utility in non-trivial ways. From this perspective, self-adaptation techniques appear as a natural solution to reason about how to react to environment changes via adaptation tactics that can
potentially improve the quality of ML models (e.g., model retrain), and ultimately maximize system utility. However, adapting ML components is non-trivial, since adaptation tactics have costs and it may not be clear in a given context whether the benefits of ML adaptation outweigh its
costs. In this paper, we present a formal probabilistic framework, based on model checking, that incorporates the essential governing factors for reasoning at an architectural level about adapting ML classifiers in a
system context. The proposed framework can be used in a self-adaptive system to create adaptation strategies that maximize rewards of a multidimensional utility space. Resorting to a running example from the enterprise
systems domain, we show how the proposed framework can be
employed to determine the gains achievable via ML adaptation and to find the boundary that renders adaptation worthwhile.
Danny Weyns, Tomas Bures, Radu Calinescu, Barnaby Craggs, John Fitzgerald,
David Garlan, Bashar Nuseibeh, Liliana Pasquale, Awais Rashid,
Ivan Ruchkin and
Bradley Schmerl. Six Software Engineering Principles for Smarter Cyber-Physical Systems. In Proceedings of the Workshop on Self-Improving System Integration. September 27, 2021.
https://doi.org/10.1109/acsos-c52956.2021.00058.
Abstract: Cyber-Physical Systems (CPS) integrate computational and physical components. With the digitisation of society and industry and the progressing integration of systems, CPS need to become 'smarter' - in the sense that they can adapt and learn to handle new and unexpected conditions, and improve over time. Smarter CPS present a combination of challenges that existing engineering methods have difficulties addressing: inter-twined digital, physical and social spaces, need for heterogeneous modelling formalisms, demand for context-tied cooperation to achieve system goals, widespread uncertainty and disruptions in changing contexts, inherent human constituents, and continuous encounter with new situations. While approaches have been put forward to deal with some of these challenges, a coherent perspective on engineering smarter CPS is lacking. In this paper, we present six engineering principles for addressing the challenges of smarter CPS. As smarter CPS are software-intensive systems, we approach them from a software engineering perspective with the angle of self-adaptation that offers an effective approach to deal with run-time change. The six principles create an integrated landscape for the engineering and operation of smarter CPS.
Maria Casimiro, Paolo Romano,
David Garlan,
Gabriel A. Moreno,
Eunsuk Kang and Mark Klein. Self-Adaptation for Machine Learning Based Systems. In Proceedings of the 1st International Workshop on Software Architecture and Machine Learning (SAML), Virtual, (Originally Växjö, Sweden), Springer. LNCS. September 14, 2021.
Abstract: Today’s world is witnessing a shift from human-written software to machine-learned software, with the rise of systems
that rely on machine learning. These systems typically operate in non-static environments, which are prone to unexpected
changes, as is the case of self-driving cars and enterprise systems. In this context, machine-learned software can misbehave.
Thus, it is paramount that these systems are capable of detecting problems with their machined-learned components and
adapt themselves to maintain desired qualities. For instance, a fraud detection system that cannot adapt its machine-learned
model to efficiently cope with emerging fraud patterns or changes in the volume of transactions is subject to losses of millions
of dollars. In this paper, we take a first step towards the development of a framework aimed to self-adapt systems that rely
on machine-learned components. We describe: (i) a set of causes of machine-learned component misbehavior and a set of
adaptation tactics inspired by the literature on machine learning, motivating them with the aid of a running example; (ii) the
required changes to the MAPE-K loop, a popular control loop for self-adaptive systems; and (iii) the challenges associated
with developing this framework. We conclude the paper with a set of research questions to guide future work.
Mohammed Alharbi,
Shihong Huang and
David Garlan. A Probabilistic Model for Personality Trait Focused Explainability. In Proceedings of the 4th international Workshop on Context-aware, Autonomous and Smart Architecture (CASA 2021), co-located with the 15th European Conference on Software Architecture, Virtual (Originally Växjö Sweden). September 13-17, 2021.
Abstract: Explainability refers to the degree to which a software system's actions or solutions can be understood by humans. Giving humans the right amount of explanation at the right time is an important factor in maximizing the effective collaboration between an adaptive system and humans during interaction. However, explanations come with costs, such as the required time of explanation and humans' response time. Hence it is not always clear whether explanations will improve overall system utility and, if so, how the system should effectively provide explanation to humans, particularly given that different humans may benefit from different amounts and frequency of explanation. To provide a partial basis for making such decisions, this paper defines a formal framework that incorporates human personality traits as one of the important elements in guiding automated decision-making about the proper amount of explanation that should be given to the human to improve the overall system utility. Specifically, we use probabilistic model analysis to determine how to utilize explanations in an effective way. To illustrate our approach, Grid - a virtual human and system interaction game -- is developed to represent scenarios for human-systems collaboration and to demonstrate how a human's personality traits can be used as a factor to consider for systems in providing appropriate explanations.
Abstract: In software design, guaranteeing the correctness of run-time system behavior while achieving an acceptable balance among multiple quality attributes remains a challenging problem.
Moreover, providing guarantees about the satisfaction of those requirements when systems are subject to uncertain environments is even more challenging.
While recent developments in architectural analysis techniques can assist architects in exploring the satisfaction of quantitative guarantees across the design space, existing approaches are still limited because they do not explicitly link design decisions to satisfaction of quality requirements.
Furthermore, the amount of information they yield can be overwhelming to a human designer, making it difficult to distinguish the forest through the trees.
In this paper, we present an approach to analyzing architectural design spaces that addresses these limitations and provides a basis to enable the explainability of design tradeoffs.
Our approach combines dimensionality reduction techniques employed in machine learning pipelines with quantitative verification to enable architects to understand how design decisions contribute to the satisfaction of strict quantitative guarantees under uncertainty across the design space.
Our results show feasibility of the approach in two case studies and evidence that dimensionality reduction is a viable approach to facilitate comprehension of tradeoffs in poorly-understood design spaces.
Abstract: Alloy is a declarative modeling language based on a first-order relational logic. Its constraint-based analysis has enabled a wide range of applications in software engineering, including configuration synthesis, bug finding, test-case generation, and security analysis. Certain types of analysis tasks in these domains involve finding an optimal solution. For example, in a network configuration problem, instead of finding any valid configuration, it may be desirable to find one that is most permissive (i. e., it permits a maximum number of packets). Due to its dependence on SAT, however, Alloy cannot be used to specify and analyze these types of problems. We propose AlloyMax, an extension of Alloy with a capability to express and analyze problems with optimal solutions. AlloyMax introduces (1) a small addition of language constructs that can be used to specify a wide range of problems that involve optimality and (2) a new analysis engine that leverages a Maximum Satisfiability (MaxSAT) solver to generate optimal solutions. To enable this new type of analysis, we show how a specification in a first-order relational logic can be translated into an input format of MaxSAT solvers - namely, a Boolean formula in weighted conjunctive normal form (WCNF). We demonstrate the applicability and scalability of AlloyMax on a benchmark of problems. To our knowledge, AlloyMax is the first approach to enable analysis with optimality in a relational modeling language, and we believe that AlloyMax has the potential to bring a wide range of new applications to Alloy.
🏆
Abstract: Many self-adaptive systems benefit from human involvement, where human operators can complement the capabilities of systems (e.g., by supervising decisions, or performing adaptations and tasks involving physical changes that cannot be automated). However, insufficient preparation (e.g., lack of task context comprehension) may hinder the effectiveness of human involvement, especially when operators are unexpectedly interrupted to perform a new task. Preparatory notification of a task provided in advance can sometimes help human operators focus their attention on the forthcoming task and understand its context before task execution, hence improving effectiveness. Nevertheless, deciding when to use preparatory notification as a tactic is not obvious and entails considering different factors that include uncertainties induced by human operator behavior (who might ignore the notice message), human attributes (e.g., operator training level), and other information that refers to the state of the system and its environment.
In this paper, informed by work in cognitive science on human attention and context management, we introduce a formal framework to reason about
the usage of preparatory notifications
in self-adaptive systems involving human operators. Our framework characterizes the effects of managing attention via task notification in terms of task context comprehension. We also build on our framework to develop an automated probabilistic reasoning technique able to determine when and in what form a preparatory notification tactic should be used to optimize system goals. We illustrate our approach in a representative scenario of human-robot collaborative goods delivery.
Abstract: The question of whether “handling unanticipated changes is the ultimate challenge for self-adaptation†is impossible to evaluate without looking closely at what “unanticipated†means. In this position paper I try to bring a little clarity to this issue by arguing that the common distinction between “known unknowns†and “unknown unknowns†is too crude: for most systems there are changes that are not directly handled by “first-order†adaptation, but can, with appropriate engineering, be addressed naturally through “second-order†adaptation. I explain what I mean by this and consider ways in which such systems might be engineered.
Abstract: [Context and motivation:] For realistic self-adaptive systems,
multiple quality attributes need to be considered and traded off
against each other. These quality attributes are commonly encoded in
a utility function, for instance, a weighted sum of relevant objectives.
[Question/problem:] The research agenda for requirements engineering
for self-adaptive systems has raised the need for decision-making
techniques that consider the trade-offs and priorities of multiple objectives.
Human stakeholders need to be engaged in the decision-making
process so that the relative importance of each objective can be correctly
elicited. [Principal ideas/results:] This research preview paper
presents a method that supports multiple stakeholders in prioritizing
relevant quality attributes, negotiating priorities to reach an agreement,
and giving input to define utility functions for self-adaptive systems.
[Contribution:] The proposed method constitutes a lightweight solution
for utility function definition. It can be applied by practitioners and
researchers who aim to develop self-adaptive systems that meet stakeholders'
requirements. We present details of our plan to study the application
of our method using a case study.
Abstract: Security attacks present unique challenges to self-adaptive
system design due to the adversarial nature of the environment. Game
theory approaches have been explored in security to model malicious
behaviors and design reliable defense for the system in a mathematically
grounded manner. However, modeling the system as a single player, as
done in prior works, is insufficient for the system under partial compromise
and for the design of fine-grained defensive strategies where the rest of the
system with autonomy can cooperate to mitigate the impact of attacks.
To deal with such issues, we propose a new self-adaptive framework incorporating
Bayesian game theory and model the defender (i.e., the system)
at the granularity of components. Under security attacks, the architecture
model of the system is translated into a Bayesian multi-player game,
where each component is explicitly modeled as an independent player
while security attacks are encoded as variant types for the components.
The optimal defensive strategy for the system is dynamically computed
by solving the pure equilibrium (i.e., adaptation response) to achieve
the best possible system utility, improving the resiliency of the system
against security attacks. We illustrate our approach using an example
involving load balancing and a case study on inter-domain routing.
Abstract: Software systems are designed and implemented with assumptions about the environment. However, once the system is deployed,the actual environment may deviate from its expected behavior,possibly undermining desired properties of the system. To enable systematic design of systems that are robust against potential environmental deviations, we propose a rigorous notion of robustness for software systems. In particular, the robustness of a system is de-fined as the largest set of deviating environmental behaviors under which the system is capable of guaranteeing a desired property. We describe a new set of design analysis problems based on our notion of robustness, and a technique for automatically computing robustness of a system given its behavior description. We demonstrate potential applications of our robustness notion on two case studies involving network protocols and safety-critical interfaces.
Abstract: End-users’ trust in automated agents is important as automated decision-making and planning is increasingly used in many aspects of people’s lives. In real-world applications of planning, multiple optimization objectives are often involved.Thus, planning agents’ decisions can involve complex tradeoffs among competing objectives. It can be difficult for the end-users to understand why an agent decides on a particular planning solution on the basis of its objective values. As a result, the users may not know whether the agent is making the right decisions, and may lack trust in it. In this work, we contribute an approach, based on contrastive explanation, that enables a multi-objective MDP planning agent to explain its decisions in a way that communicates its tradeoff rationale in terms of the domain-level concepts. We conduct a human subjects experiment to evaluate the effectiveness of our explanation approach in a mobile robot navigation domain. The results show that our approach significantly improves the users’ understanding, and confidence in their understanding, of the tradeoff rationale of the planning agent
Abstract: Many applications have taken advantage of cloud
provided autonomic capabilities, commonly auto-scaling, to harness
easily available compute capacity to maintain performance
against defined quality objectives. This has caused the management
complexity of enterprise applications to increase. It is
now common for an application to be a collection of autonomic
sub-systems. However, combining individual autonomic systems
to create an application can lead to behaviors that negatively
impact the global aggregate utility of the application and in
some cases can be conflicting and self-destructive. Commonly,
human administrators address these behaviors as part of a design
time analysis of the situation or a run time mitigation of the
undesired effects. However, the task of controlling and mitigating
undesirable behaviors is complex and error prone. To handle the
complexity of managing a collection of autonomic systems we
have previously proposed an automated approach to the creation
of a higher level autonomic management system, referred to as a
Meta-Manager. In this paper, we improve upon prior work with
a more streamlined and understandable formal representation of
the approach, expand its capabilities to include global knowledge,
and test its potential applicability and effectiveness by managing
the complexity of a collection of autonomic systems in a case
study of a major outage suffered by the Google Cloud Platform.
Abstract: Self-adaptive software systems rely on planning to
make adaptation decisions autonomously. Planning is required
to produce high-quality adaptation plans in a timely manner;
however, quality and timeliness of planning are conflicting in
nature. This conflict can be reconciled with hybrid planning,
which can combine reactive planning (to quickly provide an
emergency response) with deliberative planning that take time
but determine a higher-quality plan. While often effective, reactive
planning sometimes risks making the situation worse. Hence,
a challenge in hybrid planning is to decide whether to invoke
reactive planning until the deliberative planning is ready with a
high-quality plan. To make this decision, this paper proposes a
novel learning-based approach. We demonstrate that this learning-based
approach outperforms existing techniques that are based
on specifying fixed conditions to invoke reactive planning in two
domains: enterprise cloud systems and unmanned aerial vehicles.
Abstract: Many self-adaptive systems benefit from human involvement, where a human operator can provide expertise not available to the system and perform adaptations involving physical changes that cannot be automated.
However, a lack of transparency and intelligibility of system goals and the autonomous behaviors enacted to achieve them may hinder a human operator's effort to make such involvement effective.
Explanation is sometimes helpful to allow the human to understand why the system is making certain decisions. However, explanations come with costs in terms of, e.g., delayed actions.
Hence, it is not always obvious whether explanations will improve the satisfaction of system goals and, if so,
when to provide them to the operator. In this work, we define a formal framework for reasoning about explanations of adaptive system behaviors and the conditions under which they are warranted. Specifically, we characterize explanations in terms of their impact on a human operator's ability to effectively engage in adaptive actions.
We then present
a decision-making approach for planning in self-adaptation
that leverages a probabilistic reasoning tool to determine when the explanation should be used
in an adaptation strategy in order to improve overall system utility.
We illustrate our approach in a representative scenario for the application of an adaptive news website in the context of potential denial-of-service attacks.
Abstract: Plan reuse is a promising approach for enabling self- systems to effectively adapt to unexpected changes, such as evolving existing adaptation strategies after an unexpected change using stochastic search. An ideal self- planner should be able to reuse repertoires of adaptation strategies, but this is challenging due to the evaluation overhead. For effective reuse, a repertoire should be both (a) likely to generalize to future situations, and (b) cost effective to evaluate. In this work, we present an approach inspired by chaos engineering for generating a diverse set of adaptation strategies to reuse, and we explore two analysis approaches based on clone detection and syntactic transformation for constructing repertoires of adaptation tactics that are likely to be amenable to reuse in stochastic search self-* planners. An evaluation of the proposed approaches on a simulated system inspired by Amazon AWS shows planning effectiveness improved by up to 20% and reveals tradeoffs in planning timeliness and optimality.
Abstract: Modern data analytic and machine learning jobs
find in the cloud a natural deployment platform to satisfy their
notoriously large resource requirements. Yet, to achieve cost
efficiency, it is crucial to identify a deployment configuration that
satisfies user-defined QoS constraints (e.g., on execution time),
while avoiding unnecessary over-provisioning.
This paper introduces Lynceus, a new approach for the
optimization of cloud-based data analytic jobs that improves over
state-of-the-art approaches by enabling significant cost savings
both in terms of the final recommended configuration and of the
optimization process used to recommend configurations.
Unlike existing solutions, Lynceus optimizes in a joint fashion
both the cloud-related (i.e., which and how many machines to
provision) and the application-level (e.g. the hyper-parameters
of a machine learning algorithm) parameters. This allows for a
reduction of the cost of recommended configurations by up to
3.7X at the 90-th percentile with respect to existing approaches,
which treat the optimization of cloud-related and application level
parameters as two independent problems.
Further, Lynceus reduces the cost of the optimization process
(i.e., the cloud cost incurred for testing configurations) by
up to 11X. Such an improvement is achieved thanks to two
mechanisms: i) a timeout approach which allows to abort the
exploration of configurations that are deemed suboptimal, while
still extracting useful information to guide future explorations
and to improve its predictive model — differently from recent
works, which either incur the full cost for testing suboptimal
configurations or are unable to extract any knowledge from
aborted runs; ii) a long-sighted and budget-aware technique
that determines which configurations to test by predicting the
long-term impact of each exploration — unlike state-of-the-art
approaches for the optimization of cloud jobs, which adopt greedy
optimization methods.
Abstract: Many self-adaptive systems benefit from human involvement and
oversight, where a human operator can provide expertise not available
to the system and can detect problems that the system is
unaware of. One way of achieving this is by placing the human
operator on the loop – i.e., providing supervisory oversight and
intervening in the case of questionable adaptation decisions. To
make such interaction effective, explanation is sometimes helpful to
allow the human to understand why the system is making certain
decisions and calibrate confidence from the human perspective.
However, explanations come with costs in terms of delayed actions
and the possibility that a human may make a bad judgement. Hence,
it is not always obvious whether explanations will improve overall
utility and, if so, what kinds of explanation to provide to the operator.
In this work, we define a formal framework for reasoning
about explanations of adaptive system behaviors and the conditions
under which they are warranted. Specifically, we characterize
explanations in terms of explanation content, effect, and cost. We
then present a dynamic adaptation approach that leverages a probabilistic
reasoning technique to determine when the explanation
should be used in order to improve overall system utility.
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.
Abstract: Two of the main paradigms used to build adaptive software employ different types of properties to capture relevant aspects of the system’s run-time behavior. On the one hand, control systems consider properties that concern static aspects like stability, as well as dynamic properties that capture the transient evolution of variables such as settling time. On the other hand, self-adaptive systems consider mostly non-functional properties that capture concerns such as performance, reliability, and cost. In general, it is not easy to reconcile these two types of properties or identify under which conditions they constitute a good fit to provide run-time guarantees. There is a need of identifying the key properties in the areas of control and self-adaptation, as well as of characterizing and mapping them to better understand how they relate and possibly complement each other. In this paper, we take a first step to tackle this problem by: (1) identifying a set of key properties in control theory, (2) illustrating the formalization of some of these properties employing temporal logic languages commonly used to engineer self-adaptive software systems, and (3) illustrating how to map key properties that characterize self-adaptive software systems into control properties, leveraging their formalization in temporal logics. We illustrate the different steps of the mapping on an exemplar case in the cloud computing domain and conclude with identifying open challenges in the area.
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: This work introduces TrimTuner, the first system for optimizing machine learning jobs in the cloud to exploit sub-sampling techniques to reduce the cost of the optimization process, while keeping into account user-specified constraints. TrimTuner jointly optimizes the cloud and application-specific parameters and, unlike state of the art works for cloud optimization, eschews the need to train the model with the full training set every time a new configuration is sampled. Indeed, by leveraging sub-sampling techniques and data-sets that are up to 60x smaller than the original one, we show that TrimTuner can reduce the cost of the optimization process by up to 50x. Further, TrimTuner speeds-up the recommendation process by 65×with respect to state of the art techniques for hyper-parameter optimization that use sub-sampling techniques. The reasons for this improvement are twofold: i) a novel domain specific heuristic that reduces the number of configurations for which the acquisition function has to be evaluated; ii) the adoption of an ensemble of decision trees that enables boosting the speed of the recommendation process by one additional order of magnitude.
Abstract: Advanced persistent threats (APTs) are a particularly troubling challenge
for software systems. The adversarial nature of the security
domain, and APTs in particular, poses unresolved challenges to
the design of self- systems, such as how to defend against multiple
types of attackers with different goals and capabilities. In
this interaction, the observability of each side is an important and
under-investigated issue in the self- domain. We propose a model
of APT defense that elevates observability as a first-class concern.
We evaluate this model by showing how an informed approach that
uses observability improves the defender’s utility compared to a
uniform random strategy, can enable robust planning through sensitivity
analysis, and can inform observability-related architectural
design decisions.
🏅
Abstract: This paper presents Kubow, an extensible architecture-based selfadaptation
service for cloud native applications. Kubow itself was
implemented by customizing and extending the Rainbow self-adaptation
framework with support for Docker containers and Kubernetes.
The paper highlights Kubow’s architecture and main design
decisions, and illustrates its use and configuration through a simple
example. An accompanying demo video is available at the project’s
web site: https://ppgia-unifor.github.io/kubow/.
Abstract: Modern enterprise IT systems are increasingly becoming
compositions of many subsystems each of which is
an autonomic system. These individual autonomic systems act
independently to maintain their locally defined SLAs but can take
actions which are inconsistent with and potentially detrimental
to the global system objective. Currently, human administrators
intervene to resolve these conflicts but are challenged by
complexity in the prediction of current and future states of
the constituent systems and their managers, multiple conflicting
quality dimensions which may change over time, combinatorially
large configuration space across the set of constituent systems,
and the time critical nature of the decisions to be made to prevent
further degradation. To address these challenges, this paper
proposes an approach that enables the creation of a higher level
autonomic system, referred to as a meta-manager, that does not
subsume the control functions nor does it directly orchestrate the
actions of the sub-autonomic managers. Instead, we encapsulate
and abstract the behavior of each subsystem as a parameterized
adaptation policy which can be adjusted by the meta-manager
to tune the adaptive behavior of the subsystem adaptation. We
can effectively instantiate this idea by considering each of the
subsystems as a player in a stochastic multi-player game against
it’s local environment, and synthesize an adaptation strategy
using off-the-shelf tools for stochastic game analysis.
🏅
Abstract: Motivated by the need for cyber-physical systems (CPS) to perform in dynamic and uncertain environments, smart CPS (sCPS) utilize self-adaptive capabilities to autonomously manage uncertainties at the intersection of the cyber and physical worlds. In this context, self-adaptation approaches face particular challenges, including (i) environment monitoring that is subject to sensing errors; (ii) adaptation actions that take time, sometimes due to physical movement; (iii) dire consequences for not adapting in a timely manner; and (iv) incomparable objectives that cannot be conflated into a single utility metric (e.g., avoiding an accident vs. providing good service). To enable researchers to evaluate and compare self-adaptation approaches aiming to address these unique challenges of sCPS, we introduce the DARTSim exemplar. DARTSim implements a high-level simulation of a team of unmanned air vehicles (UAVs) performing a reconnaissance mission in a hostile and unknown environment. Designed to be easily used by researchers, DARTSim provides a TCP-based interface for easy integration with external adaptation managers, documentation, and a fast simulation capability.
Abstract: Modern cyber-physical systems (e.g., robotics systems) are typically composed of physical and software components, the characteristics of which are likely to change over time.
Assumptions about parts of the system made at design time may not hold at run time, especially when a system is deployed for long periods (e.g., over decades).
Self-adaptation is designed to find reconfigurations of systems to handle such run-time inconsistencies. Planners can be used to find and enact optimal reconfigurations in such an evolving context. However, for systems that are highly configurable, such planning becomes intractable due to the size of the adaptation space.
To overcome this challenge, in this paper we explore an approach that (a) uses machine learning to find Pareto-optimal configurations without needing to explore every configuration, and (b) restricts the search space to such configurations to make planning tractable.
We explore this in the context of robot missions that need to consider task timeliness and energy consumption. An independent evaluation shows that our approach results in high quality adaptation plans in uncertain and adversarial environments.
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: Why is it so difficult to build self-adaptive systems by reusing existing
self-adaptation services and frameworks? In this paper, we
argue that one possible explanation is that there is a fundamental
mismatch between the adaptation needs of modern software
systems, and the architectural models and adaptation mechanisms
supported by current self-adaptation solutions. We identify and
discuss the main reasons leading to this problem by looking into a
number of representative self-adaptation solutions that have been
proposed in recent years, including open source frameworks and
cloud-based services, from two perspectives: generality, i.e., their
ability to support a variety of architectural models and adaptation
mechanisms, and reusability, i.e., their ability to be reused without
requiring substantial effort from software developers. We then make
the case that recent industry progress toward microservices and
their enabling technologies can open the way to the development
of more general and reusable self-adaptation solutions.
Abstract: Design and verification of modern systems requires diverse models,
which often come from a variety of disciplines, and it is challenging to manage
their heterogeneity – especially in the case of cyber-physical systems. To check
consistency between models, recent approaches map these models to flexible static
abstractions, such as architectural views. This model integration approach, however, comes at a cost of reduced expressiveness because complex behaviors of the
models are abstracted away. As a result, it may be impossible to automatically
verify important behavioral properties across multiple models, leaving systems
vulnerable to subtle bugs. This paper introduces the Integration Property Language (IPL) that improves integration expressiveness using modular verification of
properties that depend on detailed behavioral semantics while retaining the ability
for static system-wide reasoning. We prove that the verification algorithm is sound
and analyze its termination conditions. Furthermore, we perform a case study on a
mobile robot to demonstrate IPL is practically useful and evaluate its performance.
Cody Kinneer, Zack Coker, Jiacheng Wang,
David Garlan and Claire Le Goues. Managing Uncertainty in Self-Adaptive Systems with Plan Reuseand Stochastic Search. In Proceedings of the 13th International Symposium on Software Engineering for Adaptive and Self-Managing Systems (SEAMS). May 28-29, 2018.
https://doi.org/10.1145/3194133.3194145.
Abstract: Many software systems operate in environments where change and uncertainty are the rule, rather than exceptions. Techniques for self-adaptation allow these systems to automatically respond to environmental changes, yet they do not handle changes to the adaptive system itself, such as the addition or removal of adaptation tactics. Instead, changes in a self-adaptive system often require a human planner to redo an expensive planning process to allow the system to continue satisfying its quality requirements under different conditions; automated techniques typically must replan from scratch. We propose to address this problem by reusing prior planning knowledge to adapt in the face of unexpected situations. We present a planner based on genetic programming that reuses existing plans. While reuse of material in genetic algorithms has recently applied successfully in the area of automated program repair, we find that naïvely reusing existing plans for self-* planning actually results in a loss of utility. Furthermore, we propose a series of techniques to lower the costs of reuse, allowing genetic techniques to leverage existing information to improve planning utility when replanning for unexpected changes.
🏅
Abstract: Research in self-adaptive systems often uses web applications as
target systems, running the actual software on real web servers.
This approach has three drawbacks. First, these systems are not
easy and/or cheap to deploy. Second, run-time conditions cannot
be replicated exactly to compare diferent adaptation approaches
due to uncontrolled factors. Third, running experiments is time-
consuming. To address these issues, we present SWIM, an exemplar
that simulates a web application. SWIM can be used as a target
system with an external adaptation manager interacting with it
through its TCP-based interface. Since the servers are simulated,
this use case addresses the irst two problems. The full beneit
of SWIM is attained when the adaptation manager is built as a
simulation module. An experiment using a simulated 60-server
cluster, processing 18 hours of traic with 29 million requests takes
only 5 minutes to run on a laptop computer. SWIM has been used
for evaluating self-adaptation approaches, and for a comparative
study of model-based predictive approaches to self-adaptation.
Abstract: Self-adaptive systems depend on models of themselves and their
environment to decide whether and how to adapt, but these models
are often affected by uncertainty. While current adaptation decision
approaches are able to model and reason about this uncertainty,
they do not consider ways to reduce it. This presents an opportunity
for improving decision-making in self-adaptive systems, because
reducing uncertainty results in a better characterization of the current
and future states of the system and the environment (at some
cost), which in turn supports making better adaptation decisions.
We propose uncertainty reduction as the natural next step in uncertainty
management in the field of self-adaptive systems. This
requires both an approach to decide when to reduce uncertainty,
and a catalog of tactics to reduce different kinds of uncertainty. We
present an example of such a decision, examples of uncertainty
reduction tactics, and describe how uncertainty reduction requires
changes to the different activities in the typical self-adaptation loop.
Abstract: Use of multi-objective probabilistic planning to synthesize behavior of CPSs can play an important role in engineering systems that must self-optimize for multiple quality objectives and operate under uncertainty. However, the reasoning behind automated planning is opaque to end-users. They may not understand why a particular behavior is generated, and therefore not be able to calibrate their confidence in the systems working properly. To address this problem, we propose a method to automatically generate verbal explanation of multi-objective probabilistic planning, that explains why a particular behavior is generated on the basis of the optimization objectives. Our explanation method involves describing objective values of a generated behavior and explaining any tradeoff made to reconcile competing objectives. We contribute: (i) an explainable planning representation that facilitates explanation generation, and (ii) an algorithm for generating contrastive justification as explanation for why a generated behavior is best with respect to the planning objectives. We demonstrate our approach on a mobile robot case study.
Abstract: Due to the fundamental trade-off between quality and timeliness of planning, designers of self-adaptive systems often have to compromise between an approach that is quick to find an adaptation plan and an approach that is slow but finds a quality adaptation plan. To deal with this trade-off, in our previous work, we proposed a hybrid planning approach that combines a deliberative and a reactive planning approach to find a balance between quality and timeliness of planning.
However, when reactive and deliberative planning is combined to
instantiate a hybrid planner, the key challenge is to decide which
approach(es) should be invoked to solve a planning problem. To
this end, this paper proposes to use a data-driven instance-based
learning to find an appropriate combination of the two planning
approaches when solving a planning problem. As an initial proof
of concept, the paper presents results of a small experiment that
demonstrates the potential of the proposed approach to identify a
combination of the two planning approaches to solve a planning
problem.
🏆
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: Self-Adaptive systems are expected to adapt to unanticipated run-time
events using imperfect information about their environment. This entails handling
the effects of uncertainties in decision-making, which are not always considered
as a first-class concern. This paper contributes a formal analysis technique that
explicitly considers uncertainty in sensing when reasoning about the best way to
adapt. We illustrate our approach on a Denial of Service (DoS) attack scenario
and present some preliminary results that show the benefits of uncertainty-aware
decision-making with respect to using an uncertainty-ignorant approach.
Abstract: Large software systems have to contend with a significant number of users who interact with different components of the system in various ways. The sequences of components that are used as part of an interaction define sets of behaviors that users have with the system. These can be large in number. Among these users, it is possible that there are some who exhibit anomalous behaviors - for example, they may have found back doors into the system and are doing something malicious. These anomalous behaviors can be hard to distinguish from normal behavior because of the number of interactions a system may have, or because traces may deviate only slightly from normal behavior. In this paper we describe a model-based approach to cluster sequences of user behaviors within a system and to find suspicious, or anomalous, sequences. We exploit the underlying software architecture of a system to define these sequences. We further show that our approach is better at detecting suspicious activities than other approaches, specifically those that use unigrams and bigrams for anomaly detection. We show this on a simulation of a large scale system based on Amazon Web application style architecture.
Abstract: Across many domains, end-users need to compose computational elements into novel configurations to perform their day-to-day tasks. End-user composition is a common programming activity performed by such end-users to accomplish this composition task. While there have been many studies on end-user programming, we still need a better understanding of activities involved in end-user composition and environments to support them. In this paper we report a qualitative study of four popular composition environments belonging to diverse application domains, including: Taverna workflow environment for life sciences, Loni Pipeline for brain imaging, SimMan3G for medical simulations and Kepler for scientific simulations. We interview end-users of these environments to explore their experiences while performing common compositions tasks. We use "Content Analysis" - technique to analyze these interviews to explore what are the barriers to end-user composition in these domains. Furthermore, our findings show that there are some unique differences in the requirements of naive end-users vs. expert programmers. We believe that not only are these findings useful to improve the quality of end-user composition environments, but they can also help towards development of better end-user composition frameworks.
🏆
Ivan Ruchkin, Selva Samuel,
Bradley Schmerl, Amanda Rico and
David Garlan. Challenges in Physical Modeling for Adaptation of Cyber-Physical Systems. In Workshop on MARTCPS Models at Runtime and Networked Control for Cyber Physical Systems at IEEE World Forum on the Internet of Things, Reston, Virginia. December 12-14, 2016.
https://doi.org/10.1109/wf-iot.2016.7845513.
Winner of the IEEE World Forum on the Internet of Things Best Paper Award.
Abstract: Cyber-physical systems (CPSs) mix software,
hardware, and physical aspects with equal importance. Typically,
the use of models of such systems during run time
has concentrated only on managing and controlling the cyber
(software) aspects. However, to fully realize the goals of a
CPS, physical models too have to be treated as first-class
models. This approach gives rise to three main challenges:
(a) identifying and integrating physical and software models
with different characteristics and semantics; (b) obtaining
instances of physical models at a suitable level of abstraction
for adaptation; and (c) using and adapting physical models to
control CPSs. In this position paper, we elaborate on these three
challenges and describe our vision of making physical models
first-class entities in adaptation. We illustrate this vision in the
context of power adaptation for a service robotic system.
Bradley Schmerl, Jeffrey Gennari, Alireza Sadeghi, Hamid Bagheri, Sam Malek,
Javier Cámara and
David Garlan. Architecture Modeling and Analysis of
Security in Android Systems. In Proceedings of the 10th European Conference on Software Architecture (ECSA 2016), Copenhagen, Denmark, Springer. Lecture Notes in Computer Science, Vol. 9839. November 30-December 2, 2016.
https://doi.org/10.1007/978-3-319-48992-6_21.
Abstract: Software architecture modeling is important for analyzing system quality
attributes, particularly security. However, such analyses often assume that the
architecture is completely known in advance. In many modern domains, especially
those that use plugin-based frameworks, it is not possible to have such
a complete model because the software system continuously changes. The Android
mobile operating system is one such framework, where users can install
and uninstall apps at run time. We need ways to model and analyze such architectures
that strike a balance between supporting the dynamism of the underlying
platforms and enabling analysis, particularly throughout a system�s lifetime. In
this paper, we describe a formal architecture style that captures the modifiable
architectures of Android systems, and that supports security analysis as a system
evolves. We illustrate the use of the style with two security analyses: a predicatebased
approach defined over architectural structure that can detect some common
security vulnerabilities, and inter-app permission leakage determined by model
checking. We also show how the evolving architecture of an Android device can
be obtained by analysis of the apps on a device, and provide some performance
evaluation that indicates that the architecture can be amenable for use throughout
the system�s lifetime.
Abstract: Run-time generation of adaptation plans is a powerful
mechanism that helps a self-adaptive system to meet its goals
in a dynamically changing environment. In the past, researchers
have demonstrated successful use of various automated planning
techniques to generate adaptation plans at run time. However, for
a planning technique, there is often a trade-off between timeliness
and optimality of the solution. For some self-adaptive systems,
ideally, one would like to have a planning approach that is both
quick and finds an optimal adaptation plan. To find the right
balance between these conflicting requirements, this paper introduces
a hybrid planning approach that combines more than one
planner to obtain the benefits of each. In this paper, to instantiate
a hybrid planner we combine deterministic planning with Markov
Decision Process (MDP) planning to obtain the best of both worlds:
deterministic planning provides plans quickly when timeliness is
critical, while allowing MDP planning to generate optimal plans
when the system has sufficient time to do so. We validate the
hybrid planning approach using a realistic workload pattern in
a simulated cloud-based self-adaptive system.
Abstract: Proactive latency-aware adaptation is an approach for self-adaptive systems that improves over reactive adaptation by considering both the current and anticipated adaptation needs of the system, and taking into account the latency of adaptation tactics so that they can be started with the necessary lead time. Making an adaptation decision with these characteristics requires solving an optimization problem to select the adaptation path that maximizes an objective function over a finite look-ahead horizon. Since this is a problem of selecting adaptation actions in the context of the probabilistic behavior of the environment, Markov decision processes (MDP) are a suitable approach. However, given all the possible interactions between the different and possibly concurrent adaptation tactics, the system, and the environment, constructing the MDP is a complex task. Probabilistic model checking can be used to deal with this problem since it takes as input a formal specification of the stochastic system, which is internally translated into an MDP, and solved. One drawback of this solution is that the MDP has to be constructed every time an adaptation decision has to be made to incorporate the latest predictions of the environment behavior. In this paper we present an approach that eliminates that run-time overhead by constructing most of the MDP offline, also using formal specification. At run time, the adaptation decision is made by solving the MDP through stochastic dynamic programming, weaving in the stochastic environment model as the solution is computed. Our experimental results show that this approach reduces the adaptation decision time by an order of magnitude compared to the probabilistic model checking approach, while producing the same results.
Abstract: Planning in CPSs requires temporal reasoning to handle the dynamics of the environment, including human behavior, as well as temporal constraints on system goals and durations of actions that systems and human actors may take. The discrete abstraction of time in a state space planning should have a time sampling parameter value that satisfi es some relation to achieve a certain precision. In particular, the sampling period should be small enough to allow the dynamics of the problem domain to be modeled with sufficient precision. Meanwhile, in many cases, events in the far future (relative to the sampling period) may be relevant to the decision making earlier in the planning timeline; therefore, a longer planning look-ahead horizon can yield a closer-to-optimal plan. Unfortunately, planning with a uniform fine-grained discrete abstraction of time and a long look-ahead horizon is typically computationally infeasible. In this paper, we propose a multiscale temporal planning approach - formulated as MDP planning - to preserve the required time fidelity of the problem domain and at the same time approximate a globally optimal plan. We illustrate our approach in a middleware used to monitor large sensor networks.
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: Modern frameworks are required to be extendable as well as secure. However, these two qualities are often at odds. In this poster we describe an approach that uses a combination of static analysis and run-time management, based on software architecture models, that can improve security while maintaining framework extendability. We implement a prototype of the approach for the Android platform. Static analysis identifi es the architecture and communication patterns among the collection of apps on an Android device and which communications might be vulnerable to attack. Run-time mechanisms monitor these potentially vulnerable communication patterns, and adapt the system to either deny them, request explicit approval from the user, or allow them.
Ivan Ruchkin, Ashwini Rao, Dio De Niz, Sagar Chaki and
David Garlan. Eliminating Inter-Domain Vulnerabilities in Cyber-Physical
Systems: An Analysis Contracts Approach. In Proceedings of the First ACM Workshop on Cyber-Physical Systems Security and Privacy, Denver, Colorado. October 16, 2015.
https://doi.org/10.1145/2808705.2808714.
Abstract: Designing secure cyber-physical systems (CPS) is a particularly
difficult task since security vulnerabilities stem not
only from traditional cybersecurity concerns, but also physical
ones as well. Many of the standard methods for CPS
design make strong and unverified assumptions about the
trustworthiness of physical devices, such as sensors. When
these assumptions are violated, subtle inter-domain vulnerabilities
are introduced into the system model. In this paper
we propose to use formal specification of analysis contracts
to expose security assumptions and guarantees of analyses
from reliability, control, and sensor security domains. We
show that this specification allows us to determine where
these assumptions are violated or ignore important failure
modes that open the door to malicious attacks. We demonstrate
how this approach can help discover and prevent vulnerabilities
in a self-driving car example.
Ivan Ruchkin,
Bradley Schmerl and
David Garlan. Analytic Dependency Loops in Architectural Models of Cyber-Physical Systems. In Proceedings of the 8th International Workshop on Model-based Architecting of Cyber-Physical and Embedded Systems, Ottawa, Canada. September 28, 2015.
Abstract: Rigorous engineering of safety-critical Cyber-
Physical Systems (CPS) requires integration of heterogeneous
modeling methods from different disciplines. It is often necessary
to view this integration from the perspective of analyses –
algorithms that read and change models. Although analytic
integration supports formal contract-based verification of model
evolution, it suffers from the limitation of analytic dependency
loops. Dependency loops between analyses cannot be resolved
based on the existing contract-based verification. This paper
makes a step towards using rich architectural description to
resolve circular analytic dependencies. We characterize the dependency
loop problem and discuss three algorithmic approaches
to resolving such loops: analysis iteration, constraint solving, and
genetic search. These approaches take advantage of information
in multi-view architectures to resolve analytic dependency loops.
Abstract: Modern software systems are often compositions
of entities that increasingly use self-adaptive capabilities to
improve their behavior to achieve systematic quality goals. Self-adaptive
managers for each component system attempt to provide
locally optimal results, but if they cooperated and potentially
coordinated their efforts it might be possible to obtain more
globally optimal results. The emergent properties that result
from such composition and cooperation of self-adaptive systems
are not well understood, difficult to reason about, and
present a key challenge in the evolution of modern software
systems. For example, the effects of coordination patterns and
protocols on emergent properties such as the resiliency of the
collectives need to be understood when designing these systems.
In this paper we propose that probabilistic model checking
of stochastic multiplayer games (SMG) provides a promising
approach to analyze, understand, and reason about emergent
properties in collectives of adaptive systems (CAS). Probabilistic
Model Checking of SMGs is a technique particularly suited
to analyzing emergent properties in CAS, since SMG models
capture: (i) the uncertainty and variability intrinsic to the CAS
and its execution environment in the form of probabilistic and
nondeterministic choices, and (ii) the competitive/cooperative
aspects of the interplay among the constituent systems of the
CAS. Analysis of SMGs allows us to reason about things like
the worst case scenarios, which constitutes a new contribution
to understanding emergent properties in CAS. We investigate
the use of SMGs to show how they can be useful in analyzing
the impact of communication topology for collections of fully
cooperative systems defending against an external attack.
Abstract: Internet of Things (IoT) allows for cyber-physical applications
to be created and composed to provide intelligent support or
automation of end-user tasks. For many of such tasks, human participation
is crucial to the success and the quality of the tasks. The cyber
systems should proactively request help from the humans to accomplish
the tasks when needed. However, the outcome of such system-human
synergy may be affected by factors external to the systems. Failure to
consider those factors when involving human participants in the tasks
may result in suboptimal performance and negative experience on the
humans. In this paper, we propose an approach for automated generation
of control strategies of cyber-human systems. We investigate how
explicit modeling of human participant can be used in automated planning
to generate cooperative strategy of human and system to achieve a
given task, by means of which best and appropriately utilize the human.
Specifically, our approach consists of: (1) a formal framework for modeling
cooperation between cyber system and human, and (2) a formalization
of system-human cooperative task planning as strategy synthesis
of stochastic multiplayer game. We illustrate our approach through an
example of indoor air quality control in smart homes.
Abstract: Self-adaptive systems tend to be reactive and myopic, adapting
in response to changes without anticipating what the
subsequent adaptation needs will be. Adapting reactively
can result in ineffi?ciencies due to the system performing a
suboptimal sequence of adaptations. Furthermore, when
adaptations have latency, and take some time to produce
their e?ffect, they have to be started with su?fficient lead time
so that they complete by the time their eff?ect is needed.
Proactive latency-aware adaptation addresses these issues
by making adaptation decisions with a look-ahead horizon
and taking adaptation latency into account. In this paper we
present an approach for proactive latency-aware adaptation
under uncertainty that uses probabilistic model checking for
adaptation decisions. The key idea is to use a formal model
of the adaptive system in which the adaptation decision is
left underspeci?fied through nondeterminism, and have the
model checker resolve the nondeterministic choices so that
the accumulated utility over the horizon is maximized. The
adaptation decision is optimal over the horizon, and takes
into account the inherent uncertainty of the environment
predictions needed for looking ahead. Our results show that
the decision based on a look-ahead horizon, and the factoring
of both tactic latency and environment uncertainty, considerably
improve the eff?ectiveness of adaptation decisions.
Abstract: Self-adaptive systems overcome many of the limitations of human supervision in complex software-intensive systems
by endowing them with the ability to automatically adapt their
structure and behavior in the presence of runtime changes.
However, adaptation in some classes of systems (e.g., safety-
critical) can benefit by receiving information from humans (e.g.,
acting as sophisticated sensors, decision-makers), or by involving
them as system-level effectors to execute adaptations (e.g., when
automation is not possible, or as a fallback mechanism). However,
human participants are influenced by factors external to the
system (e.g., training level, fatigue) that affect the likelihood
of success when they perform a task, its duration, or even if
they are willing to perform it in the first place. Without careful
consideration of these factors, it is unclear how to decide when to
involve humans in adaptation, and in which way. In this paper,
we investigate how the explicit modeling of human participants
can provide a better insight into the trade-offs of involving
humans in adaptation. We contribute a formal framework to
reason about human involvement in self-adaptation, focusing on
the role of human participants as actors (i.e., effectors) during
the execution stage of adaptation. The approach consists of:
(i) a language to express adaptation models that capture factors
affecting human behavior and its interactions with the system,
and (ii) a formalization of these adaptation models as stochastic
multiplayer games (SMGs) that can be used to analyze human-
system-environment interactions. We illustrate our approach in
an adaptive industrial middleware used to monitor and manage
sensor networks in renewable energy production plants.
Zack Coker,
David Garlan and Claire Le Goues. SASS: Self-adaptation using stochastic search. In Proceedings 10th International Symposium on Software Engineering for Adaptive and Self-Managing Systems (SEAMS 2015). May 18-19, 2015.
https://doi.org/10.1109/seams.2015.16.
Abstract: Future-generation self-adaptive systems will need
to be able to optimize for multiple interrelated, difficult-to-measure,
and evolving quality properties. To navigate this complex
search space, current self-adaptive planning techniques
need to be improved. In this position paper, we argue that the
research community should more directly pursue the application
of stochastic search techniques—search techniques, such as hill
climbing or genetic algorithms, that incorporate an element of
randomness—to self-adaptive systems research. These techniques
are well-suited to handling multi-dimensional search spaces and
complex problems, situations which arise often for self-adaptive
systems. We believe that recent advances in both fields make this
a particularly promising research trajectory. We demonstrate
one way to apply some of these advances in a search-based
planning prototype technique to illustrate both the feasibility and
the potential of the proposed research. This strategy informs
a number of potentially interesting research directions and
problems. In the long term, this general technique could enable
sophisticated plan generation techniques that improve domain
specific knowledge, decrease human effort, and increase the
application of self-adaptive systems.
Abstract: Modern cyber-physical systems interact closely with continuous physical processes like kinematic movement. Software component frameworks do not provide an explicit way to represent or reason about these processes. Meanwhile, hybrid program models have been successful in proving critical properties of discrete-continuous systems. These programs deal with diverse aspects of a cyber-physical system such as controller decisions, component communication protocols, and mechanical dynamics, requiring several programs to address the variation. However, currently these aspects are often intertwined in mostly monolithic hybrid programs, which are difficult to understand, change, and organize. These issues can be addressed by component-based engineering, making hybrid modeling more practical. This paper lays the foundation for using architectural models to provide component-based benefits to developing hybrid programs. We build formal architectural abstractions of hybrid programs and formulas, enabling analysis of hybrid programs at the component level, reusing parts of hybrid programs, and automatic transformation from views into hybrid programs and formulas. Our approach is evaluated in the context of a robotic collision avoidance case study.
Abstract: Architecture-based approaches to self-adaptation rely on architectural descriptions to reason about the best way of adapting the structure and behavior of software-intensive systems at run time, either by choosing among a set of predefined adaptation strategies, or by automatically generating adaptation plans. Predefined strategy selection has allow computational overhead and facilitates dealing with uncertainty (e.g., by accounting explicitly for contingencies derived from unexpected outcomes of actions), but requires additional designer effort regarding the specification of strategies and is unable to guarantee optimal solutions. In contrast, run time plan generation is able to explore a richer
solution space and provide optimal solutions in some cases,
but is more limited when dealing with uncertainty, and incurs higher computational overheads. In this paper, we
propose an approach to optimal adaptation plan generation for architecture-based self-adaptation via model checking of stochastic multiplayer games (SMGs). Our approach
enables: (i) trade-off analysis among different qualities by means of utility functions and preferences, and (ii) explicit modeling of uncertainty in the outcome of adaptation actions and the behavior of the environment. Basing on the concepts embodied in the Rainbow framework for self-adaptation, we illustrate our approach in Znn.com, a case study
that reproduces the infrastructure for a news website.
Abstract: Development of modern Cyber-Physical Systems (CPS) relies on a number of analysis tools to verify critical properties. The Architecture Analysis and Design Language (AADL) standard provides a common architectural model to which multiple CPS analyses can be applied. Unfortunately, interaction between these analyses can invalidate their results. In this paper we present ACTIVE, a tool developed within the OSATE/AADL infrastructure to solve this problem. We analyze the problems that occur when multiple analyses are applied to an AADL model and how these problems invalidate analysis results. Interactions between analyses, implemented as OSATE plugins, are formally described in ACTIVE in order to enable automatic verification. In particular, these interactions are captured in an analysis contract consisting of inputs, outputs, assumptions, and guarantees. The inputs and outputs help determine the correct order of execution of the plugins. Assumptions capture the conditions that must be valid in order to execute an analysis plugin, while guarantees are conditions that are expected to be valid afterwards. ACTIVE allows the use of any generic verification tool (e. g., a model checker) to validate these conditions. To coordinate these activities our tool uses two components: ACTIVE EXECUTER and ACTIVE VERIFIER. ACTIVE EXECUTER invokes the analysis plugins in the required order and uses ACTIVE VERIFIER to check assumptions and guarantees. ACTIVE VERIFIER identifies and executes the verification tool that needs to be invoked based on the target formula. Together, they ensure that plugins are always executed in the correct order and under the correct conditions, guaranteeing correct results. To the best of our knowledge, ACTIVE is the first extensible framework that integrates independently-developed analysis plugins ensuring provably-correct interactions.
Abstract: Developing cyber-physical systems involves creating systems with properties from multiple domains, e. g., timing, logical correctness, thermal resilience, aerodynamics, and mechanical stress. In today/s industrial practice, multiple analyses are used to obtain and verify such properties. Unfortunately, given that these analyses originate from different scientific domains, they abstract away interactions among themselves, risking the invalidation of their results. Specifically, one challenge is to ensure that an analysis is never applied to a model that violates its assumptions. Since such violation can originate from the updating of the model by another analysis, analyses must be executed in the correct order. Another challenge is to do this soundly and scalably over models of realistic complexity and diverse set of analyses. To address these challenges, we develop an analysis integration approach that uses contracts to specify dependencies between analyses, determine their correct orders of application, and specify and verify applicability conditions across multiple domains. We present an implementation of our approach, and demonstrate its effectiveness, extensibility, and scalability.
Abstract: Self-adaptive systems have the ability to adapt their behavior to dynamic operation conditions. In reaction to changes in the environment, these systems determine the appropriate corrective actions based in part on information about which action will have the best impact on the system. Existing models used to describe the impact of adaptations are either unable to capture the underlying uncertainty and variability of such dynamic environments, or are not compositional and described at a level of abstraction too low to scale in terms of specification effort required for non-trivial systems. In this paper, we address these shortcomings by describing an approach to the specification of impact models based on architectural system descriptions, which at the same time allows us to represent both variability and uncertainty in the outcome of adaptations, hence improving the selection of the best corrective action. The core of our approach is an impact model language equipped with a formal semantics defined in terms of Discrete Time Markov Chains. To validate our approach, we show how employing our language can improve the accuracy of predictions used for decision-making in the Rainbow framework for architecture-based self-adaptation.
Abstract: Availability is an increasingly important quality for today's
software-based systems and it has been successfully addressed
by the use of closed-loop control systems in self-adaptive systems.
Probes are inserted into a running system to obtain
information and the information is fed to a controller that,
through provided interfaces, acts on the system to alter its
behavior. When a failure is detected, pinpointing the source
of the failure is a critical step for a repair action. However,
information obtained from a running system is commonly
incomplete due to probing costs or unavailability of probes.
In this paper we address the problem of fault localization
in the presence of incomplete system monitoring. We may
not be able to directly observe a component but we may be
able to infer its health state. We provide formal criteria to
determine when health states of unobservable components
can be inferred and establish formal theoretical bounds for
accuracy when using any spectrum-based fault localization
algorithm.
Abstract: Although different approaches to decision-making in self-adaptive systems have shown their effectiveness in the past by factoring in predictions about the system and its environment (e. g., resource availability), no proposal considers the latency associated with the execution of tactics upon the target system. However, different adaptation tactics can take different amounts of time until their eff ects can be observed. In reactive adaptation, ignoring adaptation tactic latency can lead to suboptimal adaptation decisions (e. g., activating a server that takes more time to boot than the transient spike in traffic that triggered its activation). In proactive adaptation, taking adaptation latency into account is necessary to get the system into the desired state to deal with an upcoming situation. In this paper, we introduce a formal analysis technique based on model checking of stochastic multiplayer games (SMGs) that enables us to quantify the potential benefi ts of employing different types of algorithms for self-adaptation. In particular, we apply this technique to show the potential benefi t of considering adaptation tactic latency in proactive adaptation algorithms. Our results show that factoring in tactic latency in decision making improves the outcome of adaptation. We also present an algorithm to do proactive adaptation that considers tactic latency, and show that it achieves higher utility than an algorithm that under the assumption of no latency is optimal.
Bradley Schmerl,
Javier Cámara, Jeffrey Gennari,
David Garlan,
Paulo Casanova,
Gabriel A. Moreno,
Thomas J. Glazier and
Jeffrey M. Barnes. Architecture-Based Self-Protection: Composing and Reasoning about Denial-of-Service Mitigations. In HotSoS 2014: 2014 Symposium and Bootcamp on the Science of Security, Raleigh, NC, USA. April 8-9, 2014.
https://doi.org/10.1145/2600176.2600181.
Abstract: Security features are often hardwired into software applications, making it difficult to adapt security responses to reflect changes in runtime context and new attacks. In prior work, we proposed the idea of architecture-based self-protection as a way of separating adaptation logic from application logic and providing a global perspective for reasoning about security adaptations in the context of other business goals. In this paper, we present an approach, based on this idea, for combating denial-of-service (DoS) attacks. Our approach allows DoS-related tactics to be composed into more sophisticated mitigation strategies that encapsulate possible responses to a security problem. Then, utility-based reasoning can be used to consider diff erent business contexts and qualities. We describe how this approach forms the underpinnings of a scientific approach to self-protection, allowing us to reason about how to make the best choice of mitigation at runtime. Moreover, we also show how formal analysis can be used to determine whether the mitigations cover the range of conditions the system is likely to encounter, and the effect of mitigations on other quality attributes of the system. We evaluate the approach using the Rainbow self-adaptive framework and show how Rainbow chooses DoS mitigation tactics that are sensitive to diff erent business contexts.
Vishal Dwivedi,
David Garlan, Jürgen Pfeffer and
Bradley Schmerl. Model-based Assistance for Making Time/Fidelity Trade-offs in Component Compositions. In 11th International Conference on Information Technology : New Generations (ITNG 2014), Special track on: MDCBSE: Model-Driven, Component-Based Software Engineering, Las Vegas, NV. April 7-9, 2014.
https://doi.org/10.1109/itng.2014.107.
Abstract: In many scientific fields, simulations and analyses require compositions of computational entities such as web services, programs, and applications. In such fields, users may want various trade-offs between different qualities. Examples include: (i) performing a quick approximation vs. an accurate, but slower, experiment, (ii) using local slower execution environments vs. remote, but advanced, computing facilities, (iii) using quicker approximation algorithms vs. computationally expensive algorithms with smaller data. However, such trade-offs are difficult to make as many such decisions today are either (a) wired into a fixed configuration and cannot be changed, or (b) require detailed systems knowledge and experimentation to determine what configuration to use. In this paper we propose an approach that uses architectural models coupled with automated design space generation for making fidelity and timeliness trade-offs. We illustrate this approach through an example in the intelligence analysis domain.
David Garlan. Software Architecture: A Travelogue. In Proceedings of the on Future of Software Engineering, New York, NY, USA, ACM. FOSE 2014, pp. 29--39. 2014. ISBN 978-1-4503-2865-4. Also available from
ACM DOI: 10.1145/2593882.2593886.
Abstract: Over the past two and a half decades 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. However, much still remains
to be done to achieve that. Moreover, the changing face of
technology raises a number of challenges for software
architecture. This travelogue recounts the history of the field, its
current state of practice and research, and speculates on some of
the important emerging trends, challenges, and aspirations
Abstract: In previous research, we have developed a theoretical
framework to help software architects make better decisions when
planning software evolution. Our approach is based on representation
and analysis of candidate evolution paths—sequences of transitional
architectures leading from the current system to a desired
target architecture. One problem with this kind of approach is
that it imposes a heavy burden on the software architect, who
must explicitly define and model these candidate paths. In this
paper, we show how automated planning techniques can be used
to support automatic generation of evolution paths, relieving this
burden on the architect. We illustrate our approach by applying
it to a data migration scenario, showing how this architecture
evolution problem can be translated into a planning problem and
solved using existing automated planning tools.
Eric Yuan, Sam Malek,
Bradley Schmerl,
David Garlan and Jeffrey Gennari. Architecture-Based Self-Protecting Software Systems. In Proceedings of the Ninth International ACM Sigsoft Conference on the Quality of Software Architectures (QoSA 2013). pp. 33-42. June 17-21, 2013. DOI:
10.1145/2465478.2465479.
Abstract: Since conventional software security approaches are often manually developed and statically deployed, they are no longer sufficient against today's sophisticated and evolving cyber security threats. This has motivated the development of self-protecting software that is capable of detecting security threats and mitigating them through runtime adaptation techniques. In this paper, we argue for an architecture-based self- protection (ABSP) approach to address this challenge. In ABSP, detection and mitigation of security threats are informed by an architectural representation of the running system, maintained at runtime. With this approach, it is possible to reason about the impact of a potential security breach on the system, assess the overall security posture of the system, and achieve defense in depth. To illustrate the effectiveness of this approach, we present several architecture adaptation patterns that provide reusable detection and mitigation strategies against well-known web application security threats. Finally, we describe our ongoing work in realizing these patterns on top of Rainbow, an existing architecture-based adaptation framework.
Abstract: Many domains such as scientific computing and neuroscience require end users to compose heterogeneous computational entities to automate their professional tasks. However, an issue that frequently hampers such composition is data-mismatches between computational entities. Although, many composition frameworks today provide support for data mismatch resolution through specialpurpose data converters, end users still have to put significant effort in dealing with data mismatches, e. g., identifying the available converters and determining which of them meet their QoS expectations. In this paper we present an approach that eliminates this effort by automating the detection and resolution of data mismatches. Specifically, it uses architectural abstractions to automatically detect different types of data mismatches, model-generation techniques to fix those mismatches, and utility theory to decide the best fix based on QoS constraints. We illustrate our approach in the neuroscience domain where data-mismatches can be fixed in an efficient manner on the order of few seconds.
Abstract: Recent research has developed a theoretical basis for providing software architects with better support for planning and carrying out major evolutions of software systems. However, these theoretical models have yet to be implemented in a complete, integrated tool. In this paper, we consider some of the challenges involved in developing such a tool as a plug-in to an existing architecture modeling framework. We present an experience report based on the development of a prototype architecture evolution tool as a plug-in to MagicDraw, a commercial UML tool. We find that there are many practical obstacles to developing tools for architecture evolution modeling as plug-ins, and we discuss some of the key factors that plug-in developers should weigh when considering frameworks.
🏆
Abstract: Self-diagnosis is a fundamental capability of self-adaptive
systems. In order to recover from faults, systems need
to know which part is responsible for the incorrect behavior. In
previous work we showed how to apply a design-time diagnosis
technique at run time to identify faults at the architectural level
of a system. Our contributions address three major shortcomings
of our previous work: 1) we present an expressive, hierarchical
language to describe system behavior that can be used to
diagnose when a system is behaving different to expectation; the
hierarchical language facilitates mapping low level system events
to architecture level events; 2) we provide an automatic way to
determine how much data to collect before an accurate diagnosis
can be produced; and 3) we develop a technique that allows the
detection of correlated faults between components. Our results
are validated experimentally by injecting several failures into a
system and accurately diagnosing them using our algorithm.
Abstract: Although architecture-based self-adaptation has
been widely used, there is still little understanding about
the validity and tradeoffs of incorporating it into real-world software-intensive systems which already feature built-in adaptation mechanisms. In this paper, we report on our experience in integrating Rainbow, a platform for architecture-based self-adaptation, and an industrial middleware employed to monitor and manage highly populated networks of devices. Concretely, we reflect on aspects such as the effort required for framework customization and legacy code refactoring, performance improvement, and the impact of architecture-based self-adaptation on system evolution.
David Garlan,
Vishal Dwivedi,
Ivan Ruchkin and
Bradley Schmerl. Foundations and Tools for End-User Architecting. In Large-Scale Complex IT Systems. Development, Operation and Management, 17th Monterey Workshop 2012, Oxford, UK, March 19-21, 2012,
David Garlan and Radu Calinescu (Eds.), Springer. Lecture Notes in Computer Science, Vol. 7539, pp. 157-182. 2012.
https://doi.org/10.1007/978-3-642-34059-8_9.
Abstract: Within an increasing number of domains an important emerging need is the ability for technically naive users to compose computational elements into novel configurations. Examples include astronomers who create new analysis pipelines to process telescopic data, intelligence analysts who must process diverse sources of unstructured text to discover socio-technical trends, and medical researchers who have to process brain image data in new ways to understand disease pathways. Creating such compositions today typically requires low-level technical expertise, limiting the use of computational methods and increasing the cost of using them. In this paper we describe an approach -- which we term end-user architecting -- that exploits the similarity between such compositional activities and those of software architects. Drawing on the rich heritage of software architecture languages, methods, and tools, we show how those techniques can be adapted to support end users in composing rich computational systems through domain-specific compositional paradigms and component repositories, without requiring that they have knowledge of the low-level implementation details of the components or the compositional infrastructure. Further, we outline a set of open research challenges that the area of end-user architecting raises.
Akshay Rajhans, Ajinkya Y. Bhave, Sarah Loos, Bruce Krogh, Andre Platzer and
David Garlan. Using Parameters in Architectural Views to Support Heterogeneous Design and Verification. In 50th IEEE Conference on Decision and Control (CDC) and European Control Conference (ECC), Orlando, FL. December 12-15, 2011.
https://doi.org/10.1109/cdc.2011.6161408.
Abstract: Current methods for designing cyber-physical systems
lack a unifying framework due to the heterogeneous nature
of the constituent models and their respective analysis and verification
tools. There is a need for a formal representation of the
relationships between the different models. Our approach is to
define these relationships at the architectural level, associating
with each model a particular view of the overall system base
architecture. This architectural framework captures critical
structural and semantic information without including all
the details of the various modeling formalisms. This paper
introduces the use of logical constraints over parameters in the
architectural views to represent the conditions under which the
specifications verified for each model are true and imply the
system-level specification. Interdependencies and connections
between the constraints in the architectural views are managed
in the base architecture using first-order logic of real arithmetic
to ensure consistency and correct reasoning. The approach is
illustrated in the context of heterogeneous verification of a
leader-follower vehicle scenario.
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: An important step in achieving robustness to run-time faults is the ability
to detect and repair problems when they arise in a running system. Effective
fault detection and repair could be greatly enhanced by run-time fault diagnosis
and localization, since it would allow the repair mechanisms to focus adaptation
effort on the parts most in need of attention. In this paper we describe
an approach to run-time fault diagnosis that combines architectural models with
spectrum-based reasoning for multiple fault localization. Spectrum-based reasoning
is a lightweight technique that takes a form of trace abstraction and produces
a list (ordered by probability) of likely fault candidates. We show how this technique
can be combined with architectural models to support run-time diagnosis
that can (a) scale to modern distributed software systems; (b) accommodate the
use of black-box components and proprietary infrastructure for which one has
neither a specification nor source code; and (c) handle inherent uncertainty about
the probable cause of a problem even in the face of transient faults and faults that
arise only when certain combinations of system components interact.
Abstract: Current methods for modeling, analysis, and design
of cyber-physical systems lack a unifying framework due to the
complexity and heterogeneity of the constituent elements and
their interactions. Our approach is to define relationships between
system models at the architectural level, which captures the
structural interdependencies and some semantic interdependencies
between representations without attempting to comprehend
all of the details of any particular modeling formalism. This
paper addresses the issue of defining and evaluating consistency
between architectural views imposed by various heterogeneous
models and a base architecture (BA) for the complete system. This
notion of structural consistency ensures that the model elements
adhere to the cyber and physical types and the connections
between components present in the BA, which serves as the
unifying framework for model-based development. Consistency
checking between a model and the underlying system architecture
is formulated as a typed graph matching problem between
the connectivity graphs of the corresponding architectural view
and the system’s BA. The usefulness of the approach to check
system modeling assumptions is illustrated in the context of two
heterogeneous views of a quadrotor air vehicle.
Abstract: An increasingly important class of software-based systems is plat-forms that permit integration of third-party components, services, and tools. Service-Oriented Architecture (SOA) is one such plat-form that has been successful in providing integration and distri-bution in the business domain, and could be effective in other domains (e.g., scientific computing, healthcare, and complex deci-sion making). In this paper, we discuss our application of SOA to provide an integration platform for socio-cultural analysis, a domain that, through models, tries to understand, analyze and predict relationships in large complex social systems. In developing this platform, called SORASCS, we had to overcome issues we believe are generally applicable to any application of SOA within a domain that involves technically naïve users and seeks to establish a sustainable software ecosystem based on a common integration platform. We discuss those issues and the lessons learned about the kinds of problems that occur, and pathways toward a solution.
Ajinkya Y. Bhave, Bruce Krogh,
David Garlan and
Bradley Schmerl. Multi-domain Modeling of Cyber-Physical Systems using Architectural Views. In Proceedings of the 1st Analytic Virtual Integration of Cyber-Physical Systems Workshop. November 30, 2010. Co-located with RTSS 2010.
Abstract: Designing cyber-physical systems(CPSs)increasingly requires the use of multi-domain models throughout the development process. Ensuring consistent relationships between various system models is an important part of an integrated design methodology. This paper describes an architectural approach to reasoning about relations between heterogeneous system models. The runtime base architecture of the system is used as a unifying representation to compare the structure and semantics of the associated models. Each model is related to the base architecture through the abstraction of an architectural view, which captures structural and semantic correspondences between model elements and system entities. The use of the architectural view framework to relate system models from different domains is illustrated in the context of a quadrotor air vehicle.
Ajinkya Y. Bhave,
David Garlan, Bruce Krogh, Akshay Rajhans and
Bradley Schmerl. Augmenting Software Architectures with Physical Components. In Proceedings of the Embedded Real Time Software and Systems Conference (ERTS^2 2010). May 19-21, 2010.
Abstract: This paper presents an extension of existing software architecture tools to model physical systems, their interconnections, and the interactions between physical and cyber components. We introduce a new cyber-physical system (CPS) architectural style to support the construction of architectural descriptions of complete systems and to serve as the reference context for analysis and evaluation of design alternatives using existing model-based tools. The implementation of the CPS architectural style in AcmeStudio includes behavioral annotations on components and connectors using either finite state processes (FSP) or linear hybrid automata (LHA) with plug-ins to perform behavior analysis. The application of the CPS architectural style is illustrated for the STARMAC quadrotor.
David Garlan. Software Engineering in an Uncertain World. In Proceedings of the FSE/SDP workshop on Future of Software Engineering Research, New York, NY, USA, ACM. FoSER '10, pp. 125--128. 2010.
https://doi.org/10.1145/1882362.1882389. ISBN 978-1-4503-0427-6.
🔗
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: As new market opportunities, technologies, platforms, and frameworks become available, systems require large-scale and systematic architectural restructuring to accommodate them. Today’s architects have few tools and techniques to help them plan this architecture evolution. In particular, they have little assistance in planning alternative evolution paths, trading-off various aspects of the different paths, or knowing best practices for particular domains. In this paper we describe an approach for assisting architects in developing and reasoning about architectural evolution paths. The key in-sight of our approach is that, architecturally, many system evolutions follow certain common patterns – or evolution styles. We define what we mean by an evolution style, and show how it can be used to provide automated assistance for expressing architectural evolution, and for reasoning about both the correctness and quality of evolution paths.
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: Architecture evolution is a key feature of most software systems. There are few tools that help architects plan and execute these evolutionary paths. We demonstrate a tool to enable architects to describe evolution paths, associate properties with elements of the paths, and perform trade-off analysis over these paths.
🥇
Abstract: Rainbow is a framework for engineering a system with run-time, self-adaptive capabilities to monitor, detect, decide, and act on opportunities for system improvement. We applied Rainbow to a system, Znn.com, and evaluated its effectiveness to self-adapt on three levels: its effectiveness to maintain quality attribute in the face of changing conditions, run-time overheads of adaptation, and the engineering effort to use it to add self-adaptive capabilities to Znn.com. We make Znn.com and the associated evaluation tools available to the community so that other researchers can use it to evaluate their own systems and the community can compare different systems. In this paper, we report on our evaluation experience, reflect on some principles for benchmarking self-adaptive systems, and discuss the suitability of our evaluation tools for this purpose.
Abstract: Architecture evolution, a key aspect of software evolution,
is typically done in an ad hoc manner, guided only
by the competence of the architect performing it. This process
lacks the rigor of an engineering discipline. In this
paper, we argue that architecture evolution must be engineered
— based on rational decisions that are supported by
formal models and objective analyses. We believe that evolutions
of a restricted form — close-ended evolution, where
the starting and ending design points are known a priori —
are amenable to being engineered. We discuss some of the
key challenges in engineering close-ended evolution. We
present a conceptual framework in which an architecture
evolutionary trajectory is modeled as a sequence of steps,
each captured by an operator. The goal of our framework is
to support exploration and objective evaluation of different
evolutionary trajectories. We conclude with open research
questions in developing this framework.
Abstract: Rainbow is an approach for engineering self-adaptive systems, with run-time, closed-loop control over target systems to monitor, detect, decide, and act on opportunities for system improvement. RAIDE enables adaptation engineers to customize the Rainbow framework, simulate adaptation behavior, and deploy Rainbow run-time components.
Abstract: This paper presents a framework for engineering resource-adaptive software systems targeted at small
mobile devices. The proposed framework empowers users to control tradeoffs among a rich set of servicespecific
aspects of quality of service. After motivating the problem, the paper proposes a model for
capturing user preferences with respect to quality of service, and illustrates prototype user interfaces to elicit
such models. The paper then describes the extensions and integration work made to accommodate the
proposed framework on top of an existing software infrastructure for ubiquitous computing.
The research question addressed here is the feasibility of coordinating resource allocation and
adaptation policies in a way that end-users can understand and control in real time. The evaluation covered
both systems and the usability perspectives, the latter by means of a user study. The contributions of this
work are: first, a set of design guidelines for resource-adaptive systems, including APIs for integrating new
applications; second, a concrete infrastructure that implements the guidelines. And third, a way to model
quality of service tradeoffs based on utility theory, which our research indicates end-users with diverse
backgrounds are able to leverage for guiding the adaptive behaviors towards activity-specific quality goals.
Abstract: Most pervasive computing technologies focus on helping users with computer-oriented tasks. In this NSF-funded project, we instead focus on using computers to support user-centered “activities” that normally do not involve the use of computers. Examples may include everyday tasks around such as answering the doorbell or doing laundry. A focus on activity-based computing brings to the foreground a number of unique challenges. These include activity definition and representation, system design, interfaces for managing activities, and ensuring robust operation. Our project focuses on the first two challenges.
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.
Abstract: Autonomic, or self-adaptive, systems are increasingly important. One of the most prevalent techniques is to adopt a control systems view of the solution: adding a runtime, separate control unit that monitors and adapts the system under consideration. A problem with this paradigm for system engineering is that the control and the system are loosely coupled, introducing a variety of sources of uncertainty. In this paper we describe three specific sources of uncertainty, and briefly explain how we address those in the Rainbow Project.
Vahe Poladian, Mary Shaw and
David Garlan. Modeling Uncertainty of Predictive Inputs in Anticipatory Dynamic Configuration. In Proceedings of the International Workshop on Living with Uncertainties (IWLU'07), co-located with the 22nd International Conference on Automated Software Engineering (ASE'07),, Atlanta, GA, USA. November 5, 2007.
http://godzilla.cs.toronto.edu/IWLU/program.html.
Abstract: Dynamic adaptive systems based on multiple concurrent applications typically employ optimization models to decide how to allocate scarce resources among the applications and how to tune their runtime settings for optimal quality-of-service according to the preferences of an end user.
Traditionally, such systems have avoided dealing with uncertainty by assuming that current snapshots of the relevant inputs are precise and by solving for an optimal system point. To achieve dynamic behavior, a system performs an optimization loop upon discovering changes in the input variables (e.g. changes in the available level of resources) and adapts the applications according to the new optimal solution. Unfortunately, when certain adaptation actions incur costs, such reactive adaptation strategies suffer from a significant shortcoming: several locally optimal decisions over time may often be less than optimal globally.
By using predictive information about the future values of the problem inputs, we can model and implement an anticipatory adaptation strategy that helps improve the global behavior of the system in many situations. However, modeling predictions requires representing and dealing with uncertainty from different sources. In this paper, we describe our proposed approach to represent multiple sources of uncertainty and outline algorithms for solving the anticipatory configuration problem with predictive inputs.
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.
Abstract: Self-adapting systems based on multiple concurrent applications must decide how to allocate scarce resources to
applications and how to set the quality parameters of each
application to best satisfy the user. Past work has made
those decisions with analytic models that used current resource availability information: they react to recent changes in resource availability as they occur, rather than anticipating future availability. These reactive techniques may model each local decision optimally, but the accumulation of decisions over time nearly always becomes less than optimal.
In this paper, we propose an approach to self adaptation, called anticipatory configuration that leverages
predictions of future resource availability to improve utility for the user over the duration of the task. The approach solves the following technical challenges: (1) how to express resource availability prediction, (2) how to combine prediction from multiple sources, and (3) how to leverage predictions continuously while improving utility to the user. Our experiments show that when certain adaptation operations are costly, anticipatory configuration provides better utility to the user than reactive configuration, while being comparable in resource demand.
Abstract: Over the past decade there has been considerable progress in the development of formal methods to improve our confidence in complex systems. Today the use of such methods in certain fields, such as hardware design, or nuclear power control systems, is de rigueur, with commensurate improvements in quality and reliability.
Regrettably, however, the use of formalism in the medical device domain is relatively sparse. This is due in large part to the perceived difficulty of using formal methods by ordinary engineers and domain specialists, and by the lack of training in how best to apply existing tools to solve the problems faced in that domain.
Over the past few years we have been developing educational materials to help bridge this gap. Specifically we have developed a course in formal modeling for practicing engineers. A core component of this effort is a set of exercises drawn from the medical device domain, which are used to
a) show how formal modeling can be used as an effective technique to improve quality and reliability of software-intensive systems
b) provide guidelines on selecting appropriate modeling approaches for the problem at hand
c) give students hands-on experience in modeling and tool-assisted analysis
In this paper we outline our use of medical device challenge problems in achieving these goals. We argue that such exercises (and the underlying concepts) can go a long way towards bridging the gap between theory and practice, and could be used more generally to improve the state of the practice in developing high-confidence systems, in general, and medical devices, in particular.
Abstract: Text with(bad spacing)and[brackets ].
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.
Abstract: In the world of autonomic computing, the ultimate aim is to automate human tasks in system management to achieve high-level stakeholder objectives. One common approach is to capture and represent human expertise in a form executable by a computer. Techniques to capture such expertise in programs, scripts, or rule sets are effective to an extent. However, they are often incapable of expressing the necessary adaptation expertise and emulating the subtleties of trade-offs in high-level decision making. In this paper, we propose a new language of adaptation that is suffi-ciently expressive to capture the subtleties of choice, deriving its ontology from system administration tasks and its underlying formalism from utility theory.
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: One of the challenges for software architects is ensuring that an implemented system faithfully represents its architecture. We describe and demonstrate a tool, called DiscoTect, that addresses this challenge by dynamically monitoring a running system and deriving the software architecture as that system runs. The derivation process is based on mappings that relate low level system-level events to higher-level architectural events. The resulting architecture is then fed into existing architectural design tools so that comparisons can be conducted with the design time architecture and architectural analyses can be re-run to ensure that they are still valid. In addition to the demonstration, we briefly describe the mapping language and formal definition of the language in terms of Colored Petri Nets.
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.
João Sousa,
Vahe Poladian,
David Garlan and
Bradley Schmerl. Capitalizing on Awareness of User Tasks for Guiding Adaptation. In Proceedings of the First International Workshop on Adaptive and Self-managing Enterprise Applications, at CAISE'05, Portugal. 2005.
Abstract: Computers support more and more tasks in the personal and professional activities of users. Such user tasks increasingly span large periods of time and many locations across the enterprise space and beyond. Recently there has been a growing interest in developing applications that can cope with the specific environmental conditions at each location, and adapt to dynamic changes in system resources. However, in a given situation there may be many possible configuration solutions, and an awareness of the user's intent for each task is a critical element in knowing which one to pick. In this paper, we discuss the limitations of building such awareness into applications, and propose to factor the awareness of user tasks into a common software layer. That however, brings up the problem of coordinating the system-wide adaptation performed by such a layer with fine-grain adaptation performed by resource-aware applications. We summarize the main features of an architectural framework that incorporates such a layer, and distill some of the lessons learned in implementing the framework.
Shang-Wen Cheng,
David Garlan and
Bradley Schmerl. Making Self-Adaptation an Engineering Reality. In Proceedings of the Conference on Self-Star Properties in Complex Information Systems, Ozlap Babaoghu, Mark Jelasity, Alberto Montroser, Christof Fetzer, Stefano Leonardi and Aad Van Moorsel (Eds.), Springer-Verlag. LNCS, Vol. 3460. 2005. Also available from Springer-Verlag
here.
Abstract: In this paper, we envision a world where a software engineer could take an existing software system, specify, for a set of properties of interest, an objective, conditions for change, and strategies for their adaptation and, within a few man weeks, make that system self-adaptive where it was not before. We describe how our approach generalizes to different classes of systems and holds promise for cost-effective, dynamic system self-adaptation to become an engineering reality.
Abstract: Recently there has been increasing interest in developing systems that can adapt dynamically to cope with changing environmental conditions and unexpected system errors. Most efforts for achieving self-adaptation have focused on the mechanisms for detecting opportunities for improvement and then taking appropriate action. However, such mechanisms beg the question: what is the system trying to achieve? In a given situation there may be many possible adaptations, and knowing which one to pick is a difficult question. In this paper we advocate the use of explicit representation of user task as a critical element in addressing this missing link.
Abstract: A common approach to adding self-management capabilities to a system is to provide one or more external control modules, whose responsibility is to monitor system behavior, and adapt the system at run time to achieve various goals (configure the system, improve performance, recover from faults, etc.). An important problem arises when there is more than one such self-management module: how can one make sure that they are composed to provide consistent and complementary benefits? In this paper we describe a solution that introduces a self-management coordination architecture and infrastructure to support such composition. We focus on the problem of coordinating self-configuring and self-healing capabilities, particularly with respect to global configuration and incremental repair. We illustrate the approach in the context of a self-managing video teleconference system that composes two pre-existing adaptation modules to achieve synergistic benefits of both.
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.
Abstract: An important emerging requirement for computing systems is the ability to adapt at run time, taking advantage of local computing devices, and coping with dynamically changing resources. Three specific technical challenges in satisfying this requirement are to (1) select an appropriate set of applications or services to carry out a user s task, (2) allocate (possibly scarce) resources among those applications, and (3) reconfigure the applications or resource assignments if the situation changes. In this paper we show how to provide a shared infrastructure that automates configuration decisions given a specification of the user s task. The heart of the approach is an analytical model and an efficient algorithm that can be used at run time to make near-optimal (re)configuration decisions. We validate this approach both analytically and by applying it to a representative scenario.
Abstract: One crucial aspect of high quality software engineering is the development of a welldefined software architectural model. Despite advances in using software architectural models to clarify system design, there remains the problem of determining whether the system as implemented has the architecture as designed? One approach is to to this is to monitor the running system and translate observed events to events that construct and update an architectural model that reflects the actual running system. One can then compare this dynamically-determined model to the correct architectural model. Discrepancies can be used to flag implementation errors, or, possibly, to effect run-time adaptations to correct certain kinds of flaws. At Carnegie Mellon University, our research group has been investigating the use of system monitoring and reflection using architectural models. In the process of exploring this area we have identified a number of significant research challenges. In this paper we outline our experience, and use that as a way to lay out an agenda for architecture-based approaches to system monitoring and system self-repair.
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.
Barry Boehm, Jesal Bhuta,
David Garlan, Eric Gradman, LiGuo Huang, Alexander Lam, Ray Madachy, Nenad Medvidovic, Kenneth Meyer, Steven Meyers, Gustavo Perez, Kirk Reinholtz, Roshanak Roshandel and Nicolas Rouquette. Using Empirical Testbeds to Accelerate Technology Maturity and Transition: The SCRover Experience. In International Symposium on Empirical Software Engineering, Los Alamitos, CA, USA, IEEE Computer Society. pp. 117-126. 2004.
https://doi.org/10.1109/isese.2004.1334899. ISBN 0-7695-2165-7.
Abstract: This paper is an experience report on a first attempt
to develop and apply a new form of software: a fullservice
testbed designed to evaluate alternative software
dependability technologies, and to accelerate their
maturation and transition into project use. The SCRover
testbed includes not only the specifications, code, and
hardware of a public safety robot, but also the package of
instrumentation, scenario drivers, seeded defects,
experimentation guidelines, and comparative effort and
defect data needed to facilitate technology evaluation
experiments.
The SCRover testbed’s initial operational capability
has been recently applied to evaluate two architecture
definition languages (ADLs) and toolsets, Mae and
AcmeStudio. The testbed evaluation showed (1) that the
ADL-based toolsets were complementary and costeffective
to apply to mission-critical systems; (2) that the
testbed was cost-effective to use by researchers; and (3)
that collaboration in testbed use by researchers and the
Jet Propulsion Laboratory (JPL) project users resulted in
actions to accelerate technology maturity and transition
into project use. The evaluation also identified a number
of lessons learned for improving the SCRover testbed,
and for development and application of future technology
evaluation testbeds.
Abstract: While publish-subscribe systems have good engineering properties, they are difficult to reason about and to test. Model checking such systems is an attractive alternative. However, in practice coming up with an appropriate state model for a pub-sub system can be a difficult and error-prone task. In this paper we address this problem by describing a generic pub-sub model checking framework. The key feature of this framework is a reusable, parameterized state machine model that captures pub-sub runtime event management and dispatch policy. Generation of models for specific pub-sub systems is then handled by a translation tool that accepts as input a set of pub-sub component descriptions together with a set of pub-sub properties, and maps them into the framework where they can be checked using off-the-shelf model checking tools.
Vahe Poladian, Shawn Butler, Mary Shaw and
David Garlan. Time is Not Money: The case for multi-dimensional accounting in value-based software engineering. In Fifth Workshop on Economics-Driven Software Engineering Research (EDSER-5). May, 2003.
Abstract: 'Time is money', or so goes the old saying. Perhaps influenced by this aphorism, some strategies for incorporating costs in the analysis of software design express all costs in currency units for reasons of simplicity and tractability. Indeed, in theoretical economics all costs can, in principle, be expressed in dollars. Software engineering problems, however, often present situations in which converting all costs to a common currency is problematical. In this paper we pinpoint some of these situations and the underlying causes of the problems, and we argue that it is often better to treat costs as a multidimensional value, with dimensions corresponding to distinct types of resources. We go on to highlight the differences among cost dimensions that need to be considered when developing cost-benefit analyses, and we suggest mechanisms for mediating among heterogeneous cost dimensions.
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.
Vahe Poladian,
David Garlan and Mary Shaw. Selection and Configuration in Mobile Environments: A Utility-Based Approach. In Fourth Workshop on Economics-Driven Software Engineering Research (EDSER-4). May, 2002.
Abstract: Users of low-power mobile computing platforms make ad hoc decisions when choosing software components among alternatives and configuring those components. We propose applying utility-theoretic models, which can help determine optimal allocation of scarce resources to applications given the user's utility and application resource usage. We believe that taking into consideration resource consumption and applying microeconomic models has the potential of improving the user's satisfaction with the system. In this paper, we formulate the problem, demonstrate the use of a microeconomics-based model on a simple version of the problem, and list possible solutions. Further, we identify issues typical of mobile environments that are not addressed by existing research, and propose ways of tackling these issues.
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.
Nicolas Rouquette, Nenad Medvidovic and
David Garlan. Dependable Autonomous Systems = knowing well what to do + knowing how to do it well. In Proceedings of the NASA High Dependability Computing Consortium Workshop, NASA AMES, Moffett Field, CA. January 10-12, 2001.
Abstract: This position paper reflects upon experiences and lessons learned from several spacecraft projects at JPL and JPL's recent collaboration with software architecture researchers from USC and CMU.
Abstract: While implicit invocation (publish-subscribe) systems have good engineering properties, they are difficult to reason about and to test. Model checking such systems is an attractive alternative. However, it is not clear what kinds of state models are best suited for this. In this paper we propose a structural approach, which factors the model checking problem into two parts: behavior specific to a particular implicit invocation system, and reusable runtime infrastructure that handles event-based communication and delivery policies. The reusable portion is itself structured so that alternative runtime mechanisms may be experimented with.
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.
Jurgen Dingel,
David Garlan, Somesh Jha and David Notkin. Reasoning about Implicit Invocation. In Proceedings of the Sixth International Symposium on the Foundations of Software Engineering (FSE-6), Lake Buena Vista, Florida. November, 1998.
https://doi.org/10.1145/288195.288312.
Abstract: Implicit invocation has become an important architectural style for large-scale system design and evolution. This paper addresses the lack of specication and verication formalisms for such systems. Based on standard notions from process algebra and trace semantics, we dene a formal computational model for implicit invocation. A verication methodology is presented that supports linear time temporal logic and compositional reasoning. First, the entire system is partioned into groups of components (methods) that behave independently. Then, local properties are proved for each of the groups. A precise description of the cause and the eect of an event supports this step. Using local correctness, independence of groups, and properties of the delivery of events, we infer the desired property of the overall system. Two detailed examples illustrate the use of our framework.
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.
Abstract: Many software designs are produced by combining and elaborating existing architectural design fragments. These fragments may be design patterns, partially thought-out ideas, or portions of some previously-developed system design. To provide mechanized support for this activity it is necessary to have a precise characterization of when and how two or more architectural fragments can be combined. In this paper we describe extensions to notations for software architecture to represent incomplete design fragments, and algorithms for combining fragments in a process analogous to unification in logic.
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.
David Garlan. Style-Based Refinement for Software Architecture. In Joint Proceedings of the Second International Software Architecture Workshop (ISAW2) and the International Workshop on Multiple Perspectives in Software Development (Viewpoints '96), San Francisco, CA, ACM Press. October, 1996.
https://doi.org/10.1145/243327.243607.
Abstract: A question that frequently arises for architectural design is 'When can I implement a design in style S1 using a design in style S2?' In this paper I propose a technique for structuring a solution to this kind of problem using the idea of substyles. This technique leads to a two-step process in which first, useful subsets of a family of architectures are identified, and second, refinement rules specific to these subsets are established. I will argue that this technique, in combination with an unconventional interpretation of refinement, clarifies how engineers actually carry out architectural refinement and provides a formal framework for establishing the correctness of those methods.
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.
Robert Allen and
David Garlan. A Case Study in Architectural Modelling: The AEGIS System. In Proceedings of the Eighth International Workshop on Software Specification and Design (IWSSD-8), Paderborn, Germany. pp. 6-15. March, 1996.
https://doi.org/10.1109/IWSSD.1996.501142.
Abstract: Software architecture is receiving increasingly attention as a critical design level for software systems. However, the current practice of architectural description is largely informal and ad hoc, with the consequence that architectural documents serve as a poor communication mechanism, are difficult to analyze, and may have very little relationship to the implemented system. In an attempt to address these problems several researchers have experimented with formalisms for architectural specification and modelling. One such formalism is Wright. In this paper we show how Wright can be used to provide insight into an architectural design by modelling a prototype implementation of part of the AEGIS Weapons System.
🏅
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.
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.
Abstract: A critical issue in the design of a professional software engineering degree program is the way in which formal methods are integrated into the curriculum. The approach taken by most programs is to teach formal techniques for software development in a separate course on formal methods. In this paper we detail some of the problems with that approach and describe an alternative in which formal methods are integrated across the curriculum. We illustrate the strengths and weaknesses of this alternative in terms of our experience of using it in the Master of Software Engineering Program at Carnegie Mellon University.
🏆
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.
David Notkin,
David Garlan, William Griswold and Kevin Sullivan. Adding Implicit Invocation to Languages: Three Aproaches. In Proceedings of the JSSST Symp. Object Technologies for Advanced Software, Spring-Verlag. Lecture Notes in Computer Science, Vol. 742. November, 1993.
https://doi.org/10.1007/3-540-57342-9_91.
Abstract: Implicit invocation based on event announcement is an increasingly important technique for integrating systems. However, the use of this technique has largely been confined to tool integration systems---in which tools exist as independent processes---and special-purpose languages---in which specialized forms of event broadcast are designed into the language from the start. This paper broadens the class of systems that can benefit from this approach by showing how to augment general-purpose programming languages with facilities for implicit invocation. We illustrate the approach in the context of three different languages, Ada, C++, and Common Lisp. The intent is to highlight the key design considerations that arise in extending such languages with implicit invocation.