Home   Research Publications Members Related Software
IndexBrowse   BibliographiesMy selection
 Search: in   (word length ≥ 3)
      Login
All publications   ( Html | Bibtex | Both )   Download bibtex file Order by:   Type | Year
<< 2014 >> TOP
1
@Article{Barnes/AEVol/2012,
      AUTHOR = {Barnes, Jeffrey M. and Garlan, David and Schmerl, Bradley},
      TITLE = {Evolution styles: foundations and models for software architecture evolution},
      YEAR = {2014},
      MONTH = {May},
      JOURNAL = {Journal of Software and Systems Modeling},
      VOLUME = {13},
      NUMBER = {2},
      PAGES = {649-678},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/sosym.pdf},
      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 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 planning and reasoning about architecture evolution. Our approach focuses on providing architects with the means to model prospective evolution paths and supporting analysis to select among these candidate paths. To demonstrate the usefulness of our approach, we show how it can be applied to an actual architecture evolution. In addition, we present some theoretical results about our evolution path constraint specification language.},
      NOTE = {DOI 10.1007/s10270-012-0301-9},
      KEYWORDS = {Architecture Evolution, Landmark}
}
2
@Article{Rajhans/TAC/2013,
      AUTHOR = {Rajhans, Akshay and Bhave, Ajinkya Y. and Ruchkin, Ivan and Krogh, Bruce and Garlan, David and Platzer, Andre and Schmerl, Bradley},
      TITLE = {Supporting Heterogeneity in Cyber-Physical Systems Architectures},
      YEAR = {2014},
      JOURNAL = {IEEE Transactions on Automatic Control's Special Issue on “Control of Cyber-Physical Systems” },
      ABSTRACT = {Cyber-physical systems (CPS) are heterogeneous, because they tightly couple computation, communication and control along with physical dynamics, which are traditionally considered separately. Without a comprehensive modeling formalism, model-based development of CPS involves using a multitude of models in a variety of formalisms that capture various aspects of the system design, such as software design, networking design, physical models, and protocol design. Without a rigorous unifying framework, system integration and integration of the analysis results for various models remains ad hoc. In this paper, we propose a multi-view architecture framework that treats models as views of the underlying system structure and uses structural and semantic mappings to ensure consistency and enable system-level verification from that of the models in a hierarchical and compositional manner. Throughout the paper, the theoretical concepts are illustrated using two examples, an automotive intersection collision avoidance system and a quadrotor.},
      NOTE = {To appear},
      KEYWORDS = {Cyberphysical Systems}
}
3
@TechReport{Schmerl/MTD/2014,
      AUTHOR = {Schmerl, Bradley and Cámara, Javier and Moreno, Gabriel A. and Garlan, David and Mellinger, Andrew},
      TITLE = {Architecture-Based Self-Adaptation for Moving Target Defense},
      YEAR = {2014},
      NUMBER = {CMU-ISR-14-109},
      INSTITUTION = {Institute for Software Research, Carnegie Mellon University},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/CMU-ISR-14-109.pdf},
      ABSTRACT = {The fundamental premise behind Moving Target Defense (MTD) is to create a dynamic and shifting system that is more difficult to attack than a static system because a constantly changing attack surface at least reduces the chance of an attacker finding and exploiting the weakness. However, MTD approaches are typically chosen without regard to other qualities of the system, such as performance or cost. This report explores the use of self-adaptive systems, in particular those based on the architecture of the running system. A systems software architecture can be used to trade off different quality dimensions of the system. In particular, this report describes the first steps in reasoning formally about MTD approaches, and elevating this reasoning to an architectural level, along three thrusts: (1) creating an initial catalog of MTD tactics that can be used at the architectural level, along with the impacts on security and other quality concerns, (2) using this information to inform proactive self-adaptation that uses predictions of tactic duration to improve the self-adaptation, and (3) using stochastic multiplayer games to verify the the behavior of a variety of MTD scenarios, from uninformed to predictive-reactive. This work is applied in the context of the Rainbow self-adaptive framework.},
      KEYWORDS = {Rainbow, Science of Security, Self-adaptation, Software Architecture}
}
4
@InProceedings{2013/Casanova/Unobserved,
      AUTHOR = {Casanova, Paulo and Garlan, David and Schmerl, Bradley and Abreu, Rui},
      TITLE = {Diagnosing Unobserved Components in Self-Adaptive Systems},
      YEAR = {2014},
      MONTH = {2-3 June},
      BOOKTITLE = {9th International Symposium on Software Engineering for Adaptive and Self-Managing Systems},
      ADDRESS = {Hyderabad, India},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/unobserved2013_Casanova_Unobserved.pdf},
      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.},
      KEYWORDS = {Diagnosis, Self-adaptation}
}
5
@InProceedings{2014/Dwivedi/Mutlifidelity,
      AUTHOR = {Dwivedi, Vishal and Garlan, David and Pfeffer, Jürgen and Schmerl, Bradley},
      TITLE = {Model-based Assistance for Making Time/Fidelity Trade-offs in Component Compositions},
      YEAR = {2014},
      MONTH = {7-9 April},
      BOOKTITLE = {11th International Conference on Information Technology : New Generations (ITNG 2014), Special track on: MDCBSE: Model-Driven, Component-Based Software Engineering},
      ADDRESS = {Las Vegas, NV},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/ITNGpaper.pdf},
      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.},
      KEYWORDS = {Acme, End-user Architecture, Model Checking, Mult-fidelity Applications, Resource Aware Computing}
}
6
@Article{Kang/2014/IJSEKE,
      AUTHOR = {Kang, Sungwon and Garlan, David},
      TITLE = {Architecture-based planning of software evolution},
      YEAR = {2014},
      JOURNAL = {International Journal of Software Engineering and Knowledge Engineering},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/evolutionPlanning.pdf},
      ABSTRACT = {Software architecture allows us to make many decisions about a software system and analyze it even before it has been implemented, so as to make planned development possible. Similarly, architecture-based software evolution planning makes planned evolution possible by allowing us to make many decisions about the evolution of a software system and to analyze its evolution at the level of architecture design before software evolution is realized. In this paper, we develop a framework for architecture-based software evolution planning. It is done by defining various foundational terms and concepts, providing a taxonomy of software evolution plans, and then showing how to calculate values for various types of plans. By identifying and defining constituent foundational concepts, this conceptual framework makes precise the notion of ‘architecture-based software planning’. By developing a value-calculation framework for software evolution plans, it also provides a basis for concrete methods for designing and evaluating evolution plans.},
      NOTE = {Accepted for publication},
      KEYWORDS = {Architecture Evolution}
}
7
@InProceedings{2014/Schmerl/ABSP-DoS,
      AUTHOR = {Schmerl, Bradley and Cámara, Javier and Gennari, Jeffrey and Garlan, David and Casanova, Paulo and Moreno, Gabriel A. and Glazier, Thomas J. and Barnes, Jeffrey M.},
      TITLE = {Architecture-Based Self-Protection: Composing and Reasoning about Denial-of-Service Mitigations},
      YEAR = {2014},
      MONTH = {8-9 April},
      BOOKTITLE = {HotSoS 2014: 2014 Symposium and Bootcamp on the Science of Security},
      ADDRESS = {Raleigh, NC, USA},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/absp-dos.pdf},
      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 e ffect 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.},
      KEYWORDS = {Autonomic Systems, Model Checking, Rainbow, Science of Security, Self-adaptation, Stitch}
}
8
@InProceedings{Camara/Stochastic/2014,
      AUTHOR = {Cámara, Javier and Moreno, Gabriel A. and Garlan, David},
      TITLE = {Stochastic Game Analysis and Latency Awareness for Proactive Self-Adaptation},
      YEAR = {2014},
      MONTH = {2-3 June},
      BOOKTITLE = {9th International Symposium on Software Engineering for Adaptive and Self-Managing Systems},
      ADDRESS = {Hyderabad, India},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/stochastic-proactive.pdf},
      ABSTRACT = {Although diff erent approaches to decision-making in self- adaptive systems have shown their e ffectiveness 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, di fferent adaptation tactics can take diff erent 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 di fferent 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.},
      KEYWORDS = {Model Checking, Self-adaptation}
}
9
@Unpublished{Barnes/2014,
      AUTHOR = {Barnes, Jeffrey M.},
      TITLE = {An Interview-Based Case Study in Software Architecture Evolution},
      YEAR = {2014},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/arch-evol-case-study.pdf},
      ABSTRACT = {In recent years, researchers have worked to develop approaches and models to support software architects in planning and carrying out major evolutions of software systems. To date, this line of work has been largely theoretical. These new approaches and models are seldom accompanied by empirical evidence to support them, let alone subjected to rigorous empirical evaluation. This paper describes a formal case study examining architecture evolution in a real-world organization. Based on content analysis of interview data and architectural documentation, the study examines how practicing architects plan and reason about evolution, what challenges they face, and whether the modeling approach developed in our previous work can capture the concerns that arise in a real-world evolution.},
      NOTE = {Submitted for Publication}
}
10
@InProceedings{2014/Ruchkin/CBI,
      AUTHOR = {Ruchkin, Ivan and De Niz, Dio and Chaki, Sagar and Garlan, David},
      TITLE = {Contract-Based Integration of Cyber-Physical Analyses},
      YEAR = {2014},
      MONTH = {12-17 October},
      BOOKTITLE = {Embedded Systems Week},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/paper-camera-ready-ieee-verified-178-EM82.pdf},
      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.},
      NOTE = {To appear},
      KEYWORDS = {Cyberphysical Systems}
}
11
@InProceedings{Garlan:2014:SAT:2593882.2593886,
      AUTHOR = {Garlan, David},
      TITLE = {Software Architecture: A Travelogue},
      YEAR = {2014},
      BOOKTITLE = {Proceedings of the on Future of Software Engineering},
      PAGES = {29--39},
      SERIES = {FOSE 2014},
      ADDRESS = {New York, NY, USA },
      PUBLISHER = {ACM},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/GarlanFOSE-Final-Rev.pdf},
      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},
      NOTE = {ISBN 978-1-4503-2865-4. Also available from ACM DOI: 10.1145/2593882.2593886.}
}
12
@TechReport{ruchkin_architectural_2014,
      AUTHOR = {Ruchkin, Ivan and Dwivedi, Vishal and Garlan, David and Schmerl, Bradley},
      TITLE = {Architectural Modeling of Ozone Widget Framework End-User Compositions},
      YEAR = {2014},
      MONTH = {June},
      NUMBER = {CMU-ISR-14-108},
      ADDRESS = {Pittsburgh, PA},
      TYPE = {Technical Report},
      INSTITUTION = {Institute for Software Research, Carnegie Mellon University},
      URL = {http://reports-archive.adm.cs.cmu.edu/anon/isr2014/abstracts/14-108.html},
      ABSTRACT = {Ozone Widget Framework (OWF) is an event-based web platform for lightweight integration of widget applications. This technical report presents a formal model of OWF’s widget composition mechanism. First, we present a detailed description of Ozone’s end user composition mechanism. Then, we describe our architectural modeling approach and its value for analysis of OWF widget compositions. We go through the process of creating an architectural style to represent assemblies of Ozone widgets, reviewing modeling decision points and style alternatives.}
}
13
@InProceedings{Camara/SAC/2014,
      AUTHOR = {Cámara, Javier and de Lemos, Rogério and Larangeiro, Nuno and Ventura, Rafael and Vieira, Marco},
      TITLE = {Robustness Evaluation of the Rainbow Framework for Self-Adaptation},
      YEAR = {2014},
      MONTH = {24-28 March},
      BOOKTITLE = {The 29th Annual ACM Symposium on Applied Computing},
      ADDRESS = {Gyeongju, Korea},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/SAC2014.pdf},
      ABSTRACT = {Self-adaptive (or autonomic) systems incorporate complex software components that act as controllers of a target system by executing actions through eff ectors, based on information monitored by probes. Despite the growing importance and criticality of controllers in many application domains, a central concern about them is the diculty in assessing their robustness when architecting self-adaptive systems. In previous work, we proposed an approach for evaluating the robustness of controllers in self-adaptive systems. In this practical experience report, we describe a comprehensive evaluation of the robustness of a particular controller, in our case Rainbow, in the context of two case studies: a benchmark case study that reproduces the typical infrastructure for a news website, and an industrial middleware for monitoring populated networks of devices. The aim of this work is to assess to what extent the use of a diff erent target system has an impact on the robustness of the controller, which has to be customized in diff erent ways, and may need to resort to the activation of diff erent features, depending on the particular target system. Our analysis concludes that the customization of Rainbow (the controller) has little impact on its robustness because of the way the controller was designed and built, and this modularization of non-functional requirements is indeed encouraging when architecting self-adaptive systems.},
      KEYWORDS = {Rainbow}
}
14
@InProceedings{Camara/2014/Qosa,
      AUTHOR = {Cámara, Javier and Correia, Pedro and de Lemos, Rogério and Vieira, Marco},
      TITLE = {Empirical Resilience Evaluation of an Architecture-based Self-Adaptive Software System},
      YEAR = {2014},
      MONTH = {30 June - 3 July},
      BOOKTITLE = {Tenth International ACM Sigsoft Conference on the Quality of Software Architectures},
      ADDRESS = {Lille, France},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/QoSA14.pdf},
      ABSTRACT = {Architecture-based self-adaptation is considered as a promising approach to drive down the development and opera- tion costs of complex software systems operating in ever changing environments. However, there is still a lack of evidence supporting the arguments for the bene ficial impact of architecture-based self-adaptation on resilience with respect to other customary approaches, such as embedded code-based adaptation. In this paper, we report on an empirical study about the impact on resilience of incorporating architecture-based self-adaptation in an industrial middleware used to collect data in highly populated networks of devices. To this end, we compare the results of resilience evaluation between the original version of the middleware, in which adaptation mechanisms are embedded at the code- level, and a modifi ed version of that middleware in which the adaptation mechanisms are implemented using Rainbow, a framework for architecture-based self-adaptation. Our results show improved levels of resilience in architecture-based compared to embedded code-based self-adaptation.},
      NOTE = {ACM SIGSOFT QoSA Distinguished Paper Award},
      KEYWORDS = {Rainbow, Self-adaptation}
}
15
@InProceedings{Camara/FACS2014,
      AUTHOR = {Cámara, Javier and Lopes, Antonia and Garlan, David and Schmerl, Bradley},
      TITLE = {Impact Models for Architecture-Based Self-Adaptive Systems},
      YEAR = {2014},
      MONTH = {10-12 September},
      BOOKTITLE = {Proceedings of the 11th International Symposium on Formal Aspects of Component Software (FACS2014)},
      ADDRESS = {Bertinoro, Italy},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/LGC-IM-submitted.pdf},
      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.},
      NOTE = {To appear},
      KEYWORDS = {Autonomic Systems, Rainbow, Self-adaptation, Self-awareness & Adaptation, Stitch}
}
<< 2013 >> TOP
16
@InProceedings{2013:Camara/Correia,
      AUTHOR = {Cámara, Javier and Correia, Pedro and de Lemos, Rogério and Garlan, David and Gomes, Pedro and Schmerl, Bradley and Ventura, Rafael},
      TITLE = {Evolving an Adaptive Industrial Software System to Use Architecture-based Self-Adaptation},
      YEAR = {2013},
      MONTH = {20-21 May},
      BOOKTITLE = {Proceedings of the 8th International Symposium on Software Engineering for Adaptive and Self-Managing Systems},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/eaisabsa.pdf},
      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.},
      KEYWORDS = {Rainbow}
}
17
@InProceedings{Velasco/Mismatch/2013,
      AUTHOR = {Velasco Elizondo, Perla and Dwivedi, Vishal and Garlan, David and Schmerl, Bradley and Maria Fernandes, Jose},
      TITLE = {Resolving Data Mismatches in End-User Compositions},
      YEAR = {2013},
      MONTH = {10-13 June},
      BOOKTITLE = {Proceedings of the 4th International Symposium on End-User Development},
      ADDRESS = {IT University of Copenhagen, Denmark},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/resolvingDataMismatchesVelasco_Mismatch_2013.pdf},
      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.},
      KEYWORDS = {End-user Architecture, SORASCS}
}
18
@InProceedings{2013:Casanova/Garlan,
      AUTHOR = {Casanova, Paulo and Garlan, David and Schmerl, Bradley and Abreu, Rui},
      TITLE = {Diagnosing architectural run-time failures},
      YEAR = {2013},
      MONTH = {20-21 May},
      BOOKTITLE = {Proceedings of the 8th International Symposium on Software Engineering for Adaptive and Self-Managing Systems},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/darf.pdf},
      ABSTRACT = {Self-diagnosis is a fundamental capability of selfadaptive 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 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 in a system and accurately diagnosing them using our algorithm.},
      NOTE = {Received SEAMS 2013 Best Paper Award},
      KEYWORDS = {Diagnosis, Self-adaptation}
}
19
@InProceedings{Yuan/2013/ABSS,
      AUTHOR = {Yuan, Eric and Malek, Sam and Schmerl, Bradley and Garlan, David and Gennari, Jeffrey},
      TITLE = {Architecture-Based Self-Protecting Software Systems},
      YEAR = {2013},
      MONTH = {17-21 June},
      BOOKTITLE = {Proceedings of the Ninth International ACM Sigsoft Conference on the Quality of Software Architectures (QoSA 2013)},
      PAGES = {33-42},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/p33-yuan.pdf},
      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.},
      NOTE = {DOI: 10.1145/2465478.2465479},
      KEYWORDS = {Rainbow, Science of Security, Self-adaptation}
}
20
@InProceedings{2013:Barnes/TOPI,
      AUTHOR = {Barnes, Jeffrey M. and Garlan, David},
      TITLE = {Challenges in Developing a Software Architecture Evolution Tool as a Plug-In},
      YEAR = {2013},
      MONTH = {21 May},
      BOOKTITLE = {Proceedings of the 3rd Workshop on Developing Tools as Plug-Ins},
      PAGES = {13--18},
      ADDRESS = {San Francisco, CA, USA},
      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.},
      KEYWORDS = {Architecture Evolution}
}
21
@Unpublished{2013:Casanova/Samsung,
      AUTHOR = {Casanova, Paulo and Schmerl, Bradley and Garlan, David and Abreu, Rui and Ahn, Jungsik},
      TITLE = {Applying Autonomic Diagnosis at Samsung Electronics},
      YEAR = {2013},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/DiagnosisSamsung.pdf},
      ABSTRACT = {An increasingly essential aspect of many critical software systems is the ability to quickly diagnose and locate faults so that appropriate corrective measures can be taken. Large, complex software systems fail unpredictably and pinpointing the source of the failure is a challenging task. In this paper we explore how our recently developed technique for automatic diagnosis performs in the automatic detection of failures and fault localization in a critical manufacturing control system of Samsung Electronics, where failures can result in large financial and schedule losses. We show how our approach can scale to such systems to diagnose intermittent faults, connectivity problems, protocol violations, and timing failures. We propose a set of measures of accuracy and performance that can be used to evaluate run-time diagnosis. We present lessons learned from this work including how instrumentation limitations may impair diagnosis accuracy: without overcoming these, there is a limit to the kinds of faults that can be detected.},
      NOTE = {Submitted for Publication},
      KEYWORDS = {Autonomic Systems, Diagnosis}
}
22
@InCollection{Lemos13,
      AUTHOR = {de Lemos, Rogério and Giese, Holger and Muller, Hausi A. and Shaw, Mary and Andersson, Jesper and Baresi, Luciano and Becker, Basil and Bencomo, Nelly and Brun, Yuriy and Cukic, Bojan and Desmarais, Ron and Dustdar, Schahram and Engels, Gregor and Geihs, Kurt and Goeschka, Karl M. and Gorla, Alessandra and Grassi, Vincenzo and Inverardi, Paola and Karsai, Gabor and Kramer, Jeff and Litoiu, Marin and Lopes, Antonia and Magee, Jeff and Malek, Sam and Mankovskii, Serge and Mirandola, Raffaela and Mylopoulos, John and Nierstrasz, Oscar and Pezzè, Mauro and Prehofer, Christian and Schafer, Wilhelm and Schlichting, Rick and Schmerl, Bradley and Smith, Dennis B. and Sousa, João Pedro and Tamura, Gabriel and Tahvildari, Ladan and Villegas, Norha M. and Vogel, Thomas and Weyns, Danny and Wong, Kenny and Wuttke, Jochen},
      TITLE = {Software engineering for self-adaptive systems: A second research roadmap},
      YEAR = {2013},
      BOOKTITLE = {Software Engineering for Self-Adaptive Systems II},
      VOLUME = {7475},
      PAGES = {1--32},
      EDITOR = {de Lemos, Rogério and Giese, Holger and Muller, Hausi A. and Shaw, Mary},
      PUBLISHER = {Springer-Verlag},
      ABSTRACT = {The goal of this roadmap paper is to summarize the state-of-the-art and identify research challenges when developing, deploying and managing self-adaptive software systems. Instead of dealing with a wide range of topics associated with the field, we focus on four essential topics of self-adaptation: design space for self-adaptive solutions, software engineering processes for self-adaptive systems, from centralized to decentralized control, and practical run-time verification & validation for self-adaptive systems. For each topic, we present an overview, suggest future directions, and focus on selected challenges. This paper complements and extends a previous roadmap on software engineering for self-adaptive systems published in 2009 covering a different set of topics, and reflecting in part on the previous paper. This roadmap is one of the many results of the Dagstuhl Seminar 10431 on Software Engineering for Self-Adaptive Systems, which took place in October 2010.},
      KEYWORDS = {Self-adaptation}
}
23
@TechReport{Cataldo:2013/SBE,
      AUTHOR = {Cataldo, Marcelo and Garlan, David and Herbsleb, James and McConahy, Amber Lynn and Park, Young-Suk Ahn and Schmerl, Bradley},
      TITLE = {Software Platforms for Smart Building Ecosystems: Understanding the Key Architectural Capabilities and Trade-offs},
      YEAR = {2013},
      NUMBER = {CMU-ISR-13-104},
      INSTITUTION = {Institute for Software Research, Carnegie Mellon University},
      KEYWORDS = {Software Architecture}
}
24
@InProceedings{Barnes:2013/EvolutionPlanning,
      AUTHOR = {Barnes, Jeffrey M. and Pandey, Ashutosh and Garlan, David},
      TITLE = {Automated Planning for Software Architecture Evolution},
      YEAR = {2013},
      MONTH = {11-15 November},
      BOOKTITLE = {The 28th IEEE/ACM International Conference on Automated Software Engineering},
      ADDRESS = {Silicon Valley, CA},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/ASE2013-final.pdf},
      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.},
      KEYWORDS = {Architecture Evolution}
}
25
@TechReport{Barnes/CaseStudy2013,
      AUTHOR = {Barnes, Jeffrey M.},
      TITLE = {Case Study Report: Architecture Evolution at Costco},
      YEAR = {2013},
      NUMBER = {CMU-ISR-13-116},
      INSTITUTION = {Institute for Software Research, School of Computer Science, Carnegie Mellon University},
      ABSTRACT = {Many software systems eventually undergo changes to their basic architectural structure. As systems age, they often require redesign in order to accommodate new requirements, support new technologies, or respond to changing market conditions. At present, however, software architects lack tools to assist them in developing plans for carrying out such evolution. In previous research, we have developed an approach to support architects in reasoning about evolution. Our approach is based on formally modeling and reasoning about possible evolution paths—sequences of transitional architectures leading from the current state to some desired target architecture. To date, much of this work has been theoretical in character. We have focused our efforts on the definition and elaboration of a theoretical framework for architecture evolution, and have done relatively little work on applying this theoretical research in practical contexts. This report presents a case study examining architecture evolution in depth in a real-world software organization: the IT division of a major global retailer. Based on content analysis of interview data and architectural documentation, the case study examines how practicing architects plan and reason about evolution, what challenges they face in doing so, and whether our modeling approach is adequate for capturing the concerns that arise in a real-world evolution. It finds that architects face a variety of pressing challenges in planning evolutions of major software systems, and use a variety of techniques to manage these challenges. It further finds that most of the major considerations that architects described in connection within a specific evolution can be successfully modeled using our approach, suggesting that the conceptual framework and specification languages that we have developed are expressive enough to be applicable to a real-world architecture evolution.},
      KEYWORDS = {Architecture Evolution}
}
26
@PhdThesis{Barnes/Thesis/2013,
      AUTHOR = {Barnes, Jeffrey M.},
      TITLE = {Software Architecture Evolution},
      YEAR = {2013},
      SCHOOL = {Institute for Software Research, School of Computer Science, Carnegie Mellon University},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/CMU-ISR-13-118.pdf},
      ABSTRACT = {Many software systems eventually undergo changes to their basic architectural structure. Such changes may be prompted by new feature requests, new quality attribute requirements, changing technology, or other reasons. Whatever the causes, architecture evolution is commonplace in real-world software projects. Today’s software architects, however, have few techniques to help them plan such evolution. In particular, they have little assistance in planning alternatives, making trade-offs among these different alternatives, or applying best practices for particular domains. To address this, we have developed an approach for assisting architects in planning and reasoning about software architecture evolution. Our approach is based on modeling and analyzing potential evolution paths that represent different ways of evolving the system. We represent an evolution path as a sequence of transitional architectural states leading from the initial architecture to the target architecture, along with evolution operators that characterize the transitions among these states. We support analysis of evolution paths through the definition and application of constraints that express rules governing the evolution of the systemand evaluation functions that assess path quality. Finally, a set of these modeling elements may be grouped together into an evolution style that encapsulates a body of knowledge relevant to a particular domain of architecture evolution. We evaluate this approach in three ways. First, we evaluate its applicability to real-world architecture evolution projects. This is accomplished through case studies of two very different software organizations. Second, we undertake a formal evaluation of the computational complexity of verifying evolution constraints. Finally, we evaluate the implementability of the approach based on our experiences developing prototype tools for software architecture evolution.},
      NOTE = {Technical Report CMU-ISR-13-118},
      KEYWORDS = {Architecture Evolution}
}
<< 2012 >> TOP
27
@InProceedings{Barnes/NASA/2012,
      AUTHOR = {Barnes, Jeffrey M.},
      TITLE = {NASA's Advanced Multimission Operations System: A Case Study in Software Architecture Evolution},
      YEAR = {2012},
      MONTH = {25-28 June},
      BOOKTITLE = {Proceedings of the International ACM SIGSOFT Conference on the Quality of Software Architectures 2012},
      ADDRESS = {Bertinoro, Italy},
      ABSTRACT = {Virtually all software systems of significant size and longevity eventually undergo changes to their basic architectural structure. Such changes may be prompted by new feature requests, new quality attribute requirements, changing technology, or other reasons. Whatever the cause, software architecture evolution is commonplace in real-world software projects. However, research in this area has suffered from problems of validation; previous work has tended to make heavy use of toy examples and hypothetical scenarios and has not been well supported by real-world examples. To help address this problem, this paper presents a case study of an ongoing effort at the Jet Propulsion Laboratory to rearchitect the Advanced Multimission Operations System used to operate NASA’s deep-space and astrophysics missions. Based on examination of project documents and interviews with project personnel, I describe the goals and approach of this evolution effort, then demonstrate how approaches and formal methods from previous research in architecture evolution may be applied to this evolution while using languages and tools already in place at the Jet Propulsion Laboratory.},
      KEYWORDS = {Architecture Evolution}
}
28
@Article{2012:Cheng:Stitch,
      AUTHOR = {Cheng, Shang-Wen and Garlan, David},
      TITLE = {Stitch: A Language for Architecture-Based Self-Adaptation},
      YEAR = {2012},
      MONTH = {December},
      JOURNAL = {Journal of Systems and Software, Special Issue on State of the Art in Self-Adaptive Systems},
      VOLUME = {85},
      NUMBER = {12},
      EDITOR = {Weyns, Danny and Andersson, Jesper and Malek, Sam and Schmerl, Bradley},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/JSS-S-11-00544.pdf},
      ABSTRACT = {Requirements for high availability in computing systems today demand that systems be self-adaptive to maintain expected qualities-of-service in the presence of system faults, variable environmental conditions, and changing user requirements. Autonomic computing tackles the challenge of automating tasks that humans would otherwise have to perform to achieve this goal. However, existing approaches to autonomic computing lack the ability to capture routine human repair tasks in a way that takes into account the business context that humans use in selecting an appropriate form of adaptation, while dealing with timing delays and uncertainties in outcome of repair actions. In this article, we present Stitch, a language for representing repair strategies within the context of an architecture-based self-adaptation framework. Stitch supports the explicit representation of repair decision trees together with the ability to express business objectives, allowing a self-adaptive system to select a strategy that has optimal utility in a given context, even},
      NOTE = {doi:10.1016/j.jss.2012.02.060 },
      KEYWORDS = {Landmark, Rainbow, Science of Security, Self-adaptation, Self-Repair, Stitch}
}
29
@InBook{Weyns/Schmerl/2012,
      AUTHOR = {Weyns, Danny and Schmerl, Bradley and Grassi, Vincenzo and Malek, Sam and Mirandola, Raffaela and Prehofer, Christian and Wuttke, Jochen and Andersson, Jesper and Giese, Holger and Goeschka, Karl},
      TITLE = {On Patterns for Decentralized Control in Self-Adaptive Systems},
      YEAR = {2012},
      BOOKTITLE = {Software Engineering for Self-Adaptive Systems II},
      VOLUME = {7475},
      EDITOR = {de Lemos, Rogério and Giese, Holger and Muller, Hausi and Shaw, Mary},
      SERIES = { LNCS },
      PUBLISHER = {Springer},
      ABSTRACT = {Self-adaptive systems have the ability to adapt themselves to changes in the environment and internal dynamics to achieve particular goals. Self-adaptation is typically realized using control loops. When systems are large, complex, and heterogeneous, a single control loop may not be sufficient. Given the central role control loops play in the way we conceptualize, design, and implement self-adaptive systems, their patterns of interaction should be made explicit to foster comprehension and analysability, and to serve as the basis for developing guidelines and documenting common design choices for engineers. Because of the diversity of ways that existing self-adaptive systems organize the various self-adaptation activities, it is timely to reflect on these systems to: (a) consolidate the knowledge in this area, and (b) to develop a systematic approach for describing different control schema. In this paper, we contribute with a simple notation for describing control schema with multiple control loops, which we believe helps in achieving (b), and we use this notation to describe a number of existing self-adaptation patterns, to begin to fulfill (a). From our study, we outline numerous remaining research challenges and future work in this area.},
      KEYWORDS = {Self-adaptation}
}
30
@InProceedings{Garlan/EUA/2012,
      AUTHOR = {Garlan, David and Dwivedi, Vishal and Ruchkin, Ivan and Schmerl, Bradley},
      TITLE = {Foundations and Tools for End-User Architecting},
      YEAR = {2012},
      BOOKTITLE = {Large-Scale Complex IT Systems. Development, Operation and Management, 17th Monterey Workshop 2012, Oxford, UK, March 19-21, 2012},
      VOLUME = {7539},
      PAGES = {157-182},
      EDITOR = {Garlan, David and Calinescu, R},
      SERIES = {Lecture Notes in Computer Science},
      PUBLISHER = {Springer},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/EUA-LNCS.pdf},
      ABSTRACT = {Within an increasing number of domains an important emerging need is the ability for technically na¨ıve 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.},
      NOTE = {Book reference },
      KEYWORDS = {End-user Architecture, Landmark, Service Composition, Software Architecture, SORASCS}
}
<< 2011 >> TOP
31
@InProceedings{Schmerl/2011/ICSE,
      AUTHOR = {Schmerl, Bradley and Garlan, David and Dwivedi, Vishal and Bigrigg, Michael W. and Carley, Kathleen M.},
      TITLE = {SORASCS: A Case Study in SOA-based Platform Design for Socio-Cultural Analysis},
      YEAR = {2011},
      BOOKTITLE = {Proceedings of the 33rd International Conference on Software Engineering.},
      ADDRESS = {Hawaii, USA},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/SORASCS-ICSE2011-cr-final.pdf},
      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.},
      KEYWORDS = {Architectural Style, SORASCS}
}
32
@InProceedings{Bhave/CPS/2011,
      AUTHOR = {Bhave, Ajinkya Y. and Krogh, Bruce and Garlan, David and Schmerl, Bradley},
      TITLE = {View Consistency in Architectures for Cyber-Physical Systems},
      YEAR = {2011},
      MONTH = {April},
      BOOKTITLE = {Proceedings of the 2nd ACM/IEEE International Conference on Cyber-Physical Systems},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/ICCPS11_BKGS.pdf},
      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.},
      KEYWORDS = {Architecture View Consistency, Cyberphysical Systems}
}
33
@TechReport{Gennari/2011,
      AUTHOR = {Gennari, Jeffrey and Garlan, David},
      TITLE = {Measuring Attack Surface in Software Architecture},
      YEAR = {2011},
      NUMBER = {CMU-ISR-11-121},
      INSTITUTION = {Institute for Software Research, School of Computer Science, Carnegie Mellon University},
      URL = {http://reports-archive.adm.cs.cmu.edu/anon/isr2011/abstracts/11-121.html},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/CMU_ISR_11_121.PDF},
      ABSTRACT = {In this report we show how to adapt the notion of “attack surface” to formally evaluate security properties at the architectural level of design and to identify vulnerabilities in architectural designs. Further we explore the application of this metric in the context of architecture-based transformations to improve security by reducing the attack surface. These transformations are described in detail and validated with a simple experiment.},
      KEYWORDS = {Acme, AcmeStudio, Architectural Analysis, Science of Security}
}
34
@InProceedings{Rajhans/2011/CPS,
      AUTHOR = {Rajhans, Akshay and Bhave, Ajinkya Y. and Loos, Sarah and Krogh, Bruce and Platzer, Andre and Garlan, David},
      TITLE = {Using Parameters in Architectural Views to Support Heterogeneous Design and Verification},
      YEAR = {2011},
      MONTH = {12-15 December},
      BOOKTITLE = {50th IEEE Conference on Decision and Control (CDC) and European Control Conference (ECC)},
      ADDRESS = {Orlando, FL},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/RBL+_CDC11.pdf},
      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.},
      KEYWORDS = {Architecture View Consistency, Cyberphysical Systems}
}
35
@Unpublished{Garlan/SWiFT/2011,
      AUTHOR = {Garlan, David and Schmerl, Bradley and Dwivedi, Vishal and Banerjee, Aparup and Glendenning, Laura and Nakayama, Mai and Patel, Nina},
      TITLE = {SWiFT: A Tool for Constructing Workflows for Dynamic Network Analysis},
      YEAR = {2011},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/Paper.pdf},
      ABSTRACT = {Abstract—Dynamic Network Analysis is a domain of computation that refers to the analysis of complex social systems that change over time. Within this domain, analysts need to be able to carry out workflows, involving composition of various tools and procedures that they use to extract and analyze social systems. Typically these workflows require the incorporation of heterogeneous tools in distributed locations, are interactive in that they allow dynamic parameterization and exploration, and can be shared with and reused by other analysts in different contexts. Furthermore, because such analysts are not computer programmers, they require an approach for constructing workflows that allows them to focus on their analysis task, and that provides them with appropriate guidance in constructing and reusing workflows. In this paper, we describe a tool, called SWiFT, that provides a workflow construction environment for dynamic network analysis, built on a service oriented architecture, that provides these features.},
      NOTE = {http://acme.able.cs.cmu.edu/pubs/show.php?id=333},
      KEYWORDS = {Service Composition, SORASCS}
}
36
@InProceedings{Casonova/2011/ARFD,
      AUTHOR = {Casanova, Paulo and Schmerl, Bradley and Garlan, David and Abreu, Rui},
      TITLE = {Architecture-based Run-time Fault Diagnosis},
      YEAR = {2011},
      MONTH = {13-16 September},
      BOOKTITLE = {Proceedings of the 5th European Conference on Software Architecture},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/ecsa2011-abrtfd.pdf},
      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.},
      KEYWORDS = {Rainbow, Self-adaptation}
}
37
@InProceedings{2011:Dwivedi:SCORE,
      AUTHOR = {Dwivedi, Vishal and Velasco Elizondo, Perla and Maria Fernandes, Jose and Garlan, David and Schmerl, Bradley},
      TITLE = {An Architectural Approach to End User Orchestrations},
      YEAR = {2011},
      MONTH = {13-16 September},
      BOOKTITLE = {Proceedings of the 5th European Conference on Software Architecture},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/ECSA-EndUserOrchestrations.pdf},
      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},
      KEYWORDS = {Architectural Style, Service Composition, Software Architecture, SORASCS}
}
38
@Book{Clements2011,
      AUTHOR = {Clements, Paul and Bachmann, Felix and Bass, Len and Garlan, David and Ivers, James and Little, Reed and Merson, Paulo and Nord, Robert and Stafford, Judith},
      TITLE = {Documenting Software Architectures: Views and Beyond, Second Edition},
      YEAR = {2011},
      PUBLISHER = {Addison Wesley}
}
39
@TechReport{Garlan/CSPE/2011,
      AUTHOR = {Garlan, David and Lattanze, Anthony},
      TITLE = {Computer Science for Practicing Engineers: Computer Science for Everyone Else},
      YEAR = {2011},
      NUMBER = {CMU-ISR-11-115},
      INSTITUTION = {Institute for Software Research, School of Computer Science, Carnegie Mellon University},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/CMU-ISR-11-115.pdf},
      ABSTRACT = {The Computer Science for Practicing Engineers (CS4PE) course is a breath-oriented course covering key topics in computer science that represent critical foundational knowledge for anyone developing software. The course is designed for students and professionals who do not have a formal background in computer science, but currently write, or anticipate writing software as a key part of their job. CS4PE represents one important facet of Computation Thinking [Wing 2006]. Computational thinking is a fundamental skill for everyone, not just for computer scientists. To those core concepts essential to a particular professional discipline, we need to add computational thinking to every professional’s analytical ability. The purpose of this report is to describe the motivation for, and the development of, the CS4PE course. The aim is to describe why such a course is needed, the design of the course, our experience in delivering the course since its inception, and feedback received from a peer review of the course content and assignments during the 2010 Conference on Software Engineering Education and Training. We will also discuss how and why the course has evolved since its initial development and delivery, as well as future directions that we expect the course to move in.},
      KEYWORDS = {Education, Software Engineering}
}
40
@PhdThesis{2011/Bhave/Thesis,
      AUTHOR = {Bhave, Ajinkya Y.},
      TITLE = {Multi-View Consistency in Architectures for Cyber-Physical Systems},
      YEAR = {2011},
      SCHOOL = {Department of Electrical and Computer Engineering, Carnegie Mellon University},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/ajinkya-thesis.pdf},
      ABSTRACT = {Today's complex cyber-physical systems (CPSs) are created using models throughout the system development life cycle, a process referred to as model-based design (MBD). The heterogeneity of elements in CPSs requires multiple perspectives and formalisms to explore the complete design space. Ensuring the consistency of these various system models is an important part of the integrated MBD approach.

In this thesis, we propose to unify heterogeneous system models through light-weight representations of their structure and semantics using architectural descriptions. Architectures are annotated structural representations that describe systems at a high level of abstraction, allowing designers to determine appropriate assignment of functionality to elements, and make trade-o s between different quality attributes. There are two fundamental shortcomings of current architecture modeling capabilities that limit their potential to fully address the engineering problems of large-scale, heterogeneous CPSs: (i) limited vocabulary to represent physical elements and their interactions; and (ii) inadequate ways to support consistency relations between heterogeneous architecture views of the same system.

This thesis addresses the first shortcoming through the development of the CPS architectural style that supports a uni ed representation of both physical and cyber elements and their interactions in the same framework. This ability allows the architect to create a common base architecture (BA) for a CPS that provides a uni ed point of reference for multi-domain system models. To address the second shortcoming, the architectural view is used as the mechanism to represent the architectures of system models as abstractions of the underlying shared BA. In this context, well-de ned mappings between a view and the BA are used to identify and manage semantically equivalent elements (and their relations) between each model and the underlying system. Structural consistency de nes when an architectural view conforms to the structural and semantic constraints imposed by components and connectors in the system's BA. Such a notion of consistency ensures that the model elements adhere to the connectivity constraints and physical laws present between elements in the BA. We define view consistency as the existence of an appropriate morphism between the typed graphs of a view and the BA. Depending on the type of morphism present, two notions of consistency are defined: view conformance and view completeness.

Our tool framework is implemented in the AcmeStudio architecture design framework, and consists of a view map language, a graphical view editor, and a set of graph morphism algorithms for consistency checking. We illustrate the application of our architectural approach with two case studies: an autonomous quadrotor with heterogeneous legacy models, and management of model variants in simulation environments for engine control of vehicles.},
      KEYWORDS = {Cyberphysical Systems}
}

<< 2010 >> TOP
41
@InProceedings{2010/Faulring/Radar,
      AUTHOR = {Faulring, Andrew and Myers, Brad and Mohnkern, Ken and Schmerl, Bradley and Steinfeld, Aaron and Zimmerman, John and Smailagic, Asim and Hansen, Jeffery and Siewioreck, Daniel},
      TITLE = {Agent-Assisted Task Management that Reduces Email Overhead},
      YEAR = {2010},
      MONTH = {7-10 February},
      BOOKTITLE = {Proceedings of the 14th International Conference on Intelligent User Interfaces},
      PAGES = {61-70},
      ADDRESS = {Hong Kong, China},
      PUBLISHER = {ACM Press},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/radar-iui10.pdf},
      ABSTRACT = {RADAR is a multiagent system with a mixed-initiative user interface designed to help office workers cope with email overload. RADAR agents observe experts to learn models of their strategies and then use the models to assist other people who are working on similar tasks. The agents’ assistance helps a person to transition from the normal email-centric workflow to a more efficient task-centric workflow. The Email Classifier learns to identify tasks contained within emails and then inspects new emails for similar tasks. A novel task-management user interface displays the found tasks in a to-do list, which has integrated support for performing the tasks. The Multitask Coordination Assistant learns a model of the order in which experts perform tasks and then suggests a schedule to other people who are working on similar tasks. A novel Progress Bar displays the suggested schedule of incomplete tasks as well as the completed tasks. A large evaluation demonstrated that novice users confronted with an email overload test performed significantly better (a 37% better overall score with a factor of four fewer errors) when assisted by the RADAR agents. },
      NOTE = {Honorable Mention Award in the Best Paper Contest. DOI},
      KEYWORDS = {RADAR}
}
42
@InProceedings{Bhave/ERTS2010,
      AUTHOR = {Bhave, Ajinkya Y. and Garlan, David and Krogh, Bruce and Rajhans, Akshay and Schmerl, Bradley},
      TITLE = {Augmenting Software Architectures with Physical Components},
      YEAR = {2010},
      MONTH = {19-21 May},
      BOOKTITLE = {Proceedings of the Embedded Real Time Software and Systems Conference (ERTS^2 2010)},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/ERTS2_2010.pdf},
      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.},
      KEYWORDS = {Cyberphysical Systems}
}
43
@Misc{2010/Vishal/EUO,
      AUTHOR = {Dwivedi, Vishal and Garlan, David and Schmerl, Bradley},
      TITLE = {End User Orchestrations},
      YEAR = {2010},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/EndUserOrchestrations.pdf},
      ABSTRACT = {Service-orchestrations define how services can be composed together and are widely used to execute applications based on Service Oriented Architectures (SOAs). However, the various special purpose orchestration languages used today require code-level constructs that force the users to provide excessive technical detail. For many SOA domains end-users of these orchestrations have limited technical expertise, and hence these users find it difficult to specify orchestrations in current languages. Additionally, users specifying orchestrations would often like to reason about architectural attributes such as performance, security and composability - capabilities that current languages and tools do not support. In this paper we provide an improved technique for modeling orchestrations that allows users to focus primarily on the functional composition of services that is guided by tool supported domain-specific analyses. We introduce an abstract architectural specification language called SCORE (Simple Compositional ORchestration for End users) that defines the vocabulary of elements that can be used in a service composition. SCORE not only allows users to create correct service orchestrations, but it also removes the need for technical detail, most of which is auto-generated by tool support. We demonstrate the use of our approach to specify service-orchestrations in SORASCS (Service ORiented Architectures for Socio-Cultural Systems), which is a SOA system for the intelligence analysis domain. SORASCS users are analysts, who are involved with domain-specific analysis workflows that are represented using SCORE and executed.},
      NOTE = {Submitted for publication},
      KEYWORDS = {Service Composition, Software Architecture}
}
44
@Article{Kim2010,
      AUTHOR = {Kim, Jung Soo and Garlan, David},
      TITLE = {Analyzing Architectural Styles},
      YEAR = {2010},
      JOURNAL = {Journal of Software and Systems},
      VOLUME = {83},
      NUMBER = {7},
      PAGES = {1216-1235},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/JSS-final-revision3.pdf},
      ABSTRACT = {The backbone of most software architectures and component integration frameworks is one or more architectural styles that provide a domain-speci c design vocabulary and a set of constraints on how that vocabulary is used. Today's architectural styles are increasingly complex, involving rich vocabularies and numerous constraints. Hence, designing a sound and appropriate style becomes an intellectually challenging activity. Unfortunately, although there are numerous tools to help in the analysis of architectures for individual systems, relatively less work has been done on tools to help in the design of architectural styles. In this paper we address this gap by showing how to map an architectural style, expressed formally in an architectural description language, into a relational model that can then be checked for properties, such as whether a style is consistent, whether a style satis es some predicates over its architectural structure, and whether two styles are compatible for composition.},
      KEYWORDS = {Architectural Analysis, Architectural Style}
}
45
@InProceedings{Views/Bhave/2010,
      AUTHOR = {Bhave, Ajinkya Y. and Krogh, Bruce and Garlan, David and Schmerl, Bradley},
      TITLE = {Multi-domain Modeling of Cyber-Physical Systems using Architectural Views},
      YEAR = {2010},
      MONTH = {30 November},
      BOOKTITLE = {Proceedings of the 1st Analytic Virtual Integration of Cyber-Physical Systems Workshop.},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/MMCPSAV.pdf},
      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.},
      NOTE = {Co-located with RTSS 2010.},
      KEYWORDS = {Architectural Style, Cyberphysical Systems}
}
46
@InProceedings{Garlan/FoSER/2010,
      AUTHOR = {Garlan, David},
      TITLE = {Software Engineering in an Uncertain World},
      YEAR = {2010},
      MONTH = {November},
      BOOKTITLE = {Workshop on the Future of Software Engineering Research (FoSER)},
      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.},
      KEYWORDS = {Software Engineering, uncertainty}
}
47
@InProceedings{Garlan:2010:SEU:1882362.1882389,
      AUTHOR = {Garlan, David},
      TITLE = {Software Engineering in an Uncertain World},
      YEAR = {2010},
      BOOKTITLE = {Proceedings of the FSE/SDP workshop on Future of Software Engineering Research},
      PAGES = {125--128},
      SERIES = {FoSER '10},
      ADDRESS = {New York, NY, USA},
      PUBLISHER = {ACM},
      URL = {http://doi.acm.org/10.1145/1882362.1882389},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/foser057-garlan.pdf},
      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.},
      NOTE = {ISBN 978-1-4503-0427-6},
      KEYWORDS = {Software Architecture, Software Engineering, uncertainty}
}
<< 2009 >> TOP
48
@Article{RajhansMPM2009,
      AUTHOR = {Rajhans, Akshay and Cheng, Shang-Wen and Schmerl, Bradley and Garlan, David and Krogh, Bruce and Agbi, Clarence and Bhave, Ajinkya Y.},
      TITLE = {An Architectural Approach to the Design and Analysis of Cyber-Physical Systems},
      YEAR = {2009},
      JOURNAL = {Electronic Communications of the EASST},
      VOLUME = {21: Multi-Paradigm Modeling},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/286-855-1-PB.pdf},
      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. A new CPS architectural style is introduced to support the principled design and evaluation of alternative architectures for cyber-physical systems (CPSs). 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 using the Labeled Transition System Analyzer (LTSA) or Polyhedral Hybrid Automata Verifier (PHAVer), respectively. The CPS architectural style and analysis plug-ins are illustrated with an example. },
      KEYWORDS = {Cyberphysical Systems}
}
49
@InProceedings{SOAR2009,
      AUTHOR = {Raheja, Rahul and Cheng, Shang-Wen and Garlan, David and Schmerl, Bradley},
      TITLE = {Improving Architecture-Based Self-Adaptation using Preemption},
      YEAR = {2009},
      MONTH = {14 September},
      BOOKTITLE = {Proceedings of the Workshop on Self-Organizing Architecture},
      ADDRESS = {Cambridge, UK},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/SOAR-web.pdf},
      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.},
      KEYWORDS = {Autonomic Systems, Rainbow, Self-adaptation, Software Architecture, Software Engineering}
}
50
@InBook{2009:AdaptationChapter,
      AUTHOR = {Garlan, David and Schmerl, Bradley and Cheng, Shang-Wen},
      TITLE = {Software Architecture-Based Self-Adaptation},
      YEAR = {2009},
      BOOKTITLE = {Autonomic Computing and Networking},
      NUMBER = {ISBN 978-0-387-89827-8},
      EDITOR = {Denko, Mieso and Yang, Laurence and Zhang, Yan},
      PUBLISHER = {Springer},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/chapter-final.pdf},
      ABSTRACT = {Increasingly, systems must have the ability to self-adapt to meet changes in their execution environment. Unfortunately, existing solutions require human oversight, or are limited in the kinds of systems and the set of quality-of-service concerns they address. Our approach, embodied in a system called Rainbow, uses software architecture models and architectural styles to overcome existing limitations. It provides an engineering approach and a framework of mechanisms to monitor a target system and its environment, reflect observations into a system's architecture model, detect opportunities for improvements, select a course of action, and effect changes in a closed loop. The framework provides general and reusable infrastructures with well-defined customization points, allowing engineers to systematically customize Rainbow to particular systems and concerns. },
      NOTE = {Springer Link},
      KEYWORDS = {Autonomic Systems, Rainbow, Self-adaptation, Self-Repair}
}
51
@InProceedings{Garlan/2009/SOA,
      AUTHOR = {Garlan, David and Carley, Kathleen M. and Schmerl, Bradley and Bigrigg, Michael W. and Celiku, Orieta},
      TITLE = {Using Service-Oriented Architectures for Socio-Cultural Analysis},
      YEAR = {2009},
      MONTH = {1-3 July},
      BOOKTITLE = {Proceedings of the 21st International Conference on Software Engineering and Knowledge Engineering (SEKE2009)},
      ADDRESS = {Boston, USA},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/SORASCS-SEKE09.pdf},
      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.},
      KEYWORDS = {SORASCS, Service Composition, Software Architecture}
}
52
@InProceedings{Garlan/2009/ICSE/AEvol,
      AUTHOR = {Garlan, David and Schmerl, Bradley},
      TITLE = {Ævol: A tool for defining and planning architecture evolution},
      YEAR = {2009},
      MONTH = {20-22 May},
      BOOKTITLE = {2009 International Conference on Software Engineering},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/ICSE2009_FRD_0231_Schmerl_Bradley.pdf},
      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.},
      KEYWORDS = {Architecture Evolution}
}
53
@InProceedings{MISE2009,
      AUTHOR = {Chaki, Sagar and Diaz-Pace, Andres and Garlan, David and Garfunkel, Arie and Ozkaya, Ipek},
      TITLE = {Towards Engineered Architecture Evolution},
      YEAR = {2009},
      MONTH = {May},
      BOOKTITLE = {Workshop on Modeling in Software Engineering 2009},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/ICSE2009_MISE_2013_Chaki_Sagar-1.pdf},
      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.},
      KEYWORDS = {Architecture Evolution}
}
54
@InProceedings{Cheng:2009:RAIDE/icse,
      AUTHOR = {Cheng, Shang-Wen and Garlan, David and Schmerl, Bradley},
      TITLE = {RAIDE for Engineering Architecture-Based Self-Adaptive Systems},
      YEAR = {2009},
      BOOKTITLE = {2009 International Conference on Software Engineering},
      ADDRESS = {Vancouver, BC, Canada},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/ICSE2009_IRD_0659_Cheng_Shang-Wen.pdf},
      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.},
      KEYWORDS = {Rainbow}
}
55
@InProceedings{Cheng:2009:benchmark/znn:seams,
      AUTHOR = {Cheng, Shang-Wen and Garlan, David and Schmerl, Bradley},
      TITLE = {Evaluating the Effectiveness of the Rainbow Self-Adaptive System},
      YEAR = {2009},
      MONTH = {18-19 May},
      BOOKTITLE = {ICSE 2009 Workshop on Software Engineering for Adaptive and Self-Managing Systems (SEAMS’09), Vancouver, BC, Canada},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/ICSE2009_SEAMS_2528_Cheng_Shang-Wen.pdf},
      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.},
      KEYWORDS = {Benchmark, Rainbow}
}
56
@InProceedings{Garlan/2009/ArchEvol,
      AUTHOR = {Garlan, David and Barnes, Jeffrey M. and Schmerl, Bradley and Celiku, Orieta},
      TITLE = {Evolution Styles: Foundations and Tool Support for Software Architecture Evolution},
      YEAR = {2009},
      MONTH = {14-17 September},
      BOOKTITLE = {Proceedings of the Joint Working IEEE/IFIP Conference on Software Architecture 2009 & European Conference on Software Architecture 2009},
      ADDRESS = {Cambridge, UK},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/wicsa-09-camera-web.pdf},
      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.},
      KEYWORDS = {Architecture Evolution}
}
57
@TechReport{Abi-Antoun/2009/Security/TR,
      AUTHOR = {Abi-Antoun, Marwan and Barnes, Jeffrey M.},
      TITLE = {Enforcing Conformance between Security Architecture and Implementation},
      YEAR = {2009},
      MONTH = {April},
      NUMBER = {CMU-ISR-09-113},
      INSTITUTION = {Carnegie Mellon University Institure for Software Research},
      ABSTRACT = {Analysis at the level of a runtime architecture matches the way experts reason about security or privacy better than a purely code-based strategy. However, the architecture must still be correctly realized in the implementation. We previously developed Scholia to analyze, at compile time, communication integrity between arbitrary object-oriented code, and a rich, hierarchical intended runtime architecture, using typecheckable annotations. This paper applies Scholia to security runtime architectures. Having established traceability between the target architecture and the code, we extend Scholia to enforce structural architectural constraints. At the code level, annotations enforce local, modular constraints. At the architectural level, predicates enforce global constraints. We validate the end-to-end approach in practice using a real 3,000-line Java implementation, and enforce its conformance to a security architecture designed by an expert. }
}
58
@Article{Kang2009,
      AUTHOR = {Kang, Sungwon and Garlan, David},
      TITLE = {Valuation of Architecture-based Deterministic Plan for Software Evolution},
      YEAR = {2009},
      MONTH = {October},
      JOURNAL = {The KIPS Transactions: Part D},
      VOLUME = {16-D},
      NUMBER = {5},
      PAGES = {755-566},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/12 J4_200900069_R5-clean copy.pdf},
      ABSTRACT = {Software architecture allows us to make many decisions about a software system and analyze it even before it exists in order to make systematic and planned development possible. Similarly, architecture-based software evolution planning makes planned evolution possible by allowing us to make many decisions about evolution of a software system and analyze its evolution at the level of architecture design before software evolution is realized. In this paper, we develop a framework for architecture-based software evolution planning for the class of deterministic evolution plans by defining and relating various essential concepts and developing its valuation mechanism so that a plan with the greatest value among candidate plans can be selected as the optimal plan. A case study is conducted for explicating the framework and exemplifying its usage.}
}
59
@Article{Garlan/Mismatch/2009,
      AUTHOR = {Garlan, David and Allen, Robert and Ockerbloom, John},
      TITLE = {Architectural Mismatch: Why Reuse is Still So Hard},
      YEAR = {2009},
      MONTH = {July},
      JOURNAL = {IEEE Software, 25th-Anniversary Top Picks},
      PAGES = {66-69},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/DG+09.pdf},
      KEYWORDS = {Software Architecture}
}
60
@InCollection{Sousa-SDT2009,
      AUTHOR = {Sousa, João Pedro and Balan, Rajesh Krishna and Poladian, Vahe and Garlan, David and Satyanarayanan, Mahadev},
      TITLE = {A Software Infrastructure for User-Guided Quality-of-Service Tradeoffs},
      YEAR = {2009},
      BOOKTITLE = {Software and Data Technologies},
      VOLUME = {47},
      PAGES = {48-61},
      EDITOR = {Cordeiro, J.},
      SERIES = {CCIS},
      PUBLISHER = {Springer},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/SIUGQoST.pdf},
      ABSTRACT = {This paper presents a framework for engineering resource-adaptive software targeted at small mobile devices. Rather than building a solution from scratch, we extend and integrate existing work on software infrastructures for ubiquitous computing, and on resource-adaptive applications. This paper addresses two research questions: first, is it feasibility to coordinate resource allocation and adaptation policies among several applications in a way that is both effective and efficient. And second, can end-users understand and control such adaptive behaviors dynamically, depending on user-defined goals for each activity. The evaluation covered both the 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, 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.},
      KEYWORDS = {Activity-oriented Computing, Self-awareness & Adaptation, Software Architecture, Ubiquitous Computing, Usability}
}
<< 2008 >> TOP
61
@InBook{Prediction2008,
      AUTHOR = {Poladian, Vahe and Cheng, Shang-Wen and Garlan, David and Schmerl, Bradley},
      TITLE = {Improving Architecture-Based Self-Adaption Through Resource Prediction},
      YEAR = {2008},
      BOOKTITLE = {Software Engineering for Self-Adaptive Systems},
      VOLUME = {5525},
      EDITOR = {Cheng, Betty H.C. and de Lemos, Rogério and Giese, Holger and Inverardi, Paola and Magee, Jeff},
      SERIES = {Lecture Notes in Computer Science},
      PUBLISHER = {LNCS},
      CHAPTER = {15},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/LNCS-SEfSASChapter-2009-0222-web.pdf},
      ABSTRACT = {An increasingly important concern for modern systems design is how best to incorporate self-adaptation into systems so as to improve their ability to dynamically respond to faults, resource variation, and changing user needs. One promising approach is to use architectural models as a basis for monitoring, problem detection, and repair selection. While this approach has been shown to yield positive results, current systems use a reactive approach: they respond to problems only when they occur. In this paper we argue that self-adaptation can be improved by adopting an anticipatory approach in which predictions are used to inform adaptation strategies. We show how such an approach can be incorporated into an architecture-based adaptation framework and demonstrate the benefits of the approach.},
      KEYWORDS = {Rainbow, Resource prediction, Self-adaptation}
}
62
@InBook{Sousa2008,
      AUTHOR = {Sousa, João Pedro and Schmerl, Bradley and Steenkiste, Peter and Garlan, David},
      TITLE = {Activity Oriented Computing},
      YEAR = {2008},
      BOOKTITLE = {Advances in Ubiquitous Computing: Future Paradigms and Directions},
      EDITOR = {Mostefaoui, Soraya Kouadri and Maamar, Zakaria and Giaglis, George},
      ADDRESS = {Herschey, PA},
      PUBLISHER = {IGI Publishing},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/AOC.pdf},
      ABSTRACT = {This chapter introduces a new way of thinking about software systems for supporting the activities of end-users. In this approach, models of user activities are promoted to first class entities, and software systems are assembled and configured dynamically based on activity models. This constitutes a fundamental change of perspective over traditional applications: activities take the main stage and may be long-lived, whereas the agents that carry them out are plentiful and interchangeable. The core of the chapter describes a closed-loop control design that enables activity-oriented systems to become self-aware and self-configurable, and to adapt to dynamic changes both in the requirements of user activities and in the environment resources. The chapter discusses how that design addresses challenges such as user mobility, resolving conflicts in accessing scarce resources, and robustness in the broad sense of responding adequately to user expectations, even in unpredictable situations, such as random failures, erroneous user input, and continuously changing resources. The chapter further summarizes challenges and ongoing work related to managing activities where humans and automated agents collaborate, human-computer interactions for managing activities, and privacy and security aspects.},
      NOTE = {Book link: http://www.igi-pub.com/books/details.asp?ID=7314},
      KEYWORDS = {Aura, Ubiquitous Computing}
}
63
@InProceedings{Sousa2008-WICSA,
      AUTHOR = {Sousa, João Pedro and Schmerl, Bradley and Poladian, Vahe and Brodsky, Alex},
      TITLE = {UDesign: End-User Design Applied to Monitoring and Control Applications for Smart Spaces},
      YEAR = {2008},
      MONTH = {18-22 February},
      BOOKTITLE = {Proceedings of the 2008 Working IFIP/IEEE Conference on Software Architecture},
      ADDRESS = {Vancouver, BC, Canada},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/uDesign-final.pdf},
      ABSTRACT = {This paper introduces an architectural style for enabling end-users to quickly design and deploy software systems in domains characterized by highly personalized and dynamic requirements. The style offers an intuitive metaphor based on boxes, pipes, and wires, but retains enough preciseness that systems can be automatically assembled and dynamically reconfigured based on uDesign descriptions. uDesign was primarily motivated and validated within monitoring and control applications for smart spaces, but we envision possible extensions to other domains. Our contribution differs from early attempts at end-user programming in the level of abstraction, software architecture rather than programming, and in the subject of description: run-time rather than code structures. To validate the approach, the paper presents (a) two case studies, one in health care and one in home security, (b) the formal semantics of uDesign’s primitives, and (c) a mapping of those primitives to an existing software infrastructure: the Aura infrastructure.},
      KEYWORDS = {Architectural Style, Aura, Service Composition, Ubiquitous Computing}
}
64
@Article{AANSG08,
      AUTHOR = {Abi-Antoun, Marwan and Aldrich, Jonathan and Nahas, Nagi and Schmerl, Bradley and Garlan, David},
      TITLE = {Differencing and Merging of Architectural Views},
      YEAR = {2008},
      MONTH = {March},
      JOURNAL = {Automated Software Engineering Journal},
      VOLUME = {15},
      NUMBER = {1},
      ABSTRACT = {Differencing and merging architectural views is an important activity in software engineering. However, existing approaches are still based on restrictive assumptions, such as requiring view elements to have unique identiers or exactly matching types, which is often not the case in many application domains. We propose an approach based on structural information. We generalize a published polynomial-time tree-to-tree correction algorithm that detects inserts, renames and deletes, into a novel algorithm that additionally detects restricted moves. Our algorithm also supports forcing and preventing matches between view elements. We incorporate the algorithm into tools to compare and merge Component-and-Connector (C&C) architectural views. We provide an empirical evaluation of the algorithm. We illustrate the tools using extended examples, and use them to detect and reconcile interesting differences between real architectural views.},
      NOTE = {Final version available online at http://dx.doi.org/10.1007/s10515-007-0023-3.},
      KEYWORDS = {Acme, ArchJava, Software Architecture}
}
65
@InProceedings{Sousa2008a,
      AUTHOR = {Sousa, João Pedro and Poladian, Vahe and Garlan, David and Schmerl, Bradley and Steenkiste, Peter},
      TITLE = {Steps toward Activity-Oriented Computing},
      YEAR = {2008},
      MONTH = {14 April},
      BOOKTITLE = {Proceedings of the 2008 NSF Next Generation Software Program Workshop},
      ADDRESS = {Miami, FL},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/IPDPS-web.pdf},
      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.},
      KEYWORDS = {Aura, Ubiquitous Computing}
}
66
@PhdThesis{Cheng:2008:Thesis,
      AUTHOR = {Cheng, Shang-Wen},
      TITLE = {Rainbow: Cost-Effective Software Architecture-Based Self-Adaptation},
      YEAR = {2008},
      MONTH = {May},
      SCHOOL = {Carnegie Mellon University},
      URL = {http://reports-archive.adm.cs.cmu.edu/anon/isr2008/abstracts/08-113.html},
      NOTE = {Institute for Software Research Technical Report CMU-ISR-08-113},
      KEYWORDS = {Rainbow}
}
67
@InProceedings{Sousa2008b,
      AUTHOR = {Sousa, João Pedro and Balan, Rajesh and Poladian, Vahe and Garlan, David and Satyanarayanan, Mahadev},
      TITLE = {User Guidance of Resource-Adaptive Systems},
      YEAR = {2008},
      MONTH = {July},
      BOOKTITLE = {ICSOFT'08 International Conference on Software and Data Technologies},
      ADDRESS = {Porto, Portugal},
      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.},
      KEYWORDS = {Aura, Resource Aware Computing}
}
68
@PhdThesis{Poladian2008:Thesis,
      AUTHOR = {Poladian, Vahe},
      TITLE = {Tailoring Configuration to User’s Tasks under Uncertainty},
      YEAR = {2008},
      MONTH = {April},
      SCHOOL = {Carnegie Mellon University},
      URL = {http://reports-archive.adm.cs.cmu.edu/anon/2008/abstracts/08-121.html},
      ABSTRACT = {The expansion of computing infrastructure has opened the possibility of a world in which users can compute everywhere. Despite such advances, computing resources are often scarce and changing, limiting a user’s ability to take advantage of the applications and devices, and requiring changes to the application runtime settings. Currently, the burden of managing the computing environment (devices, applications, and resources) falls on the user. A user must manually start applications and adjust their settings according to the available resources. Assigning such chores of configuration to the user has a number of disadvantages. First, it consumes user’s precious cognitive resources. Second, effectively managing the environment requires skills that a typical user might not have. Third, even with adequate low-level expertise, managing the environment optimally (or even adequately) can be difficult. Ideally, the computing needs of a user are seamlessly matched with the capabilities of the environment: devices, applications, and available resources. The user should enjoy the best possible application quality, without worrying about managing the low-level computing mechanisms. In this dissertation, we describe a novel approach that substantially automates the control of the configuration of the environment for a user’s task: finding and starting applications, configuring their runtime settings, and allocating possibly limited resources. Our approach simultaneously satisfies two important requirements: utility and practicality. Utility ensures that configuration decisions take into account user’s preferences for specific applications and quality of service. Practicality ensures that configuration has low runtime overhead in terms of the latency of configuration decisions and its usage of resources. First, we model configuration analytically as a problem of optimizing user’s utility based on three inputs: (1) user’s preferences, (2) application capability, and (3) resource availability. Formally, automating the control of the configuration requires solving an optimization problem, and then using the optimization solution to control the environment. Next, we design a software infrastructure that is based on the analytical model. The infrastructure implements efficient algorithms to solve the problem of configuration, eliminating the need for manual configuration. We validate our approach using experiments and simulation, demonstrating that the infrastructure satisfies the requirements of utility and practicality while substantially automating configuration.},
      NOTE = {Technical Report CMU-CS-08-121}
}
69
@TechReport{Garlan:2008:EvoStyle,
      AUTHOR = {Garlan, David},
      TITLE = {Evolution Styles: Formal foundations and tool support for software architecture evolution},
      YEAR = {2008},
      MONTH = {June},
      NUMBER = {CMU-CS-08-142},
      INSTITUTION = {School of Computer Science, Carnegie Mellon University},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/CMU-CS-08-142.pdf},
      ABSTRACT = {Architecture evolution is a central feature of virtually all software systems. As new market opportuni-ties, technologies, platforms, and frameworks become available systems must change their organiza-tional structures to accommodate them, requiring large-scale and systematic restructuring. Today arc-hitects have few tools to help them plan and execute such evolutionary paths. In particular, they have almost no assistance in reasoning about questions such as: How should we stage the evolution to achieve business goals in the presence of limited development resources? How can we reduce risk in incorporating new technologies and infrastructure required by the target architecture? How can we make principled tradeoffs between time and development effort? What kinds of changes can be made independently, and which require coordinated system-wide modifications? How can an evolution plan be represented and communicated within an organization? In this report we outline first steps towards a formal basis for assisting architects in developing and reasoning about architectural evolution paths. The key insight behind the approach is that at an architectural level of abstraction many system evolutions follow certain common patterns – or evolution styles. By taking advantage of regularity in the space of common architectural evolutions, and by making the notion of evolutions styles a first-class entity that can be formally defined, we can provide automated assistance for expressing architecture evolution, and for reasoning about both the correctness and quality of evolution paths.},
      KEYWORDS = {Architectural Style}
}
<< 2007 >> TOP
70
@PhdThesis{Fairbanks2007,
      AUTHOR = {Fairbanks, George},
      TITLE = {Design Fragments},
      YEAR = {2007},
      SCHOOL = {Institute for Software Research, Carnegie Mellon University},
      HOWPUBLISHED = {Technical Report CMU-ISRI-07-108}
}
71
@Article{garlan2007,
      AUTHOR = {Garlan, David and Schmerl, Bradley},
      TITLE = {The RADAR Architecture for Personal Cognitive Assistance},
      YEAR = {2007},
      MONTH = {April},
      JOURNAL = {International Journal of Software Engineering and Knowledge Engineering},
      VOLUME = {17},
      NUMBER = {2},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/IJSEKE-paper-submission.pdf},
      ABSTRACT = {Current desktop environments provide weak support for carrying out complex user-oriented tasks. Although individual applications are becoming increasingly sophisticated and feature-rich, 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.},
      NOTE = {A shorter version of this paper appeared in the 2006 Conference on Software Engineering and Knowledge Engineering (SEKE 2006).},
      KEYWORDS = {Personal Assistance, RADAR, Software Architecture}
}
72
@InProceedings{Poladian2007,
      AUTHOR = {Poladian, Vahe and Garlan, David and Shaw, Mary and Schmerl, Bradley and Sousa, João Pedro and Satyanarayanan, Mahadev},
      TITLE = {Leveraging Resource Prediction for Anticipatory Dynamic Configuration},
      YEAR = {2007},
      MONTH = {8-11 July},
      BOOKTITLE = { Proceedings of the First IEEE International Conference on Self-Adaptive and Self-Organizing Systems, SASO-2007},
      PAGES = {214-223},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/predictive_configuration_16_marked.pdf},
      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.},
      KEYWORDS = {Aura, Dynamic Configuration, Resource Aware Computing, Service Composition, Ubiquitous Computing}
}
73
@InProceedings{Celiku2007,
      AUTHOR = {Celiku, Orieta and Garlan, David},
      TITLE = {Using Medical Devices to Teach Formal Modeling},
      YEAR = {2007},
      MONTH = {25-27 June},
      BOOKTITLE = {Joint Workshop on High Confidence Medical Devices, Software, and Systems (HCMDSS) and Medical Device Plug-and-Play (MD PnP) Interoperability},
      ADDRESS = {Boston, MA},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/CelikuGarlanMedicalDevices.pdf},
      SLIDES = {http://acme.able.cs.cmu.edu/pubs/uploads/slides/CelikuGarlanMedicalDevicesPoster.pdf},
      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.},
      KEYWORDS = {Education, Formal Methods}
}
74
@InProceedings{Latoza2007,
      AUTHOR = {LaToza, Thomas and Garlan, David and Herbsleb, James and Myers, Brad},
      TITLE = {Program Comprehension as Fact Finding},
      YEAR = {2007},
      MONTH = {3-7 September},
      BOOKTITLE = {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)},
      PAGES = {361-370},
      ADDRESS = {Dubrovnik, Croatia},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/fp242-latoza.pdf},
      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.},
      NOTE = {Available from the ACM Digital Library: http://doi.acm.org/10.1145/1287624.1287675},
      KEYWORDS = {Software Architecture}
}
75
@Misc{Pride2006,
      AUTHOR = {Pride, Chris},
      TITLE = {Extending Aura with an Augmented Reality Interface},
      YEAR = {2007},
      HOWPUBLISHED = {Undergraduate Thesis},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/PrideThesis.pdf},
      ABSTRACT = {In a ubiquitous computing environment augmented reality would be an ideal choice for a display for the user. An augmented reality display assists users by adding computer generated information to their perception of reality, thus making it ideal for ubiquitous computing. Unfortunately augmented reality is technically difficult and costly to implement even when the application is designed for its use from the ground up. However, many of the necessary devices for a low fidelity implementation of augmented reality are readily available in a ubiquitous computing environment. Our research focuses on using Aura, a ubiquitous computing framework, to marshal the available devices in the environment. These devices can then be connected within the framework to provide an augmented reality display to the user at the best fidelity possible, given the available resources in a user's environment.},
      KEYWORDS = {Aura}
}
76
@InProceedings{Cheng:2007:huas/iwlu,
      AUTHOR = {Cheng, Shang-Wen and Garlan, David},
      TITLE = {Handling Uncertainty in Autonomic Systems},
      YEAR = {2007},
      MONTH = {5 November},
      BOOKTITLE = {Proceedings of the International Workshop on Living with Uncertainties (IWLU’07), co-located with the 22nd International Conference on Automated Software Engineering (ASE’07)},
      ADDRESS = {Atlanta, GA, USA},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/IWLU07-HandlingUncertainties-pub.pdf},
      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.},
      NOTE = {http://godzilla.cs.toronto.edu/IWLU/program.html},
      KEYWORDS = {Autonomic Systems, Rainbow, Self-adaptation, Self-Repair, Stitch, strategy, tactic, uncertainty}
}
77
@InProceedings{Celiku2007a,
      AUTHOR = {Celiku, Orieta and Garlan, David and Schmerl, Bradley},
      TITLE = {Augmenting Architectural Modeling to Cope with Uncertainty},
      YEAR = {2007},
      MONTH = {5 November},
      BOOKTITLE = {Proceedings of the International Workshop on Living with Uncertainties (IWLU’07), co-located with the 22nd International Conference on Automated Software Engineering (ASE’07)},
      ADDRESS = {Atlanta, GA, USA},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/uncertainty-web.pdf},
      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.},
      NOTE = {http://godzilla.cs.toronto.edu/IWLU/program.html},
      KEYWORDS = {Acme, AcmeStudio, Architectural Analysis, Software Architecture}
}
78
@InProceedings{Poladian:2007:iwlu,
      AUTHOR = {Poladian, Vahe and Shaw, Mary and Garlan, David},
      TITLE = {Modeling Uncertainty of Predictive Inputs in Anticipatory Dynamic Configuration},
      YEAR = {2007},
      MONTH = {5 November},
      BOOKTITLE = {Proceedings of the International Workshop on Living with Uncertainties (IWLU’07), co-located with the 22nd International Conference on Automated Software Engineering (ASE’07),},
      ADDRESS = {Atlanta, GA, USA},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/uncertainty_in_configuration_v5.1.pdf},
      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.},
      NOTE = {http://godzilla.cs.toronto.edu/IWLU/program.html},
      KEYWORDS = {Aura, Dynamic Configuration, Resource Allocation, Resource Aware Computing, Ubiquitous Computing, uncertainty}
}
<< 2006 >> TOP
79
@Article{DiscoTectTSE,
      AUTHOR = {Schmerl, Bradley and Aldrich, Jonathan and Garlan, David and Kazman, Rick and Yan, Hong},
      TITLE = {Discovering Architectures from Running Systems},
      YEAR = {2006},
      MONTH = {July},
      JOURNAL = {IEEE Transactions on Software Engineering},
      VOLUME = {32},
      NUMBER = {7},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/discotect-tse.pdf},
      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 runtime observations about an executing system to construct an architectural view of the system. In 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 and are formally defined using Colored Petri Nets. In this paper, we describe a system, called DiscoTect, that uses these mappings and we introduce the DiscoSTEP mapping language and its formal definition. Two case studies showing the application of DiscoTect suggest that the tool is practical to apply to legacy systems and can dynamically verify conformance to a preexisting architectural specification.},
      NOTE = {Also available from IEEE. Appendix A, Appendix B},
      KEYWORDS = {DiscoTect, Rainbow, Self-Repair, Software Architecture}
}
80
@InProceedings{Fairbanks2006,
      AUTHOR = {Fairbanks, George and Scherlis, William and Garlan, David},
      TITLE = {Design Fragments Make Using Frameworks Easier},
      YEAR = {2006},
      MONTH = {22-27 October},
      BOOKTITLE = {Proceedings of ACM SIGPLAN Conference on Object Oriented Programs, Systems, Languages, and Applications (OOPSLA) 2006},
      ADDRESS = {Portland, OR, USA},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/OOPSLA-06.pdf},
      ABSTRACT = {Object oriented frameworks impose new burdens on programmers that libraries did not, such as requiring the programmer to understand the method callback sequence, respecting behavior constraints within these methods, and devising solutions within a constrained solution space. To overcome these burdens, we express the repeated patterns of engagement with the framework as a design fragment. We analyzed the 20 demo applets provided by Sun and created a representative catalog of design fragments of conventional best practice. By evaluating 36 applets pulled from the internet we show that these design fragments are common, many applets copied the structure of the Sun demos, and that creation of a catalog of design fragments is practical. Design fragments give programmers immediate benefit through tool-based conformance assurance and long-term benefit through expression of design intent.},
      KEYWORDS = {Design Fragments, Design Patterns, Frameworks}
}
81
@InProceedings{Fairbanks2006a,
      AUTHOR = {Fairbanks, George and Bierhoff, Kevin and D'Souza, Desmond},
      TITLE = {Software Architecture at a Large Financial Firm},
      YEAR = {2006},
      MONTH = {22-27 October},
      BOOKTITLE = {Proceedings of ACM SIGPLAN Conference on Object Oriented Programs, Systems, Languages, and Applications (OOPSLA) 2006},
      ADDRESS = {Portland, OR, USA},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/oopsla06-exp.pdf},
      ABSTRACT = {System builders have historically used informal software architecture models to understand options, make choices, and communicate with others. Research into software architecture over the past fifteen years has indicated that more precise architecture models may be beneficial. At a large financial firm, we applied precise software architecture techniques on four software projects and this experience has revealed a number of practical issues. We made the following observations across the projects: 1) Architecture models can be used to bridge gaps between business requirements and technology, 2) A small collection of techniques and a detail knob are practical and useful in a variety of projects, 3) Architecture modeling techniques amplify the skills of the architects, 4) A model of domain concepts and relationships is helpful when building architecture models, and 5) It is difficult to know when to stop adding detail to your architecture model. We believe that these observations motivate future research and can help practitioners make software architecture more effective in practice.},
      KEYWORDS = {Software Architecture}
}
82
@InProceedings{Kim2006,
      AUTHOR = {Kim, Jung Soo and Garlan, David},
      TITLE = {Analyzing Architectural Styles with Alloy},
      YEAR = {2006},
      MONTH = {17 July},
      BOOKTITLE = {Workshop on the Role of Software Architecture for Testing and Analysis 2006 (ROSATEA 2006)},
      ADDRESS = {Portland, ME, USA},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/rosatea2006-final.pdf},
      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.},
      KEYWORDS = {Acme, Formal Methods, Software Architecture}
}
83
@InProceedings{Garlan2006,
      AUTHOR = {Garlan, David and Schmerl, Bradley},
      TITLE = {An Architecture for Personal Cognitive Assistance},
      YEAR = {2006},
      MONTH = {5-7 July},
      BOOKTITLE = {18th International Conference on Software Engineering and Knowledge Engineering},
      ADDRESS = {San Francisco Bay, USA},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/seke06.pdf},
      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.},
      KEYWORDS = {Personal Assistance, RADAR, Software Architecture}
}
84
@Article{Poladian2006,
      AUTHOR = {Sousa, João Pedro and Poladian, Vahe and Garlan, David and Schmerl, Bradley and Shaw, Mary},
      TITLE = {Task-Based Adaptation for Ubiquitous Computing},
      YEAR = {2006},
      MONTH = {May},
      JOURNAL = {IEEE Transactions on Systems, Man, and Cybernetics, Part C: Applications and Reviews, Special Issue on Engineering Autonomic Systems},
      VOLUME = {36},
      NUMBER = {3},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/tbuc.pdf},
      ABSTRACT = {An important domain for autonomic systems is the area of ubiquitous computing: users are increasingly surrounded by technology that is heterogeneous, pervasive, and variable. In this paper we describe our work in developing self-adapting computing infrastructure that automates the configuration and reconfiguration of such environments. Focusing on the engineering issues of self-adaptation in the presence of heterogeneous platforms, legacy applications, mobile users, and resource variable environments, we describe a new approach based on the following key ideas: (a) Explicit representation of user tasks allows us to determine what service qualities are required of a given configuration; (b) Decoupling task and preference specification from the lower level mechanisms that carry out those preferences provides a clean engineering separation of concerns between what is needed and how it is carried out; and (c) Efficient algorithms allow us to calculate in real time near-optimal resource allocations and reallocations for a given task.},
      NOTE = {Also available at IEEE Xplore},
      KEYWORDS = {Aura, Autonomic Systems, Ubiquitous Computing}
}
85
@Article{Garlan2006a,
      AUTHOR = {Seceleanu, Tiberiu and Garlan, David},
      TITLE = {Developing adaptive systems with synchronized architectures},
      YEAR = {2006},
      MONTH = {November},
      JOURNAL = {The Journal of Systems and Software},
      VOLUME = {79},
      NUMBER = {11},
      PAGES = {1514-1526},
      URL = {http://dx.doi.org/10.1016/j.jss.2006.03.047},
      ABSTRACT = {In this paper we show how to specify and refine self-adapting systems, by employing the state-based formalism called action systems. Assuming a fixed set of possible configurations, we use a recently-introduced synchronization operator to achieve separation of concerns between adaptation policy, fault tolerance and steady-state system execution. Using action systems allows us to apply standard refinement techniques, aimed for correct implementations of higher-level models. We illustrate this idea by applying it to the problem of coping with dynamically-varying user requirements and possible fault situations.},
      KEYWORDS = {Autonomic Systems, Software Architecture}
}
86
@Unpublished{Schmerl2006a,
      AUTHOR = {Schmerl, Bradley and Butler, Shawn and Garlan, David},
      TITLE = {Architecture-based Simulation for Security and Performance},
      YEAR = {2006},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/simulator.pdf},
      ABSTRACT = {Architectural analysis is key to producing high quality architectures. In this demonstration we present two extensions to AcmeStudio, and domain-neutral Architecture Development Environment, to add Performance and Security Simulation. Using AcmeStudio as the integration platform for these analyses allows comparisons and trade-offs between these different quality attributes.},
      NOTE = {Submitted for publication.},
      KEYWORDS = {AcmeStudio, Architectural Analysis, Architectural Style, Software Architecture}
}
87
@InProceedings{Garlan2006c,
      AUTHOR = {Garlan, David and Schmerl, Bradley},
      TITLE = {Architecture-driven Modelling and Analysis},
      YEAR = {2006},
      BOOKTITLE = {Proceedings of the 11th Australian Workshop on Safety Related Programmable Systems (SCS'06)},
      VOLUME = {69},
      EDITOR = {Cant, Tony},
      SERIES = {Conferences in Research and Practice in Information Technology},
      ADDRESS = {Melbourne, Australia},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/aSCSa-final.pdf},
      ABSTRACT = {Over the past 15 years there has been increasing recognition that careful attention to the design of a systems 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.},
      KEYWORDS = {Acme, AcmeStudio, Architectural Analysis, Architectural Style, Software Architecture}
}
88
@InProceedings{Cheng2006,
      AUTHOR = {Cheng, Shang-Wen and Garlan, David and Schmerl, Bradley},
      TITLE = {Architecture-based Self-adaptation in the Presence of Multiple Objectives},
      YEAR = {2006},
      MONTH = {21-22 May},
      BOOKTITLE = {ICSE 2006 Workshop on Software Engineering for Adaptive and Self-Managing Systems (SEAMS)},
      ADDRESS = {Shanghai, China},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/seams06.pdf},
      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.},
      KEYWORDS = {Landmark, Rainbow, Self-adaptation, Self-Repair, Software Architecture}
}
<< 2005 >> TOP
89
@TechReport{Antoun2006,
      AUTHOR = {Abi-Antoun, Marwan and Aldrich, Jonathan and Nahas, Nagi and Schmerl, Bradley and Garlan, David},
      TITLE = {Differencing and Merging of Architectural Views},
      YEAR = {2005},
      NUMBER = {CMU-ISRI-05-128},
      INSTITUTION = {Carnegie Mellon University Institute for Software Research International},
      URL = {http://reports-archive.adm.cs.cmu.edu/anon/isri2005/abstracts/05-128.html},
      ABSTRACT = {As architecture-based techniques become more widely adopted, software architects face the problem of reconciling different versions of architectural models. However, existing approaches to differencing and merging architectural views are based on restrictive assumptions, such as requiring view elements to have unique identifiers or explicitly log changes between versions. To overcome some of the above limitations, we propose differencing and merging architectural views based on structural information. To that effect, we generalize a published polynomial-time tree-to-tree correction algorithm (that detects inserts, renames and deletes) into a novel algorithm to additionally detect restricted moves and support forcing and preventing matches between view elements. We implement a set of tools to compare and merge component-and-connector (C&C) architectural views, incorporating the algorithm. Finally, we provide an empirical evaluation of the algorithm and the tools on case studies with real software, illustrating the practicality of the approach to find and reconcile interesting divergences between architectural views.},
      KEYWORDS = {Software Architecture}
}
90
@InProceedings{Sousa2005,
      AUTHOR = {Sousa, João Pedro and Poladian, Vahe and Garlan, David and Schmerl, Bradley},
      TITLE = {Capitalizing on Awareness of User Tasks for Guiding Adaptation.},
      YEAR = {2005},
      BOOKTITLE = {Proceedings of the First International Workshop on Adaptive and Self-managing Enterprise Applications, at CAISE'05},
      ADDRESS = {Portugal},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/asmea05.pdf},
      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.},
      KEYWORDS = {Aura, Autonomic Systems, Ubiquitous Computing}
}
91
@PhdThesis{Sousa2005a,
      AUTHOR = {Sousa, João Pedro},
      TITLE = {Scaling Task Management in Space and Time: Reducing User Overhead in Ubiquitous-Computing Environments},
      YEAR = {2005},
      SCHOOL = {Carnegie Mellon University School of Computer Science Technical Report CMU-CS-05-123},
      KEYWORDS = {Aura, Ubiquitous Computing}
}
92
@InProceedings{Schmerl2005,
      AUTHOR = {Schmerl, Bradley and Yan, Hong and Garlan, David},
      TITLE = {DiscoTect: A System for Discovering Architectures from Running Systems (Demonstration)},
      YEAR = {2005},
      MONTH = {September},
      BOOKTITLE = {Proceedings of the Joint European Software Engineering Conference and ACM SIGSOFT Symposium on the Foundations of Software Engineering},
      ADDRESS = {Lisbon, Portugal},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/discotect.pdf},
      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.},
      KEYWORDS = {DiscoTect}
}
93
@InProceedings{Antoun2005,
      AUTHOR = {Abi-Antoun, Marwan and Aldrich, Jonathan and Garlan, David and Schmerl, Bradley and Nahas, Nagi and Tseng, Tony},
      TITLE = {Software Architecture with Acme and ArchJava (Research Demonstration)},
      YEAR = {2005},
      MONTH = {May},
      BOOKTITLE = {Proceedings of the 27th International Conference on Software Engineering},
      ADDRESS = {St. Louis, MS},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/archjava-demo-icse05.pdf},
      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.},
      KEYWORDS = {Acme, ArchJava, Software Architecture}
}
94
@InProceedings{Antoun2005a,
      AUTHOR = {Abi-Antoun, Marwan and Aldrich, Jonathan and Garlan, David and Schmerl, Bradley and Nahas, Nagi and Tseng, Tony},
      TITLE = {Improving System Dependability by Enforcing Architectural Intent},
      YEAR = {2005},
      MONTH = {May},
      BOOKTITLE = {Proceedings of the 2005 Workshop on Architecting Dependable Systems (WADS 2005)},
      ADDRESS = {St. Louis, MS},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/WADS05-2.pdf},
      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. },
      KEYWORDS = {Acme, ArchJava, Software Architecture}
}
95
@InProceedings{Poladian2005,
      AUTHOR = {Poladian, Vahe and Sousa, João Pedro and Padberg, Frank and Shaw, Mary},
      TITLE = {Anticipatory Configuration of Resource-aware Applications},
      YEAR = {2005},
      MONTH = {May},
      BOOKTITLE = {Proceedings of the 7th International Workshop on Economics Driven Software Engineering Research, affiliated with the 27th International Conference on Software Engineering},
      ADDRESS = {St. Louis, MS},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/edser7.pdf},
      ABSTRACT = {We propose an improved approach to dynamic configuration of resource-aware applications. The new anticipatory model of configuration maximizes utility based on three inputs: user preferences, application capability profiles, and resource availability. In this respect, the proposed model is similar to a model of configuration described in [2]. However, the latter addresses the dynamic nature of the problem by reacting to changes (such as decrease in resource availability), and maximizes the utility in a point-wise manner. The newly proposed anticipatory approach explicitly models the duration of the task and leverages possible information about the future (such as stochastic resource availability over the expected duration of the task). We expect that the anticipatory model will improve user's utility, conserve scarce resources, and reduce the amount of disruption to the user resulting from changes when compared to the reactive model. However, the optimization problem underlying the anticipatory model is computationally more difficult than the problem underlying the reactive model. We would like to investigate if the anticipatory approach is feasible and efficient in practice while delivering the above-mentioned improvements. In this paper, we carefully state the model of anticipatory configuration, highlight the sources of complexity in the problem, propose an algorithm to the anticipatory configuration problem, and provide a roadmap for research.},
      KEYWORDS = {Dynamic Configuration, Aura}
}
96
@InProceedings{Garlan2005,
      AUTHOR = {Garlan, David and Reinholtz, William K. and Schmerl, Bradley and Sherman, Nicholas and Tseng, Tony},
      TITLE = {Bridging the Gap between Systems Design and Space Systems Software},
      YEAR = {2005},
      MONTH = {6-7 April},
      BOOKTITLE = {Proceedings of the 29th Annual IEEE/NASA Software Engineering Workshop (SEW-29)},
      ADDRESS = {Greenbelt, MD},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/sew-final.pdf},
      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.},
      KEYWORDS = {Acme, Software Architecture}
}
97
@InProceedings{Cheng2005,
      AUTHOR = {Cheng, Shang-Wen and Garlan, David and Schmerl, Bradley},
      TITLE = {Making Self-Adaptation an Engineering Reality},
      YEAR = {2005},
      BOOKTITLE = {Proceedings of the Conference on Self-Star Properties in Complex Information Systems},
      VOLUME = {3460},
      EDITOR = {Babaoghu, Ozlap and Jelasity, Mark and Montroser, Alberto and Fetzer, Christof and Leonardi, Stefano and Van Moorsel, Aad},
      SERIES = {LNCS},
      PUBLISHER = {Springer-Verlag},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/self-star-2005.pdf},
      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.},
      NOTE = {Also available from Springer-Verlag here},
      KEYWORDS = {Autonomic Systems, Rainbow, Self-Repair}
}
98
@InCollection{Coutaz2005,
      AUTHOR = {Coutaz, Joelle and Crowley, Jame L. and Dobson, Simon and Garlan, David},
      TITLE = {Context is Key},
      YEAR = {2005},
      MONTH = {March},
      BOOKTITLE = {Communications of the ACM, Special Issue on The Disappearing Computer},
      VOLUME = {58},
      NUMBER = {4},
      PAGES = {49-53},
      KEYWORDS = {Ubiquitous Computing}
}
99
@Misc{Cheng2005a,
      AUTHOR = {Cheng, Shang-Wen and Nord, Robert and Stafford, Judith},
      TITLE = {WICSA Wiki WAN Party: capturing experience in software architecture best practices},
      YEAR = {2005},
      MONTH = {January},
      HOWPUBLISHED = {ACM SIGSOFT Software Engineering Notes, Volume 30, Number 1},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/wwwp.pdf},
      ABSTRACT = {Researchers, practitioners, educators, and students of software architecture would benefit from having online access to quality information about the state of research and practice of software architecture. In recent years, Wiki technology has enabled distributed and collaborative editing of content using only a Web browser. To explore whether Wiki technology would be effective in facilitating the ongoing discussion and evolution of ideas on software architecture, we hosted the WICSA Wiki WAN Party (WWWP) during the 4th Working IEEE/IFIP Conference on Software Architecture (WICSA 2004). We used a history tool developed at IBM Research to monitor site activity and provide daily feedback to conference participants. This report recounts experience hosting this Wiki site and summarizes the site activity.},
      KEYWORDS = {Software Architecture}
}
100
@PhdThesis{Spitznagel2004,
      AUTHOR = {Spitznagel, Bridget},
      TITLE = {Compositional Transformation of Software Connectors},
      YEAR = {2005},
      SCHOOL = {Carnegie Mellon Univeristy School of Computer Science Technical Report CMU-CS-04-128},
      KEYWORDS = {Software Architecture}
}
101
@TechReport{Sousa2005b,
      AUTHOR = {Sousa, João Pedro and Balan, Rajesh and Poladian, Vahe and Garlan, David and Satyanarayanan, Mahadev},
      TITLE = {Giving Users the Steering Wheel for Guiding Resource-Adaptive Systems},
      YEAR = {2005},
      MONTH = {December},
      NUMBER = {CMU-CS-05-198},
      INSTITUTION = {Carnegie Mellon University School of Computer Science},
      KEYWORDS = {Aura, Mult-fidelity Applications, Resource Allocation, Service Composition, Ubiquitous Computing}
}
<< 2004 >> TOP
102
@TechReport{Yan2004,
      AUTHOR = {Yan, Hong and Aldrich, Jonathan and Garlan, David and Kazman, Rick and Schmerl, Bradley},
      TITLE = {Discovering Architectures from Running Systems: Lessons Learned},
      YEAR = {2004},
      NUMBER = {CMU-SEI-2004-TR-016},
      INSTITUTION = {Software Engineering Institute}
}
103
@InProceedings{Garlan2004a,
      AUTHOR = {Garlan, David and Poladian, Vahe and Schmerl, Bradley and Sousa, João Pedro},
      TITLE = {Task-based Self-adaptation},
      YEAR = {2004},
      MONTH = {31 October - 1 November},
      BOOKTITLE = {Proceedings of the ACM SIGSOFT 2004 Workshop on Self-Managing Systems (WOSS'04)},
      ADDRESS = {Newport Beach, CA},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/woss04.pdf},
      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.},
      KEYWORDS = {Autonomic Systems, Self-Repair}
}
104
@InProceedings{Roshandel2004,
      AUTHOR = {Roshandel, Roshanak and Schmerl, Bradley and Medvidovic, Nenad and Garlan, David},
      TITLE = {Understanding Tradeoffs among Different Architectural Modelling Approaches},
      YEAR = {2004},
      MONTH = {11-14 June},
      BOOKTITLE = {Proceedings of the 4th Working IEEE/IFIP Conference on Software Architectures (WICSA4)},
      ADDRESS = {Oslo, Norway},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/wicsa4-roshandel.pdf},
      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.},
      KEYWORDS = {Software Architecture}
}
105
@Article{Garlan2004,
      AUTHOR = {Garlan, David and Cheng, Shang-Wen and Huang, An-Cheng and Schmerl, Bradley and Steenkiste, Peter},
      TITLE = {Rainbow: Architecture-Based Self Adaptation with Reusable Infrastructure},
      YEAR = {2004},
      MONTH = {October},
      JOURNAL = {IEEE Computer},
      VOLUME = {37},
      NUMBER = {10},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/computer04.pdf},
      ABSTRACT = {The Rainbow framework uses software architectures and a reusable infrastructure to support self-adaptation of software systems. The use of external adaptation mechanisms allows the explicit specification of adaptation strategies for multiple system concerns.},
      KEYWORDS = {Autonomic Systems, Landmark, Rainbow, Self-adaptation, Software Architecture}
}
106
@InProceedings{Cheng2004,
      AUTHOR = {Cheng, Shang-Wen and Huang, An-Cheng and Garlan, David and Schmerl, Bradley and Steenkiste, Peter},
      TITLE = {An Architecture for Coordinating Multiple Self-Management Systems},
      YEAR = {2004},
      MONTH = {11-14 June},
      BOOKTITLE = {Proceedings of the 4th Working IEEE/IFIP Conference on Software Architectures (WICSA4)},
      ADDRESS = {Oslo, Norway},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/wicsa4-cheng.pdf},
      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.},
      KEYWORDS = {Autonomic Systems, Rainbow, Self-Repair}
}
107
@TechReport{Ivers2004,
      AUTHOR = {Ivers, James and Clements, Paul and Garlan, David and Nord, Robert and Schmerl, Bradley and Silva, Jaime Rodrigo Oviedo},
      TITLE = {Documenting Component and Connector Views with UML 2.0},
      YEAR = {2004},
      NUMBER = {CMU/SEI-2004-TR-008},
      INSTITUTION = {Software Engineering Institute},
      KEYWORDS = {UML, Software Architecture}
}
108
@InProceedings{Poladian2004,
      AUTHOR = {Poladian, Vahe and Sousa, João Pedro and Garlan, David and Shaw, Mary},
      TITLE = {Dynamic Configuration of Resource-Aware Services},
      YEAR = {2004},
      MONTH = {23-28 May},
      BOOKTITLE = { Proceedings of the 26th International Conference on Software Engineering},
      ADDRESS = {Edinburgh, Scotland},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/aura_icse04/aura_icse04.pdf},
      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.},
      KEYWORDS = {Mult-fidelity Applications, Resource Allocation, Resource Aware Computing, Service Composition, Ubiquitous Computing}
}
109
@InProceedings{Yan2004a,
      AUTHOR = {Yan, Hong and Garlan, David and Schmerl, Bradley and Aldrich, Jonathan and Kazman, Rick},
      TITLE = {DiscoTect: A System for Discovering Architectures from Running Systems},
      YEAR = {2004},
      MONTH = {23-28 May},
      BOOKTITLE = {Proceedings of the 26th International Conference on Software Engineering},
      ADDRESS = {Edinburgh, Scotland},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/icse04-discotect/discotect.pdf},
      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.},
      KEYWORDS = {DiscoTect, Software Architecture}
}
110
@InProceedings{Schmerl2004,
      AUTHOR = {Schmerl, Bradley and Garlan, David},
      TITLE = {AcmeStudio: Supporting Style-Centered Architecture Development (Research Demonstration)},
      YEAR = {2004},
      MONTH = {23-28 May},
      BOOKTITLE = {Proceedings of the 26th International Conference on Software Engineering},
      ADDRESS = {Edinburgh, Scotland},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/icse04-acmestudio/acmestudio.pdf},
      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.},
      KEYWORDS = {Acme, AcmeStudio, Software Architecture}
}
111
@InProceedings{Fairbanks2004,
      AUTHOR = {Fairbanks, George},
      TITLE = {Software Engineering Environment Support for Frameworks: A Position Paper},
      YEAR = {2004},
      MONTH = {May},
      BOOKTITLE = {Proceedings of the ICSE 2004 Workshop on Directions in Software Engineering Environments},
      ADDRESS = {Edinburgh, Scotland},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/WoDSEE/paper.pdf},
      ABSTRACT = {Modern software engineering environments provide programmers with contextual information on methods and classes in their software system. However, programmers increasingly encounter frameworks such as Microsoft Foundation Classes or Enterprise Java Beans whose required plug-in mechanisms cannot be adequately described with method or class documentation. The needs of programmers using frameworks are different from the needs when using libraries. Software engineering environments should be augmented with tools to aid programmers in understanding the demands of using frameworks.},
      KEYWORDS = {Design Fragments}
}
112
@InProceedings{Garlan2004b,
      AUTHOR = {Garlan, David and Schmerl, Bradley},
      TITLE = {Using Architectural Models at Runtime: Research Challenges},
      YEAR = {2004},
      MONTH = {May},
      BOOKTITLE = {Proceedings of the European Workshop on Software Architectures},
      ADDRESS = {St. Andrews, Scotland},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/EWSA/paper-final.pdf},
      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.},
      KEYWORDS = {Autonomic Systems, Dynamic Configuration, Self-Repair, Software Architecture}
}
113
@InProceedings{Steppe2004,
      AUTHOR = {Steppe, Kevin and Garlan, David and Bylenok, Greg and Schmerl, Bradley and Shevchenko, Nataliya},
      TITLE = {Tool Support for Model Based Architectural Design for Automotive Control Systems},
      YEAR = {2004},
      MONTH = {17-19 March},
      BOOKTITLE = {First European Workshop on Model Driven Architecture with Emphasis on Industrial Application},
      ADDRESS = {Enschede, The Netherlands},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/MDAEIA2004/MDAEIA2004.pdf},
      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.},
      KEYWORDS = {Acme, Software Architecture}
}
114
@InProceedings{Steppe2004a,
      AUTHOR = {Steppe, Kevin and Bylenok, Greg and Garlan, David and Schmerl, Bradley and Abirov, Kanat and Shevchenko, Nataliya},
      TITLE = {Two-tiered Architectural Design for Automotive Control Systems: An Experience Report},
      YEAR = {2004},
      MONTH = {10-12 January},
      BOOKTITLE = {Automotive Software Workshop on Future Generation Software Architectures in the Automotive Domain},
      ADDRESS = {San Diego, CA},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/ASW04/ASW04.pdf},
      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.},
      NOTE = {(Workshop Proceedings)},
      KEYWORDS = {Acme, Software Architecture}
}
115
@InProceedings{10.1109/ISESE.2004.1334899,
      AUTHOR = {Boehm, Barry and Bhuta, Jesal and Garlan, David and Gradman, Eric and Huang, LiGuo and Lam, Alexander and Madachy, Ray and Medvidovic, Nenad and Meyer, Kenneth and Meyers, Steven and Perez, Gustavo and Reinholtz, Kirk and Roshandel, Roshanak and Rouquette, Nicolas},
      TITLE = {Using Empirical Testbeds to Accelerate Technology Maturity and Transition: The SCRover Experience},
      YEAR = {2004},
      BOOKTITLE = {International Symposium on Empirical Software Engineering},
      PAGES = {117-126},
      ADDRESS = {Los Alamitos, CA, USA},
      PUBLISHER = {IEEE Computer Society},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/ISESE04.pdf},
      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.},
      NOTE = {ISBN 0-7695-2165-7},
      ANNOTE = {DOI : http://doi.ieeecomputersociety.org/10.1109/ISESE.2004.1334899},
      KEYWORDS = {Software Engineering}
}
<< 2003 >> TOP
116
@InProceedings{Poladian2003,
      AUTHOR = {Kumar, Rajnish and Poladian, Vahe and Greenberg, Ira and Messer, Alan and Milojicic, Dejan},
      TITLE = {Selecting Devices for Aggregation},
      YEAR = {2003},
      BOOKTITLE = {Proceedings of the 5th IEEE Workshop on Mobile Computing Systems and Applications (WMCSA 2003)},
      ABSTRACT = {As intelligent devices become affordable and wireless infrastructure becomes pervasive, the potential to combine, or aggregate, device functionality to provide a user with a better experience grows. Often, there will be multiple devices providing similar functionality that the user will have to choose from for the aggregation. This paper presents the design and prototype implementation of a system for automatic selection of devices for aggregation in a dynamic environment. It allows a user to express trade-offs between the quality of device attributes, user distraction, and aggregation stability. This approach enables a user to have a richer experience without having to constantly worry about the device and the environment details.},
      KEYWORDS = {Resource Aware Computing, Service Composition}
}
117
@TechReport{Roshandel2003,
      AUTHOR = {Roshandel, Roshanak and Schmerl, Bradley and Medvidovic, Nenad and Garlan, David and Zhang, Dehua},
      TITLE = {Using Multiple Views to Model and Analyze Software Architecture: An Experience Report},
      YEAR = {2003},
      NUMBER = {USC-CSE-2003-508},
      INSTITUTION = {University of Southern California, Center for Software Engineering},
      PDF = {http://sunset.usc.edu/publications/TECHRPTS/2003/usccse2003-508/usccse2003-508.pdf},
      ABSTRACT = {Architectural modeling and analysis is a critical phase in developing large and complex software systems. The usefulness of multiple views has likewise long been recognized. In this experience report, we explain how we used two ADLs to model a system initially described in UML. The system (SCRover) itheir Mission Data System technology. We describe (a) the processes that we used to extract architectural models from the UML description, (b) the way in which each ADL was used to model the system, (c) a classification of the architectural defects we uncovered, and (d) a comparison of the relative benefits of the two ADLs in terms of the different classes of defects they uncovered.},
      KEYWORDS = {Software Architecture}
}
118
@TechReport{Sousa2003,
      AUTHOR = {Sousa, João Pedro and Garlan, David},
      TITLE = {The Aura Software Architecture: An Infrastructure for Ubiquitous Computing},
      YEAR = {2003},
      MONTH = {August},
      NUMBER = {CMU-CS-03-183},
      INSTITUTION = { School of Computer Science, Carnegie Mellon University},
      KEYWORDS = {Aura, Ubiquitous Computing}
}
119
@InProceedings{Poladian2003a,
      AUTHOR = {Poladian, Vahe and Butler, Shawn and Shaw, Mary and Garlan, David},
      TITLE = {Time is Not Money: The case for multi-dimensional accounting in value-based software engineering},
      YEAR = {2003},
      MONTH = {May},
      BOOKTITLE = {Fifth Workshop on Economics-Driven Software Engineering Research (EDSER-5)},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/EDSER5/paper.pdf},
      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.},
      KEYWORDS = {Mult-fidelity Applications, Resource Allocation, Resource Aware Computing}
}
120
@Book{Clements2003,
      AUTHOR = {Clements, Paul and Bachmann, Felix and Bass, Len and Garlan, David and Ivers, James and Little, Reed and Nord, Robert and Stafford, Judith},
      TITLE = {Documenting Software Architectures: Views and Beyond},
      YEAR = {2003},
      PUBLISHER = {Addison-Wesley},
      ABSTRACT = {

For all but the most trivial software systems, you must pay close attention to its architecturethe conceptual glue that holds every phase of a project together for its many stakeholders. Without an architecture that is appropriate for the problem being solved, the project will at the very least stumble along, or most likely, fail. Even with a superb architecture, if it is not well understood and well communicatedin other words, well documentedthe project cannot be considered a complete success.Although architecture is now widely recognized as a critical element in software development, there has been little guidance independent of language or notation about how to capture it. Based on the authors' extensive experience, Documenting Software Architecture, helps you to decide what information to document and then, with guidelines and examples (in various notations, including UML), shows you how to express an architecture in a form that everyone can understand. If you go to the trouble to create a strong architecture, you must also be prepared to describe it in enough detail, without ambiguity, and to organize it so that others can quickly find the information they need. As a guide for practitioners, the book covers:Seven rules for sound documentation The uses of software architecture documentation, including goals and strategies Architectural views and styles, with general introductions and specific examples Documenting software interfaces and software behavior Templates for capturing and organizing the information to generate a coherent package.
'This book is of immense value. It should save you months of trials and errors, lots of undeserved hassle, and many costly mistakes that could potentially jeopardize the whole endeavor. It will become an important reference on the shelf of the software architect.'
From the Foreword by Philippe Kruchten, Rational Software Canada.},
      NOTE = {2003 Jolt Productivity Award Winner},
      ANNOTE = {Available from Amazon.com},
      KEYWORDS = {Software Architecture}
}
121
@InBook{Garlan2003,
      AUTHOR = {Garlan, David and Cheng, Shang-Wen and Schmerl, Bradley},
      TITLE = {Increasing System Dependability through Architecture-based Self-repair},
      YEAR = {2003},
      BOOKTITLE = {Architecting Dependable Systems},
      EDITOR = {de Lemos, Rogério and Gacek, Cristina and Romanovsky, Alexander},
      PUBLISHER = {Springer-Verlag},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/WADS/WADS-architecture.pdf},
      PS = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/WADS/WADS-architecture.ps},
      ABSTRACT = {One increasingly important technique for improving system dependability is to provide mechanisms for a system 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. In this paper we describe a partial solution in which stylized architectural design models are maintained at run time as a vehicle for automatically monitoring system behavior, for detecting when that behavior falls outside of acceptable ranges, and for deciding on a high-level repair strategy. The main innovative feature of the approach is the ability to specialize a generic run time adaptation framework to support particular architectural styles and properties of interest. Specifically, a formal description of an architectural style defines for a family of related systems the conditions under which adaptation should be considered, provides an analytic basis for detecting anomalies, and serves as a basis for developing sound repair strategies.},
      KEYWORDS = {Rainbow, Self-Repair, Software Architecture}
}
122
@InProceedings{Kim2003,
      AUTHOR = {Garlan, David and Khersonsky, Serge and Kim, Jung Soo},
      TITLE = {Model Checking Publish-Subscribe Systems},
      YEAR = {2003},
      MONTH = {May},
      BOOKTITLE = {Proceedings of The 10th International SPIN Workshop on Model Checking of Software (SPIN 03)},
      ADDRESS = {Portland, OR},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/SPIN03/SPIN03.pdf},
      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.},
      KEYWORDS = {Model Checking, Publish Subscribe Systems}
}
123
@InProceedings{Fairbanks2003,
      AUTHOR = {Fairbanks, George},
      TITLE = {Why Can't They Create Architecture Models Like Developer X? An Experience Report},
      YEAR = {2003},
      MONTH = {3-10 May},
      BOOKTITLE = {The 2003 International Conference on Software Engineering (ICSE'03)},
      ADDRESS = {Portland, OR},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/exp02/paper.pdf},
      ABSTRACT = {A large financial company, struggling with legacy systems that did not interoperate, performed a pilot project to teach software architecture to an enthusiastic application development team. Experienced mentors, including the author, worked with the application team for seven months who completed their engineering goal successfully. However, the mentors were unsuccessful in their attempt to train any of the six members of application team to create architecture models on their own, though they were able to create them collaboratively with the mentors. This surprising result is due to the application team's strong preference for concrete artifacts over abstract ones. Even more surprising, an application developer from a different project, 'Developer X', read the architecture modeling documentation on an internal website and, without mentoring, created good architecture models within a few days. In light of this failure to teach software architecture, two short-term strategies are suggested for the use of software architecture in companies and long-term strategies are discussed.},
      KEYWORDS = {Software Architecture}
}
124
@InProceedings{Spitznagel2003,
      AUTHOR = {Spitznagel, Bridget and Garlan, David},
      TITLE = {A Compositional Formalization of Connector Wrappers},
      YEAR = {2003},
      BOOKTITLE = {The 2003 International Conference on Software Engineering (ICSE'03)},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/connwrap/connwrap.pdf},
      PS = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/connwrap/connwrap.ps},
      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.},
      KEYWORDS = {Software Architecture}
}
<< 2002 >> TOP
125
@Misc{Clements2002,
      AUTHOR = {Clements, Paul and Bachmann, Felix and Garlan, David and Little, Reed and Nord, Robert and Stafford, Judith},
      TITLE = {A Practical Method for Documenting Software Architectures},
      YEAR = {2002},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/icse03-dsa/submitted.pdf},
      ABSTRACT = {A practical approach for documenting software architectures is presented. The approach is based on the well-known architectural concept of views, and holds that documentation consists of documenting the relevant views and then documenting the information that applies to more than one view. Views can be usefully grouped into viewtypes, corresponding to the three broad ways an architect must think about a system: as a set of implementation units, as a set of runtime elements interacting to carry out the system's work, and as a set of elements existing in and relating to external structures in its environment. A simple three-step procedure for choosing the relevant views to document is given, and applied to the problem of documentation for a large, complex NASA system.},
      KEYWORDS = {Software Architecture}
}
126
@InProceedings{Garlan2002,
      AUTHOR = {Garlan, David and Schmerl, Bradley},
      TITLE = {Model-based Adaptation for Self-Healing Systems},
      YEAR = {2002},
      MONTH = {18-19 November},
      BOOKTITLE = {ACM SIGSOFT Workshop on Self-Healing Systems (WOSS'02),},
      ADDRESS = {Charleston, SC},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/WOSS02/paper-submitted.pdf},
      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.},
      KEYWORDS = {Autonomic Systems, Self-Repair, Software Architecture}
}
127
@InProceedings{Dingel2002,
      AUTHOR = {Dingel, Juergen and Garlan, David and Damon, Craig},
      TITLE = {Bridging the HLA: Problems and Solutions},
      YEAR = {2002},
      MONTH = {11-13 October},
      BOOKTITLE = {Sixth IEEE International Workshop on Distributed Simulation and Real Time Applications (DS-RT '02)},
      ADDRESS = {Fort Worth, TX},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/dsrt02/dsrt-distrib.pdf},
      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 bridge. This paper presents the results of an in-depth study of the feasibility of an HLA bridge in the context of the current HLA interface specification. Problems and solutions are discussed and illustrated using particular HLA services.},
      KEYWORDS = {Formal Methods, Software Architecture}
}
128
@InProceedings{Cheng2002,
      AUTHOR = {Cheng, Shang-Wen and Garlan, David and Schmerl, Bradley and Steenkiste, Peter and Hu, Ningning},
      TITLE = {Software Architecture-based Adaptation for Grid Computing},
      YEAR = {2002},
      MONTH = {July},
      BOOKTITLE = {The 11th IEEE Conference on High Performance Distributed Computing (HPDC02)},
      ADDRESS = {Edinburgh, Scotland},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/hpdc02/hpdc02.pdf},
      PS = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/hpdc02/hpdc02.ps},
      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.},
      KEYWORDS = {Autonomic Systems, Self-Repair, Software Architecture}
}
129
@InProceedings{Poladian2002,
      AUTHOR = {Poladian, Vahe and Garlan, David and Shaw, Mary},
      TITLE = {Selection and Configuration in Mobile Environments: A Utility-Based Approach},
      YEAR = {2002},
      MONTH = {May},
      BOOKTITLE = {Fourth Workshop on Economics-Driven Software Engineering Research (EDSER-4)},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/EDSER4/EDSER.pdf},
      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.}
}
130
@InProceedings{Schmerl2002,
      AUTHOR = {Schmerl, Bradley and Garlan, David},
      TITLE = {Exploiting Architectural Design Knowledge to Support Self-repairing Systems},
      YEAR = {2002},
      MONTH = {15-19 July},
      BOOKTITLE = {The 14th International Conference on Software Engineering and Knowledge Engineering},
      ADDRESS = {Ischia, Italy},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/seke02/paper.pdf},
      PS = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/seke02/paper.ps},
      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.},
      KEYWORDS = {AcmeStudio, Self-Repair, Software Architecture}
}
131
@Article{Garlan2002a,
      AUTHOR = {Garlan, David and Siewiorek, Dan and Smalagic, Asim and Steenkiste, Peter},
      TITLE = {Project Aura: Towards Distraction-Free Pervasive Computing},
      YEAR = {2002},
      MONTH = {April},
      JOURNAL = {IEEE Pervasive Computing, special issue on Integrated Pervasive Computing Environments},
      VOLUME = {1},
      NUMBER = {2},
      PAGES = {22-31},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/aura/www/docdir/Aura-Perv02.pdf},
      ABSTRACT = {The most precious resource in a computer system is no longer its processor, memory, disk, or network, but rather human attention. Aura aims to minimize distractions on a user's attention, creating an environment that adapts to the user's context and needs.},
      KEYWORDS = {Aura, Ubiquitous Computing}
}
132
@TechReport{Bachmann2002,
      AUTHOR = {Bachmann, Felix and Bass, Len and Clements, Paul and Garlan, David and Ivers, James and Little, Reed and Nord, Robert and Stafford, Judith},
      TITLE = {Documenting Software Architecture: Documenting Interfaces},
      YEAR = {2002},
      NUMBER = {CMU/SEI-2002-TN-015},
      INSTITUTION = {Software Engineering Institute},
      KEYWORDS = {Software Architecture}
}
133
@InProceedings{Cheng2002a,
      AUTHOR = {Cheng, Shang-Wen and Garlan, David and Schmerl, Bradley and Sousa, João Pedro and Spitznagel, Bridget and Steenkiste, Peter},
      TITLE = {Using Architectural Style as a Basis for Self-repair},
      YEAR = {2002},
      MONTH = {25-31 August},
      BOOKTITLE = {Software Architecture: System Design, Development, and Maintenance (Proceedings of the 3rd Working IEEE/IFIP Conference on Software Architecture)},
      PAGES = {45-59},
      EDITOR = {Bosch, Jan and Gentleman, Morven and Hofmeister, Christine and Kuusela, Juha},
      PUBLISHER = {Kluwer Academic Publishers},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/wicsa3-arch/WICSA-web.pdf},
      PS = {http://www.cs.cmu.edu/afs/cs/project/able/ftp//wicsa3-arch/WICSA-web.ps},
      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.},
      KEYWORDS = {Architectural Analysis, Autonomic Systems, Self-Repair, Software Architecture}
}
134
@InProceedings{Sousa2002,
      AUTHOR = {Sousa, João Pedro and Garlan, David},
      TITLE = {Aura: an Architectural Framework for User Mobility in Ubiquitous Computing Environments},
      YEAR = {2002},
      MONTH = {25-31 August},
      BOOKTITLE = {Software Architecture: System Design, Development, and Maintenance (Proceedings of the 3rd Working IEEE/IFIP Conference on Software Architecture)},
      PAGES = {29-43},
      EDITOR = {Bosch, Jan and Gentleman, Morven and Hofmeister, Christine and Kuusela, Juha},
      PUBLISHER = {Kluwer Academic Publishers},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/wicsa3-aura/wicsa.pdf},
      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.},
      KEYWORDS = {Aura, Software Architecture, Ubiquitous Computing}
}
135
@InProceedings{Cheng2002b,
      AUTHOR = {Cheng, Shang-Wen and Garlan, David and Schmerl, Bradley and Sousa, João Pedro and Spitznagel, Bridget and Steenkiste, Peter and Hu, Ningning},
      TITLE = {Software Architecture-based Adaptation for Pervasive Systems},
      YEAR = {2002},
      MONTH = {8-11 April},
      BOOKTITLE = {International Conference on Architecture of Computing Systems (ARCS'02): Trends in Network and Pervasive Computing},
      VOLUME = {2299},
      EDITOR = {Schmeck, H and Ungerer, T and Wolf, L},
      SERIES = {Lecture Notes in Computer Science},
      ADDRESS = {Karlsruhe, Germany},
      PUBLISHER = {Springer-Verlag},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/arch-arcs02/arcs-final.pdf},
      PS = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/arch-arcs02/arcs-final.ps},
      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.},
      KEYWORDS = {Software Architecture, Ubiquitous Computing}
}
136
@TechReport{Bachmann2002a,
      AUTHOR = {Bachmann, Felix and Bass, Len and Clements, Paul and Garlan, David and Ivers, James and Little, Reed and Nord, Robert and Stafford, Judith},
      TITLE = {Documenting Software Architecture: Documenting Behavior},
      YEAR = {2002},
      NUMBER = {CMU/SEI-2002-TN-001},
      INSTITUTION = {Software Engineering Institute},
      KEYWORDS = {Software Architecture}
}
137
@Article{Garlan2002b,
      AUTHOR = {Garlan, David and Kompanek, Andrew and Cheng, Shang-Wen},
      TITLE = {Reconciling the Needs of Architectural Description with Object-Modeling Notations},
      YEAR = {2002},
      JOURNAL = {Science of Computer Programming},
      VOLUME = {44},
      PAGES = {23-49},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/uml01/uml01.pdf},
      PS = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/uml01/uml01.ps},
      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.},
      KEYWORDS = {Software Architecture, UML}
}
138
@Article{Kaplan2002,
      AUTHOR = {Kaplan, Alan and Schmerl, Bradley and Veeraraghaven, Rajesh},
      TITLE = {Toward Automated Support for Transparent Interoperable Queries},
      YEAR = {2002},
      MONTH = {October},
      JOURNAL = {Journal of Information Technology and Management},
      VOLUME = {3},
      NUMBER = {4},
      PAGES = {387-406},
      URL = {http://www.ingentaconnect.com/content/klu/item/2002/00000003/00000004/05093521;jsessionid=h7vv7b6cf8uk.victoria},
      NOTE = {A shorter version of this paper appeared in the Ninth Workshop on Information Technologies and Systems (WITS99)(Charlotte, USA, December 1999)}
}
<< 2001 >> TOP
139
@InProceedings{Garlan2001,
      AUTHOR = {Garlan, David and Schmerl, Bradley and Chang, Jichuan},
      TITLE = {Using Gauges for Architecture-Based Monitoring and Adaptation},
      YEAR = {2001},
      MONTH = {12-14 December},
      BOOKTITLE = {Proceedings of the Working Conference on Complex and Dynamic Systems Architecture},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/cdsa01/cdsa.pdf},
      PS = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/cdsa01/cdsa.ps},
      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. },
      KEYWORDS = {Self-Repair, Software Architecture}
}
140
@TechReport{Bachmann2001,
      AUTHOR = {Bachmann, Felix and Bass, Len and Clements, Paul and Garlan, David and Ivers, James and Little, Reed and Nord, Robert and Stafford, Judith},
      TITLE = {Documenting Software Architectures: Organization of Documentation Package},
      YEAR = {2001},
      NUMBER = {CMU/SEI-2001-TN-010},
      INSTITUTION = {Software Engineering Institute},
      KEYWORDS = {Software Architecture}
}
141
@InProceedings{Spitznagel2001,
      AUTHOR = {Spitznagel, Bridget and Garlan, David},
      TITLE = {A Compositional Approach for Constructing Connectors},
      YEAR = {2001},
      MONTH = {28-31 August},
      BOOKTITLE = {The Working IEEE/IFIP Conference on Software Architecture (WICSA'01)},
      ADDRESS = {Amsterdam, The Netherlands},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/wicsa01/wicsa_paper.pdf},
      PS = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/wicsa01/wicsa_paper.ps},
      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. },
      KEYWORDS = {Software Architecture}
}
142
@InProceedings{Cheng2001,
      AUTHOR = {Cheng, Shang-Wen and Garlan, David},
      TITLE = {Mapping Architectural Concepts to UML-RT},
      YEAR = {2001},
      MONTH = {June},
      BOOKTITLE = {Proceedings of the 2001 International Conference on Parallel and Distributed Processing Techniques and Applications (PDPTA'2001)},
      ADDRESS = {Las Vegas, NV},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/pdpta01/pdpta01.pdf},
      PS = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/pdpta01/pdpta01.ps},
      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 Acmea 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. },
      KEYWORDS = {Software Architecture, UML}
}
143
@InProceedings{Garlan2001a,
      AUTHOR = {Garlan, David and Schmerl, Bradley},
      TITLE = {Component-Based Software Engineering in a Pervasive Computing Environment},
      YEAR = {2001},
      MONTH = {14-15 May},
      BOOKTITLE = {The 4th ICSE Workshop on Component-Based Software Engineering: Component Certification and System Prediction},
      ADDRESS = {Toronto, Canada},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/cbse01/cbse01-submission.pdf},
      PS = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/cbse01/cbse01-submission.ps},
      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. },
      KEYWORDS = {Aura, Software Architecture, Ubiquitous Computing}
}
144
@InCollection{Garlan2001b,
      AUTHOR = {Garlan, David},
      TITLE = {Software Architecture},
      YEAR = {2001},
      BOOKTITLE = {Wiley Encyclopedia of Software Engineering},
      EDITOR = {Marciniak, J},
      PUBLISHER = {John Wiley & Sons},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/encycSE2001/encyclopedia-dist.ps},
      ABSTRACT = {As the size and complexity of software systems increase, the design, specification, and analysis of overall system structure becomes a critical issue. Structural issues include the organization of a system as a composition of components; global control structures, the protocols for communication, synchronization, and data access; the assignment of functionality to design elements; the composition of design elements; physical distribution; scaling and performance, and dimensions of evolution. This is the software architecture level of design. },
      KEYWORDS = {Software Architecture}
}
145
@TechReport{Dingel2001,
      AUTHOR = {Dingel, Juergen and Garlan, David and Damon, Craig},
      TITLE = {A feasibility study of the HLA bridge},
      YEAR = {2001},
      MONTH = {March},
      NUMBER = {CMU-CS-01-103},
      INSTITUTION = {Carnegie Mellon University School of Computer Science},
      KEYWORDS = {Formal Methods, Software Architecture}
}
146
@Article{Sousa2001,
      AUTHOR = {Sousa, João Pedro and Garlan, David},
      TITLE = {Formal Modeling of the Enterprise JavaBeans Component Integration Framework},
      YEAR = {2001},
      MONTH = {March},
      JOURNAL = {Information and Software Technology},
      VOLUME = {43},
      NUMBER = {3},
      NOTE = {Also available as Technical Report CMU-CS-00-162, Carnegie Mellon University School of Computer Science},
      KEYWORDS = {Formal Methods, Software Architecture}
}
147
@TechReport{Monroe2001,
      AUTHOR = {Monroe, Robert},
      TITLE = {Capturing Software Architecture Design Expertise With Armani},
      YEAR = {2001},
      MONTH = {January},
      NUMBER = {CMU-CS-98-163},
      INSTITUTION = {Carnegie Mellon University School of Computer Science},
      NOTE = {Version 2.3.},
      KEYWORDS = {Acme, Software Architecture}
}
<< 2000 >> TOP
148
@InProceedings{Kaplan2000,
      AUTHOR = {Kaplan, Alan and Ridgeway, John and Schmerl, Bradley and Sridar, Krishnan and Wileden, Jack},
      TITLE = {Toward Pure Polylingual Persistence},
      YEAR = {2000},
      MONTH = {September},
      BOOKTITLE = {Ninth International Workshop on Persistent Object Systems: Design, Implementation and Use (POS9)},
      ADDRESS = {Lillehammer, Norway}
}
149
@InProceedings{Garlan00ArchRoadmap,
      AUTHOR = {Garlan, David},
      TITLE = {Software Architecture: a Roadmap},
      YEAR = {2000},
      BOOKTITLE = {Proceedings of the Conference on The Future of Software Engineering},
      KEY = {Garlan},
      PAGES = {91--101},
      EDITOR = {Finkelstein, A.},
      SERIES = {ICSE '00},
      ADDRESS = {Limerick, Ireland},
      PUBLISHER = {ACM Press},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/roadmap2000/roadmap2000.pdf},
      PS = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/roadmap2000/roadmap2000.ps},
      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. },
      KEYWORDS = {Software Architecture}
}
150
@InProceedings{Garlan2000,
      AUTHOR = {Garlan, David and Khersonsky, Serge},
      TITLE = {Model Checking Implicit-Invocation Systems},
      YEAR = {2000},
      MONTH = {November},
      BOOKTITLE = {Proceedings of the 10th International Workshop on Software Specification and Design (IWSSD-10)},
      ADDRESS = {San Diego, CA},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/iwssd10/iwssd10.pdf},
      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. },
      KEYWORDS = {Model Checking, Publish Subscribe Systems}
}
151
@InProceedings{Garlan2000a,
      AUTHOR = {Garlan, David},
      TITLE = {Pervasive Computing and the Future of CSCW Systems},
      YEAR = {2000},
      MONTH = {November},
      BOOKTITLE = {CSCW2000 Workshop on Software Architectures for Cooperative Systems},
      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 users personal computation space and other peoples 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. },
      NOTE = {(Position Paper)},
      KEYWORDS = {Software Architecture, Ubiquitous Computing}
}
152
@InProceedings{Garlan2000b,
      AUTHOR = {Garlan, David},
      TITLE = {Software Architecture and Object-Oriented Systems},
      YEAR = {2000},
      MONTH = {August},
      BOOKTITLE = {Proceedings of the IPSJ Object-Oriented Symposium 2000},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/OO 2000-dist.pdf},
      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. },
      KEYWORDS = {Object-oriented Systems, Software Architecture}
}
153
@TechReport{Wang2000,
      AUTHOR = {Wang, Zhenyu and Garlan, David},
      TITLE = {Task-Driven Computing},
      YEAR = {2000},
      MONTH = {May},
      NUMBER = {CMU-CS-00-154},
      INSTITUTION = {Carnegie Mellon University School of Computer Science}
}
154
@Unpublished{Garlan2000c,
      AUTHOR = {Garlan, David and Kompanek, Andrew and Kenney, John and Luckham, David and Schmerl, Bradley and Wile, David},
      TITLE = {An Activity Language for the ADL Toolkit},
      YEAR = {2000},
      MONTH = {August},
      PDF = {http://www.cs.cmu.edu/~able/publications/ActivityLanguage/ActivityLanguageProposal0800.pdf},
      PS = {http://www.cs.cmu.edu/~able/publications/ActivityLanguage/ActivityLanguageProposal0800.ps},
      ABSTRACT = {With an eye toward sharing event-based behavior in architectural descriptions, a number of researchers at ISI (Wile), CMU (Garlan & Kompanek) and Stanford (Luckham & Kenney) started a dialogue to converge on an event standard. The results are summarized in this working report. The main idea of the proposal is to adopt an Acme-like approach: a simple base-level event representation would capture the minimal, core aspects of events. Additionally, other more tool-specific information could be added to those event representations in the form of annotations. In this report we outline the proposed scheme. We begin by enumerating some of the requirements that we identified early in our discussions. Next we discuss the basic ontology of events, activities and their types. Then we introduce two proposals for concrete representation: one based on XML, the other on an Acme-like syntax. Finally, we illustrate how collections of events derived from existing ADLs can be mapped into the activity language. },
      NOTE = {Working draft},
      KEYWORDS = {Software Architecture}
}
155
@Unpublished{Hu2000,
      AUTHOR = {Hu, Jianing},
      TITLE = {Adding Maps to Acme},
      YEAR = {2000},
      MONTH = {August},
      PDF = {http://www.cs.cmu.edu/~able/publications/MappingProposal/MappingProposal0800.pdf},
      PS = {http://www.cs.cmu.edu/~able/publications/MappingProposal/MappingProposal0800.ps},
      ABSTRACT = {Multiple architectural views of a system are often helpful in describing a system's design. While there are numerous languages for describing the contents of an individual architectural view, to date those languages have not supported the description of relationships between views. In this report we describe an extension to Acme for expressing maps between the structural aspects of architecture and for expressing constraints over those maps. },
      NOTE = {Working Draft},
      KEYWORDS = {Acme, Software Architecture}
}
156
@InCollection{Garlan00AcmeChapter,
      AUTHOR = {Garlan, David and Monroe, Robert T. and Wile, David},
      TITLE = {Acme: Architectural Description of Component-Based Systems},
      YEAR = {2000},
      BOOKTITLE = {Foundations of Component-Based Systems},
      KEY = {garlan},
      PAGES = {47-68},
      EDITOR = {Leavens, Gary T. and Sitaraman, Murali},
      PUBLISHER = {Cambridge University Press},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/acme-fcbs/acme-fcbs.pdf},
      ABSTRACT = {Over the past decade there has been considerable experimentation with the design of architecture description languages that can provide a formal basis for descrip- tion and analysis of the architectures of component-based systems. As the eld has matured there has emerged among the software architecture research community general consensus about many aspects of the foundations for architectural represen- tation and analysis. One result has been the development of a generic architecture description language, called Acme, that can serve as a common representation for software architectures and that permits the integration of diverse collections of in- dependently developed architectural analysis tools. In this paper we describe the Acme language and tools, and our experience in using it to integrate architecture analysis tools and to describe component-based systems. },
      KEYWORDS = {Acme, Software Architecture}
}
157
@TechReport{Bachmann2000,
      AUTHOR = {Bachmann, Felix and Bass, Len and Carriere, Jeromy and Clements, Paul and Garlan, David and Ivers, James and Nord, Robert and Little, Reed},
      TITLE = {Software Architecture Documentation in Practice: Documenting Architectural Layers},
      YEAR = {2000},
      NUMBER = {CMU/SEI-2000-SR-004},
      INSTITUTION = {Software Engineering Institute},
      KEYWORDS = {Software Architecture}
}
158
@TechReport{Garlan2000d,
      AUTHOR = {Garlan, David and Sousa, João Pedro},
      TITLE = {Documenting Software Architectures: Recommendations for Industrial Practice},
      YEAR = {2000},
      MONTH = {October},
      NUMBER = {CMU-CS-00-169},
      INSTITUTION = {Carnegie Mellon University School of Computer Science}
}
159
@InProceedings{Garlan2000e,
      AUTHOR = {Garlan, David and Kompanek, Andrew},
      TITLE = {Reconciling the Needs of Architectural Description with Object-Modeling Notations},
      YEAR = {2000},
      MONTH = {October},
      BOOKTITLE = {Proceedings of the Third International Conference on the Unified Modeling Language - << UML >> 2000},
      ADDRESS = {York, UK},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/uml00/uml00.pdf},
      PS = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/uml00/uml00.ps},
      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. },
      KEYWORDS = {Software Architecture, UML}
}
<< 1999 >> TOP
160
@PhdThesis{Monroe1999,
      AUTHOR = {Monroe, Robert},
      TITLE = {Rapid Development of Custom Software Architecture Design Environments},
      YEAR = {1999},
      MONTH = {August},
      SCHOOL = {Carnegie Mellon University School of Computer Science},
      NOTE = {Published as CMU SCS Technical Report CMU-CS-99-161},
      KEYWORDS = {Software Architecture}
}
161
@InProceedings{Garlan1999,
      AUTHOR = {Garlan, David and Wang, Zhenyu},
      TITLE = {A Case Study in Software Architecture Interchange},
      YEAR = {1999},
      BOOKTITLE = {Proceedings of Coordination'99},
      PUBLISHER = {Springer-Verlag},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/www/publications/acme-wr2rap/acme-wr2rap.pdf},
      PS = {http://www.cs.cmu.edu/afs/cs/project/able/www/publications/acme-wr2rap/acme-wr2rap.ps},
      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. },
      KEYWORDS = {Acme, Architectural Analysis, Software Architecture}
}
162
@TechReport{Damon1999,
      AUTHOR = {Damon, Craig and Melton, Ralph and Bigelow, Elizabeth and Ivers, James and Garlan, David},
      TITLE = {Formalizing a Specification for Analysis: The HLA Ownership Properties},
      YEAR = {1999},
      MONTH = {April},
      NUMBER = {CMU-CS-99-126},
      INSTITUTION = {Carnegie Mellon University School of Computer Science},
      KEYWORDS = {Architectural Analysis, Formal Methods, Software Architecture}
}
<< 1998 >> TOP
163
@InProceedings{AGI98FSE,
      AUTHOR = {Allen, Robert and Garlan, David and Ivers, James},
      TITLE = {Formal Modeling and Analysis of the HLA Component Integration Standard},
      YEAR = {1998},
      MONTH = {November},
      BOOKTITLE = {Proceedings of the Sixth International Symposium on the Foundations of Software Engineering (FSE-6)},
      KEY = {Allen},
      ADDRESS = {Lake Buena Vista, Florida},
      PUBLISHER = {ACM},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/hla-fse98/hla-fse98.pdf},
      PS = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/hla-fse98/hla-fse98.ps},
      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. },
      KEYWORDS = {Architectural Analysis, Formal Methods, Software Architecture}
}
164
@Article{DGJN97,
      AUTHOR = {Dingel, Jurgen and Garlan, David and Jha, Somesh and Notkin, David},
      TITLE = {Towards a formal treatment of implicit invocation using rely/guarantee reasoning},
      YEAR = {1998},
      JOURNAL = {Formal Aspects of Computing},
      VOLUME = {1-},
      PAGES = {193-213},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/implinvoc-fac98/implinvoc-fac98.pdf},
      PS = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/implinvoc-fac98/implinvoc-fac98.ps},
      ABSTRACT = {Implicit invocation has become an important architectural style for large-scale system design and evolution. This paper addresses the lack of specification and verification formalisms for such systems. A formal computational model for implicit invocation is presented. We develop a verification framework for implicit invocation that is based on Jones' rely/guarantee reasoning for concurrent systems. The application of the framework is illustrated with several examples. The merits and limitations of the rely/guarantee paradigm in the context of implicit invocation systems are also discussed. },
      NOTE = {Supersedes CMU-CS-97-153.},
      KEYWORDS = {Implicit Invocation, Formal Methods, Software Architecture}
}
165
@InProceedings{Dingel1998,
      AUTHOR = {Dingel, Jurgen and Garlan, David and Jha, Somesh and Notkin, David},
      TITLE = {Reasoning about Implicit Invocation},
      YEAR = {1998},
      MONTH = {November},
      BOOKTITLE = {Proceedings of the Sixth International Symposium on the Foundations of Software Engineering (FSE-6)},
      ADDRESS = {Lake Buena Vista, Florida},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/implinvoc-fse98/implinvoc-fse98.pdf},
      PS = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/implinvoc-fse98/implinvoc-fse98.ps},
      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. },
      KEYWORDS = {Formal Methods, Implicit Invocation, Model Checking, Software Architecture}
}
166
@InProceedings{Spitznagel1998,
      AUTHOR = {Spitznagel, Bridget and Garlan, David},
      TITLE = {Architecture-Based Performance Analysis},
      YEAR = {1998},
      MONTH = {June},
      BOOKTITLE = {Proceedings of the 1998 Conference on Software Engineering and Knowledge Engineering (SEKE'98)},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/perform-seke98/perform-seke98.pdf},
      PS = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/perform-seke98/perform-seke98.ps},
      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. },
      KEYWORDS = {Architectural Analysis, Software Architecture}
}
167
@InProceedings{Garlan98OMG,
      AUTHOR = {Garlan, David},
      TITLE = {Higher-Order Connectors},
      YEAR = {1998},
      MONTH = {January},
      BOOKTITLE = {Proceedings of Workshop on Compositional Software Architectures},
      KEY = {Garlan},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/hoc-omg98/hoc-omg98.pdf},
      PS = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/hoc-omg98/hoc-omg98.ps},
      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. },
      ANNOTE = {http://www.objs.com/workshops/ws9801/index.html},
      KEYWORDS = {Software Architecture}
}
168
@InProceedings{Allen98FASE,
      AUTHOR = {Allen, Robert and Douence, Remi and Garlan, David},
      TITLE = {Specifying and Analyzing Dynamic Software Architectures},
      YEAR = {1998},
      MONTH = {March},
      BOOKTITLE = {Proceedings of the 1998 Conference on Fundamental Approaches to Software Engineering (FASE'98)},
      KEY = {Allen},
      VOLUME = {1382},
      SERIES = {Lecture Notes in Computer Science},
      ADDRESS = {Lisbon, Portugal},
      PUBLISHER = {Springer},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/wright-fase98/wright-fase98.pdf},
      PS = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/wright-fase98/wright-fase98.ps},
      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. },
      NOTE = {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.},
      ANNOTE = {CONFERENCE-URL : http://www.di.fc.ul.pt:80/~llf/etaps98/},
      KEYWORDS = {Dynamism, Formal Methods, Software Architecture, Wright}
}
<< 1997 >> TOP
169
@PhdThesis{Schmerl1997,
      AUTHOR = {Schmerl, Bradley},
      TITLE = {Designing Configuration Management Tools for Dynamically Composed Systems},
      YEAR = {1997},
      MONTH = {October},
      ADDRESS = {Adelaide, South Australia},
      SCHOOL = {Flinders University},
      PDF = {http://www.cs.cmu.edu/~schmerl/publications/thesis.pdf}
}
170
@InProceedings{Schmerl1997a,
      AUTHOR = {Schmerl, Bradley and Marlin, Chris},
      TITLE = {Versioning and Consistency for Dynamically Composed Configurations},
      YEAR = {1997},
      MONTH = {May},
      BOOKTITLE = {The 7th International Workshop on Software Configuration Management},
      VOLUME = {1235},
      PAGES = {49-65},
      SERIES = {Lecture Notes in Computer Science},
      ADDRESS = {Boston, MA},
      PUBLISHER = {Springer, Berlin},
      ABSTRACT = {Dynamically composed software systems are constructed as they execute. Although these systems are of increasing importance and arise in a number of application areas, configuration management tools do not provide much support for them. This paper presents progress towards providing enhanced configuration management techniques for dynamically composed systems. The paper commences with an example of dynamically composed systems, which is used to motivate the relevance of dynamically composed systems, and to highlight various design issues and requirements for configuration management in this domain. A model, and its associated notation DCDL, is then presented to describe particular aspects of the example. This model seamlessly integrates the notions of consistency, specified in terms of complete configurations, and version families, which are relevant to the incomplete configurations of crucial importance in understanding configurations of dynamically composed systems. DCDL is then used to provide insight into the requirements for configuration management tools for dynamically composed systems.}
}
171
@InProceedings{Glastonbury1997,
      AUTHOR = {Glastonbury, Dan and Marlin, Chris and Read, Michael and Schmerl, Bradley},
      TITLE = {Run-time views as a debugging aid in an integrated software development environment},
      YEAR = {1997},
      MONTH = {December},
      BOOKTITLE = {1997 Software Visualisation Workshop},
      PAGES = {51-59},
      ADDRESS = {Adelaide, South Australia},
      PUBLISHER = {Flinders University, South Australia}
}
172
@Article{Monroe97Software,
      AUTHOR = {Monroe, Robert T. and Kompanek, Andrew and Melton, Ralph and Garlan, David},
      TITLE = {Architectural Styles, Design Patterns, and Objects},
      YEAR = {1997},
      MONTH = {January},
      JOURNAL = {IEEE Software},
      KEY = {Monroe},
      VOLUME = {14},
      NUMBER = {1},
      PAGES = {43-52},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/ObjPatternsArch-ieee97/ObjPatternsArch-ieee97.pdf},
      PS = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/ObjPatternsArch-ieee97/ObjPatternsArch-ieee97.ps},
      ABSTRACT = {Software system builders are increasingly recognizing the importance of exploiting design knowledge in the engineering of new systems. One way to do this is to define an architectural style for a collection of related systems. The style determines a coherent vocabulary of system design elements and rules for their composition. By structuring the design space for a family of related systems a style can, in principle, drastically simplify the process of building a system, reduce costs of implementation through reusable infrastructure, and improve system integrity through style-specific analyses and checks. Like architectural style, object-oriented design patterns attempt to capture and exploit design knowledge to ease the process of designing software systems and reusing proven designs. There are, however, significant differences in the roles and capabilities of architectural styles and object-oriented design patterns, as there are between architectural design and object-oriented design. In this paper we illustrate the relationship between software architecture and object-oriented design, as well as the relationship between architectural styles and design patterns. We begin by defining our terms and then proceed to compare and contrast the various approaches with examples. },
      KEYWORDS = {Architectural Style, Software Architecture}
}
173
@PhdThesis{Allen97Thesis,
      AUTHOR = {Allen, Robert},
      TITLE = {A Formal Approach to Software Architecture},
      YEAR = {1997},
      MONTH = {January},
      SCHOOL = {Carnegie Mellon, School of Computer Science},
      PDF = {http://reports-archive.adm.cs.cmu.edu/anon/1997/CMU-CS-97-144.pdf},
      PS = {http://reports-archive.adm.cs.cmu.edu/anon/1997/CMU-CS-97-144.ps},
      ABSTRACT = {As software systems become more complex, the overall system structure---or software architecture---becomes a central design problem. A system's architecture provides a model of the system that suppresses implementation detail, allowing the architect to concentrate on the analyses and decisions that are most crucial to structuring the system to satisfy its requirements. Unfortunately, current representations of software architecture are informal and ad hoc. While architectural concepts are often embodied in infrastructure to support specific architectural styles and in the initial conceptualization of a system configuration, the lack of an explicit, independently-characterized architecture or architectural style significantly limits the benefits of software architectural design in current practice. In this dissertation, I show that an Architecture Description Language based on a formal, abstract model of system behavior can provide a practical means of describing and analyzing software architectures and architectural styles. This dissertation demonstrates this claim through Wright, an architectural description language based on the formal description of the abstract behavior of architectural components and connectors. Wright provides a practical formal basis for the description of both architectural configurations and of architectural styles. It is distinguished by the use of explicit, independent connector types as interaction patterns, the ability to describe the abstract behavior of components using a CSP-like notation, the characterization of styles using predicates over system instances, and a collection of static checks to determine the consistency and completeness of an architectural specification. We introduce techniques to support the analysis of large-scale systems, and demonstrate Wright's expressiveness and practicality through three case studies. },
      NOTE = {Issued as CMU Technical Report CMU-CS-97-144.}
}
174
@Article{Allen97TOSEM,
      AUTHOR = {Allen, Robert and Garlan, David},
      TITLE = {A Formal Basis for Architectural Connection},
      YEAR = {1997},
      MONTH = {July},
      JOURNAL = {ACM Transactions on Software Engineering and Methodology},
      KEY = {Allen},
      VOLUME = {6},
      NUMBER = {3},
      PAGES = {213-249},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/wright-tosem97-revision/wright-tosem97-revision.pdf},
      PS = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/wright-tosem97-revision/wright-tosem97-revision.ps},
      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 formal approach to one aspect of architectural design: 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 further provide a formal semantics and show how this leads to a system in which architectural compatibility can be checked in a way analogous to type checking in programming languages. },
      KEYWORDS = {Formal Methods, Model Checking, Software Architecture}
}
175
@InProceedings{Melton97CASCON,
      AUTHOR = {Melton, Ralph and Garlan, David},
      TITLE = {Architectural Unification},
      YEAR = {1997},
      MONTH = {November},
      BOOKTITLE = {Proceedings of CASCON'97},
      KEY = {Melton},
      ADDRESS = {Ontario, Canada},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/Unification/Unification.pdf},
      PS = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/Unification/Unification.ps},
      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. },
      ANNOTE = {CONFERENCE-URL : http://www.cas.ibm.ca/cascon/cfp.html}
}
176
@InProceedings{Allen97SimWkshop,
      AUTHOR = {Allen, Robert and Garlan, David},
      TITLE = {Formal Modeling and Analysis of the HLA RTI},
      YEAR = {1997},
      MONTH = {March},
      BOOKTITLE = {Summary Report of the 1997 Spring Simulation Interoperability Workshop},
      KEY = {Allen},
      PAGES = {1153-1161},
      ADDRESS = {Orlando, Florida},
      PUBLISHER = {Institute for Simulation and Training},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/hla-siw97/hla-siw97.pdf},
      PS = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/hla-siw97/hla-siw97.ps},
      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. },
      NOTE = {IST-CF-97-01.2},
      KEYWORDS = {Formal Methods, Software Architecture, Wright}
}
177
@InProceedings{Garlan97CASCON,
      AUTHOR = {Garlan, David and Monroe, Robert T. and Wile, David},
      TITLE = {Acme: An Architecture Description Interchange Language},
      YEAR = {1997},
      MONTH = {November},
      BOOKTITLE = {Proceedings of CASCON'97},
      KEY = {Garlan},
      PAGES = {169-183},
      ADDRESS = {Toronto, Ontario},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/acme-cascon97/acme-cascon97.pdf},
      PS = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/acme-cascon97/acme-cascon97.ps},
      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. },
      ANNOTE = {CONFERENCE-URL : http://www.cas.ibm.ca/cascon/cfp.html},
      KEYWORDS = {Acme, Software Architecture}
}
178
@Article{Garlan1997,
      AUTHOR = {Garlan, David and Tomayko, James and Gluch, David},
      TITLE = {Agents of Change: Educating Future Leaders in Software Engineering},
      YEAR = {1997},
      MONTH = {November},
      JOURNAL = {IEEE Computer},
      KEYWORDS = {Software Engineering, Education}
}
179
@TechReport{Dingel1997,
      AUTHOR = {Dingel, Juergen and Garlan, David and Jha, Somesh and Notkin, David},
      TITLE = {Toward a formal treatment of implicit invocation},
      YEAR = {1997},
      MONTH = {July},
      NUMBER = {CMU-CS-97-153},
      INSTITUTION = {Carnegie Mellon University School of Computer Science},
      KEYWORDS = {Formal Methods, Implicit Invocation}
}
<< 1996 >> TOP
180
@TechReport{Schmerl1996,
      AUTHOR = {Schmerl, Bradley and Marlin, Chris},
      TITLE = {Modelling Dynamic Configurations to Guide Tool Design},
      YEAR = {1996},
      NUMBER = {97-01},
      INSTITUTION = {Flinders University Department of Computer Science},
      PDF = {http://www.cs.cmu.edu/~schmerl/publications/schmerl97modelling},
      ABSTRACT = {The ability to update a software system as it is being used is increasingly important and manifests itself in systems that must be maintained while executing, in systems where choices about which components comprise a system are deferred until their use, and where systems can be customised. Systems that fit one or more of these characteristics we call Dynamically Composed Systems (DCSs). Although some attention has been given to providing tools to support dynamic updates, and models of such dynamic updates have been constructed, little work as been done in examining this from a configuration management perspective. This paper describes a model of configuration management for dynamically composed systems, based on an existing model of configuration management for statically composed systems. The model includes a dynamic configuration description language, DCDL, and a formalization in terms of many-sorted algebraic specification techniques. The use of this model to design tools to support configuration management for dynamically composed systems is then discussed.}
}
181
@InProceedings{Schmerl1996a,
      AUTHOR = {Schmerl, Bradley and Marlin, Chris},
      TITLE = {Consistency issues in partially bound dynamically composed systems},
      YEAR = {1996},
      MONTH = {June},
      BOOKTITLE = {Proc.eedings of the 1996 Australian Software Engineering Conference},
      PAGES = {183-191},
      ADDRESS = {Melbourne, Australia},
      PDF = {http://www.cs.cmu.edu/~schmerl/publications/schmerl96consistency,pdf},
      ABSTRACT = {Dynamically composed systems are able to incorporate new components as they execute. Therefore, configurations of these systems are not fully elaborated until at least the time that they are executed, and they are perhaps never fully elaborated. Such incomplete configurations are termed partially bound configurations. Although partially bound, it is still important to be able to analyse these configurations to ascertain whether they meet certain assumptions about their composition. We are endevouring to provide such support for the construction of dynamically composed systems through the application of configuration management concepts. One way in which these concepts can be applied in this domain is to explicitly state such assumptions and hence be able to validate partially bound configurations against these assumptions; in this way, inconsistencies can be reported as soon as they arise. This paper disucsses the issues involved in providing this kind of consistency mechanism for dynamically composed systems.}
}
182
@InProceedings{Schmerl1996b,
      AUTHOR = {Schmerl, Bradley and Marlin, Chris},
      TITLE = {Defining consistency in the context of partially bound configurations of dynamically composed systems},
      YEAR = {1996},
      MONTH = {March},
      BOOKTITLE = {6th International Workshop on Software Configuration Management - Preprint of Proceedings},
      ADDRESS = {Berlin, Germany}
}
183
@InProceedings{Monroe1996,
      AUTHOR = {Monroe, Robert},
      TITLE = {Capturing Design Expertise in Customized Software Architecture Design Environments},
      YEAR = {1996},
      MONTH = {October},
      BOOKTITLE = {Proceedings of the Second International Software Architecture Workshop},
      PDF = {http://www.cs.cmu.edu/afs/cs.cmu.edu/project/able/ftp/armani-isaw/armani-isaw2.pdf},
      PS = {http://www.cs.cmu.edu/afs/cs.cmu.edu/project/able/ftp/armani-isaw/armani-isaw2.ps},
      ABSTRACT = {Software architecture is receiving increasing attention as a powerful way to deal with the complexity of large software systems. It has emerged as a distinct form of abstraction for software systems with its own set of design issues, vocabulary, and goals. Like designers in other disciplines, software architects can gain significant leverage by using powerful design environments and tools. Powerful design tools generally encapsulate a relatively small amount of design expertise that provides the important functionality of the tool within a relatively large support infrastructure. In this position paper I argue that in order to make the development of specialized architectural design tools practical it must be relatively easy and inexpensive to capture and make use of the desired design expertise. I then briefly describe an emerging approach for capturing this design expertise so that it can be used to incrementally configure architectural design environments.},
      KEYWORDS = {Software Architecture}
}
184
@InProceedings{Allen95Aegis,
      AUTHOR = {Allen, Robert and Garlan, David},
      TITLE = {A Case Study in Architectural Modelling: The AEGIS System},
      YEAR = {1996},
      MONTH = {March},
      BOOKTITLE = {Proceedings of the Eighth International Workshop on Software Specification and Design (IWSSD-8)},
      KEY = {Allen},
      PAGES = {6-15},
      ADDRESS = {Paderborn, Germany},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/aegis-iwssd8/aegis-iwssd8.pdf},
      PS = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/aegis-iwssd8/aegis-iwssd8.ps},
      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.},
      KEYWORDS = {Software Architecture, Wright}
}
185
@InProceedings{Garlan97ISAW2,
      AUTHOR = {Garlan, David},
      TITLE = {Style-Based Refinement for Software Architecture},
      YEAR = {1996},
      MONTH = {October},
      BOOKTITLE = {Joint Proceedings of the Second International Software Architecture Workshop (ISAW2) and the International Workshop on Multiple Perspectives in Software Development (Viewpoints '96)},
      KEY = {Garlan},
      ADDRESS = {San Francisco, CA},
      PUBLISHER = {ACM Press},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/refinement-isaw2/refinement-isaw2.pdf},
      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.}
}
186
@Book{Shaw1996,
      AUTHOR = {Shaw, Mary and Garlan, David},
      TITLE = {Software Architecture: Perspectives on an Emerging Discipline},
      YEAR = {1996},
      PUBLISHER = {Prentice Hall},
      ABSTRACT = {This book examine architectures for software systems as well as better ways to support software development. We attempt to bring together the useful abstractions of systems design and the notations and tools of the software developer, and look at patterns used for system organization. We present an introduction to the field of software architecture. Our purpose is to illustrate the discipling and examine the ways in which architectural design can impact software design. Our selection emphasizes informal descriptions, touching lightly on formal notations and specifications and on tools to support them. The book serves two groups: First, professional software developers looking for new patterns for system organization. By identifying useful patterns clearly, giving examples, comparing them, and evaluating their utility in various settings, the book will sharpen their understanding and broaden their options. Second, students with interersts in software system organization.
Education in Software Architecture
This book can be used for a course, Architectures for Software Systems, that brings together the emerging models for software archtitectures and shows how to approach systems from an architectural point of view.
  • Teaches how to understand and evaluate the design of existing software systems from an architectural persperctive,
  • Provides the intellectual building blocks for designing new systems in principled ways using well-understood architectural paradigms,
  • Shows how formal notations and models can be used to characterize and reason about a system design,
  • Presents concrete examples of actual system architectures that can serve as models for new designs
},
      NOTE = {Prentice Hall Ordering Information},
      KEYWORDS = {Software Architecture}
}
187
@InProceedings{Monroe96ICSR,
      AUTHOR = {Monroe, Robert T. and Garlan, David},
      TITLE = {Style-based Reuse for Software Architectures},
      YEAR = {1996},
      MONTH = {April},
      BOOKTITLE = {Proceedings of the Fourth International Conference on Software Reuse},
      KEY = {Monroe},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/shelf-icsr96/shelf-icsr96.pdf},
      PS = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/shelf-icsr96/shelf-icsr96.ps},
      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.},
      KEYWORDS = {Architectural Style, Software Architecture}
}
<< 1995 >> TOP
188
@InProceedings{Schmerl1995,
      AUTHOR = {Schmerl, Bradley and Marlin, Chris},
      TITLE = {Configuration management for dynamically bound systems},
      YEAR = {1995},
      MONTH = {April},
      BOOKTITLE = {Proceedings of the 5th Workshop on Software Configuration Management},
      ADDRESS = {Seattle, WA}
}
189
@InCollection{Schmerl1995a,
      AUTHOR = {Schmerl, Bradley and Marlin, Chris},
      TITLE = {Designing configuration management facilities for dynamically bound systems},
      YEAR = {1995},
      BOOKTITLE = {Software Configuration Management: ICSE SCM-4 and SCM-5 Workshops - Selected Papers},
      VOLUME = {1005},
      PAGES = {88-100},
      EDITOR = {Estublier, Jacky},
      SERIES = {Lecture Notes in Computer Science},
      PUBLISHER = {Spring-Verlag}
}
190
@Article{Garlan95TSE-intro,
      AUTHOR = {Garlan, David and Perry, Dewayne},
      TITLE = {Introduction to the Special Issue on Software Architecture},
      YEAR = {1995},
      MONTH = {April},
      JOURNAL = {IEEE Transactions on Software Engineering},
      KEY = {Garlan},
      VOLUME = {21},
      NUMBER = {4},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/saintro-tse95/saintro-tse95.pdf},
      ABSTRACT = {A critical aspect of the design for any large software system is its gross structure represented as a high-level organization of computational elements and interactions between those elements. Broadly speaking, this is the software architectural level of design. The structure of software has long been recognized as an important issue of concern. However, recently software architecture has begun to emerge as an explicit field of study for software engineering practitioners and researchers. Evidence of this trend is apparent in a large body of recent work in research such as module interface languages, domain specific architectures, architectural description languages, design patterns and handbooks, formal underpinnings for architectural design, and architectural design environments. This IEEE Transactions on Software Engineering Special Issue on Software Architecture presents seven papers that illustrate many of these emerging research areas.},
      KEYWORDS = {Software Architecture}
}
191
@InProceedings{Garlan95Dagstuhl,
      AUTHOR = {Garlan, David},
      TITLE = {What is Style?},
      YEAR = {1995},
      MONTH = {February},
      BOOKTITLE = {Proceedings of the Dagstuhl Workshop on Software Architecture},
      KEY = {David Garlan},
      ADDRESS = {Saarbruecken, Germany},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/style-iwass95/style-iwass95.pdf},
      PS = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/style-iwass95/style-iwass95.ps},
      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. },
      KEYWORDS = {Architectural Style, Software Architecture}
}
192
@InProceedings{Allen96IWSSD,
      AUTHOR = {Allen, Robert},
      TITLE = {Formalism and Informalism in Architectural Style: A Case Study},
      YEAR = {1995},
      MONTH = {April},
      BOOKTITLE = {Proceedings of the First International Workshop on Architectures for Software Systems},
      KEY = {Garlan},
      ABSTRACT = {Increasingly, developers look to software architecture to help them control the complexity of their systems. When developing a particular system, designers tend not to explore all possible alternatives for its architecture. Instead, they use specific patterns and idioms that are effective for the domain in which they are working. We term such a collection of patterns and idioms an architectural style. Unfortunately, with few exceptions current exploitation of architectural style is informal and ad hoc. In this paper we consider an alternative to the ad hoc description of architectural styles, a formal description based on the inherent structure of software architectures. We explore this solution by describing Justo and Cunha's message passing style in Wright, an architecture description language based on CSP. },
      KEYWORDS = {Architectural Style, Software Architecture}
}
193
@InProceedings{Garlan95ICSE-17,
      AUTHOR = {Garlan, David and Allen, Robert and Ockerbloom, John},
      TITLE = {Architectural Mismatch, or, Why it's hard to build systems out of existing parts},
      YEAR = {1995},
      MONTH = {April},
      BOOKTITLE = {Proceedings of the 17th International Conference on Software Engineering},
      KEY = {Garlan},
      PAGES = {179-185},
      ADDRESS = {Seattle, Washington},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/archmismatch-icse17/archmismatch-icse17.pdf},
      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.},
      NOTE = {A revised and extended version of this paper appeared in IEEE Software, Volume 12, Issue 6, Nov. 1995 (pp. 17-26)},
      KEYWORDS = {Architectural Style, Software Architecture}
}
194
@Article{IEEE1995/reuse,
      AUTHOR = {Garlan, David and Allen, Robert and Ockerbloom, John},
      TITLE = {Architectural Mismatch: Why Reuse is so Hard},
      YEAR = {1995},
      JOURNAL = {IEEE Software},
      VOLUME = {12},
      NUMBER = {6},
      PAGES = {17-26},
      KEYWORDS = {Software Architecture}
}
195
@Article{Abowd1995,
      AUTHOR = {Abowd, Gregory and Allen, Robert and Garlan, David},
      TITLE = {Formalizing Style to Understand Descriptions of Software Architecture},
      YEAR = {1995},
      MONTH = {October},
      JOURNAL = {ACM Transactions on Software Engineering and Methodology},
      VOLUME = {4},
      NUMBER = {4},
      PAGES = {319-364},
      PDF = {http://www.cs.cmu.edu/afs/cs.cmu.edu/project/able/ftp/styleformalism-tosem95/styleformalism-tosem95.pdf},
      PS = {http://www.cs.cmu.edu/afs/cs.cmu.edu/project/able/ftp/styleformalism-tosem95/styleformalism-tosem95.ps},
      ABSTRACT = {The software architecture of most systems is usually described informally and diagrammatically by means of boxes and lines. In order for these descriptions to be meaningful, the diagrams are understood by interpreting the boxes and lines in specic, conventionalized ways. The informal, imprecise nature of these interpretations has a number of limitations. In this paper we consider these conventionalized interpretations as architectural styles and provide a formal framework for their uniform denition. In addition to providing a template for precisely dening new architectural styles, this framework allows for analysis within and between dierent architectural styles.},
      KEYWORDS = {Architectural Analysis, Architectural Style, Software Architecture}
}
196
@InCollection{Shaw1995,
      AUTHOR = {Shaw, Mary and Garlan, David},
      TITLE = {Formulations and Formalisms in Software Architecture},
      YEAR = {1995},
      BOOKTITLE = {Computer Science Today: Recent Trends and Developments},
      VOLUME = {1000},
      PAGES = {307-323},
      EDITOR = {Van Leeuwen, Jan},
      SERIES = {Lecture Notes in Computer Science},
      PUBLISHER = {Spring-Verlag},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/saformalisms-lncs1000/saformalisms-lncs1000.pdf},
      PS = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/saformalisms-lncs1000/saformalisms-lncs1000.ps},
      ABSTRACT = {Software architecture is the level of software design that ad- dresses the overall structure and properties of software systems. It provides a focus for certain aspects of design and development that are not appropriately addressed within the constituent modules. Architectural design depends heavily on accurate specications of subsystems and their interactions. These specications must cover a wide variety of properties, so the specication notations and associated methods must be selected or developed to match the properties of interest. Unfortunately, the available formal methods are only a partial match for architectural needs, which entail description of structure, packaging, environmental assumptions, representation, and performance as well as functionality. A prerequisite for devising or selecting a formal method is sound understanding of what needs to be formalized. For software architecture, much of this understanding is arising through progressive codication, which begins with real-world examples and creates progressively more precise models that eventually support formalization. This paper explores the pro- gressive codication of software architecture: the relation between emerging models and the selection, development, and use of formal systems.},
      KEYWORDS = {Software Architecture}
}
197
@InCollection{Garlan1995,
      AUTHOR = {Garlan, David and Shaw, Mary},
      TITLE = {An Introduction to Software Architecture},
      YEAR = {1995},
      BOOKTITLE = {Advances in Software Engineering and Knowledge Engineering},
      VOLUME = {2},
      EDITOR = {Ambriola, V and Tortora, G},
      SERIES = {Series on Software Engineering and Knowledge Engineering},
      PUBLISHER = {World Scientific Publishing Company},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/intro_softarch/intro_softarch.pdf},
      PS = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/intro_softarch/intro_softarch.ps},
      ABSTRACT = {As the size of software systems increases, the algorithms and data structures of the computation no longer constitute the major design problems. When systems are constructed from many components, the organization of the overall system -- the software architecture -- presents a new set of design problems. This level of design has been addressed in a number of ways including informal diagrams and descriptive terms, module interconnection languages, templates and frameworks for systems that serve the needs of specific domains, and formal models of component integration mechanisms. In this paper we provide an introduction to the emerging field of software architecture. We begin by considering a number of common architectural styles upon which many systems are currently based and show how different styles can be combined in a single design. Then we present six case studies to illustrate how architectural representations can improve our understanding of complex software systems. Finally, we survey some of the outstanding problems in the field, and consider a few of the promising research directions. },
      NOTE = {Also available as: Carnegie Mellon University Technical Report CMU-CS-94-166, January 1994. Reprinted in CMIS 460: Software Design and Development Faculty Course Guide, University of Maryland, Office of Instructional Development, Summer 1995},
      KEYWORDS = {Architectural Style, Software Architecture, Software Engineering}
}
<< 1994 >> TOP
198
@InProceedings{Garlan94ZUM,
      AUTHOR = {Garlan, David},
      TITLE = {Integrating Formal Methods into a Professional Master of Software Engineering Program},
      YEAR = {1994},
      MONTH = {June},
      BOOKTITLE = {Proceedings of the Eighth Z User Meeting},
      KEY = {Garlan},
      SERIES = {Workshops in Computing},
      ADDRESS = {Cambridge, England},
      PUBLISHER = {Springer-Verlag},
      PDF = {http://www.cs.cmu.edu/afs/cs.cmu.edu/project/able/ftp/fmmse-zum94/fmmse-zum94.pdf},
      PS = {http://www.cs.cmu.edu/afs/cs.cmu.edu/project/able/ftp/fmmse-zum94/fmmse-zum94.ps},
      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.},
      KEYWORDS = {Education, Formal Methods}
}
199
@InProceedings{Garlan94Aesop,
      AUTHOR = {Garlan, David and Allen, Robert and Ockerbloom, John},
      TITLE = {Exploiting Style in Architectural Design Environments},
      YEAR = {1994},
      MONTH = {December},
      BOOKTITLE = {Proceedings of SIGSOFT'94: The Second ACM SIGSOFT Symposium on the Foundations of Software Engineering},
      KEY = {Garlan},
      PUBLISHER = {ACM Press},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/aesop-fse2/aesop-fse2.pdf},
      PS = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/aesop-fse2/aesop-fse2.ps},
      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.},
      KEYWORDS = {Architectural Style, Software Architecture}
}
200
@TechReport{Allen94ConnectorsTR,
      AUTHOR = {Allen, Robert and Garlan, David},
      TITLE = {Formal Connectors},
      YEAR = {1994},
      MONTH = {March},
      KEY = {Allen},
      NUMBER = {CMU-CS-94-115},
      INSTITUTION = {Carnegie Mellon University, School of Computer Science},
      PS = {http://reports.adm.cs.cmu.edu/usr/anon/1994/CMU-CS-94-115.ps},
      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 further provide a formal semantics and show how this leads to a system in which architectural compatibility can be checked in a way analogous to type checking in programming languages.},
      KEYWORDS = {Formal Methods, Software Architecture}
}
201
@InProceedings{Allen94MIL,
      AUTHOR = {Allen, Robert and Garlan, David},
      TITLE = {Beyond Definition/Use: Architectural Interconnection},
      YEAR = {1994},
      MONTH = {August},
      BOOKTITLE = {Proceedings of the ACM Interface Definition Language Workshop},
      KEY = {Allen},
      VOLUME = {29},
      NUMBER = {8},
      PUBLISHER = {SIGPLAN Notices},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/connectors-idl94/connectors-idl94.pdf},
      PS = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/connectors-idl94/connectors-idl94.ps},
      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.},
      KEYWORDS = {Software Architecture, Wright}
}
202
@TechReport{Garlan1994,
      AUTHOR = {Shaw, Mary and Garlan, David},
      TITLE = {Characteristics of Higher-level Languages for Software Architectures},
      YEAR = {1994},
      NUMBER = {CMU-CS-94-210},
      INSTITUTION = {Carnegie Mellon University School of Computer Science},
      KEYWORDS = {Software Architecture}
}
203
@Misc{Garlan1994a,
      AUTHOR = {Garlan, David and Perry, Dewayne},
      TITLE = {Software Architecture: Practice, Potential, and Pitfalls Panel Introduction},
      YEAR = {1994},
      MONTH = {May},
      HOWPUBLISHED = {Panel Introduction in Proceedings of the Sixteenth International Conference on Software Engineering},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/saintro-icse16/saintro-icse16.pdf},
      PS = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/saintro-icse16/saintro-icse16.ps},
      ABSTRACT = {Whatever the long-term impact of software architecture may turn out to be, an appropriate starting point is a concrete appraisal of the current state of the practice in the use of software architecture. It is the purpose of this panel to take a step in this direction. By assembling a panel of experts with a broad base of experience in the area, we hope to provide concrete examples of what is now possible when architectural principles are applied to industrial problems in systematic ways, to consider the potential impact of software architecture over the next few years, and to suggest steps that should be taken to bring this about.},
      KEYWORDS = {Software Architecture}
}
204
@InProceedings{Garlan1994b,
      AUTHOR = {Garlan, David},
      TITLE = {The Role of Software Architecture in Requirements Engineering},
      YEAR = {1994},
      BOOKTITLE = {Proceedings of the Second International Conference on Requirements Engineering},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/sareqts-re94/sareqts-re94.pdf},
      PS = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/sareqts-re94/sareqts-re94.ps},
      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.},
      KEYWORDS = {Software Architecture, Software Engineering}
}
205
@InProceedings{Garlan1994c,
      AUTHOR = {Garlan, David and Shaw, Mary},
      TITLE = {Software Development Assignments for a Software Architecture Course},
      YEAR = {1994},
      MONTH = {May},
      BOOKTITLE = {Software Engineering Resources: Proceedings of the ACM/IEEE International Workshop on Software Engineering Education},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/assignments-csee96/assignments-csee96.pdf},
      PS = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/assignments-csee96/assignments-csee96.ps},
      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.},
      KEYWORDS = {Education, Software Architecture}
}
206
@InProceedings{Allen94ICSE,
      AUTHOR = {Allen, Robert and Garlan, David},
      TITLE = {Formalizing Architectural Connection},
      YEAR = {1994},
      MONTH = {May},
      BOOKTITLE = {Proceedings of the Sixteenth International Conference on Software Engineering},
      KEY = {Allen},
      PAGES = {71-80},
      ADDRESS = {Sorrento, Italy},
      PDF = {http://acme.able.cs.cmu.edu/pubs/uploads/pdf/AG94.pdf},
      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.},
      NOTE = {Awarded ICSE2004 Best Paper (ICSE-10)},
      KEYWORDS = {Formal Methods, Software Architecture}
}
<< 1993 >> TOP
207
@InProceedings{Abowd93FSE,
      AUTHOR = {Abowd, Gregory and Allen, Robert and Garlan, David},
      TITLE = {Using Style to Understand Descriptions of Software Architecture},
      YEAR = {1993},
      MONTH = {December},
      BOOKTITLE = {Proceedings of SIGSOFT'93: Foundations of Software Engineering},
      KEY = {Abowd},
      VOLUME = {18},
      NUMBER = {5},
      PAGES = {9-20},
      SERIES = {Software Engineering Notes},
      PUBLISHER = {ACM Press},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/styleformalism-fse1/styleformalism-fse1.pdf},
      PS = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/styleformalism-fse1/styleformalism-fse1.ps},
      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.},
      KEYWORDS = {Architectural Style, Software Architecture}
}
208
@InProceedings{Notkin1993,
      AUTHOR = {Notkin, David and Garlan, David and Griswold, William and Sullivan, Kevin},
      TITLE = {Adding Implicit Invocation to Languages: Three Aproaches},
      YEAR = {1993},
      MONTH = {November},
      BOOKTITLE = {Proceedings of the JSSST Symp. Object Technologies for Advanced Software},
      VOLUME = {742},
      SERIES = {Lecture Notes in Computer Science},
      PUBLISHER = {Spring-Verlag},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/implinvoc-jssst93/implinvoc-jssst93.pdf},
      PS = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/implinvoc-jssst93/implinvoc-jssst93.ps},
      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.},
      KEYWORDS = {Implicit Invocation}
}
<< 1992 >> TOP
209
@TechReport{Allen92PFTR,
      AUTHOR = {Allen, Robert and Garlan, David},
      TITLE = {Towards Formalized Software Architectures},
      YEAR = {1992},
      MONTH = {July},
      KEY = {Allen},
      NUMBER = {CMU-CS-92-163},
      INSTITUTION = {Carnegie Mellon University, School of Computer Science},
      PS = {http://reports-archive.adm.cs.cmu.edu/anon/1992/CMU-CS-92-163.ps},
      ABSTRACT = {An important goal in software engineering is to describe complex software systems at an architectural level of abstraction. While there are many useful architectural paradigms (pipes, blackboards, etc.) they are typically understood only idiomatically and applied in an ad hoc fashion. We show how a formal model allows us to say precisely what we mean by a software architecture, explore its properties, and systematically describe instances of the architecture. We illustrate the approach using the well-known example of pipe-filter architectures.},
      KEYWORDS = {Formal Methods, Software Architecture}
}
210
@TechReport{Garlan1992,
      AUTHOR = {Garlan, David and Scott, Curtis},
      TITLE = {Reactive Integration for Traditional Programming Languages},
      YEAR = {1992},
      NUMBER = {CMU-CS-92-217},
      INSTITUTION = {Carnegie Mellon University School of Computer Science}
}
211
@InCollection{Garlan1992a,
      AUTHOR = {Garlan, David and Shaw, Mary and Okasaki, Chris and Scott, Curtis and Swonger, Roy},
      TITLE = {Experience with a Course on Architectures for Software Systems},
      YEAR = {1992},
      BOOKTITLE = {Lecture Notes in Computer Science},
      VOLUME = {640},
      PAGES = {23-43},
      PDF = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/sacourse-csee92/sacourse-csee92.pdf},
      PS = {http://www.cs.cmu.edu/afs/cs/project/able/ftp/sacourse-csee92/sacourse-csee92.ps},
      ABSTRACT = {As software systems grow in size and complexity their design problem extends beyond algorithms and data structures to issues of system design. This area receives little or no treatment in existing computer science curricula. Although courses about specific systems are usually available there is no systematic treatment of the organizations used to assemble components into systems. These issues - the software architecture level of software design - are the subject of a new course that we taught for the first time in Spring 1992. This paper describes the motivation for the course, the content and structure of the current version, and our plans for improving the next version.},
      KEYWORDS = {Education, Software Architecture}
}
<< 1990 >> TOP
212
@Article{Delisle1990,
      AUTHOR = {Delisle, Norman and Garlan, David},
      TITLE = {A Formal Specification of an Oscilloscope},
      YEAR = {1990},
      MONTH = {September},
      JOURNAL = {IEEE Software},
      VOLUME = {7},
      NUMBER = {5}
}
Feedback: ABLE Webmaster
Last modified: Fri July 25 2014 13:46:14
        BibAdmin