The Experts below are selected from a list of 360 Experts worldwide ranked by ideXlab platform

David Garlan - One of the best experts on this subject based on the ideXlab platform.

  • Formal Modeling and Analysis of the HLA RTI
    2018
    Co-Authors: Robert Allen, David Garlan
    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

  • Style-Based Renement for Software Architecture
    2016
    Co-Authors: David Garlan
    Abstract:

    A question that frequently arises for Architectural design is \When can I implement a design in style S 1 using a design in style S 2? " In this paper I propose a technique for structur-ing a solution to this kind of problem using the idea of sub-styles. This technique leads to a two-step process in which rst, useful subsets of a family of architectures are identi-ed, and second, renement rules specic to these subsets are established. I will argue that this technique, in combi-nation with an unconventional interpretation of renement, clari es how engineers actually carry out Architectural re-nement and provides a formal framework for establishing the correctness of those methods. 1 The importance of style-based renement A key issue for Architectural design is to understand when a system characterized in one style can be substituted for one described in another. That is, when can I use an instance of style S 1 in place of a system already described in style S 2 This problem arises in a number of contexts: Representing the internal structure of an archi-tectural component (or connector): Often the el-ements of an Architectural Description are implemented internally by another, more detailed architecture. In some cases the boundary of one element serves to ag-gregate and encapsulate certain parts of a complex de-scription (i.e.,

  • acme an architecture Description interchange language
    Conference of the Centre for Advanced Studies on Collaborative Research, 2010
    Co-Authors: David Garlan, Robert T. Monroe, David S. Wile
    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.

  • Reconciling the needs of Architectural Description with object-modeling notations
    Science of Computer Programming, 2002
    Co-Authors: David Garlan, Shang-wen Cheng, Andrew J. Kompanek
    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, an 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 UML. Specifically, we describe (a) the principal 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.

  • reconciling the needs of Architectural Description with object modeling notations
    Lecture Notes in Computer Science, 2000
    Co-Authors: David Garlan, Andrew J. Kompanek
    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.

Andrew J. Kompanek - One of the best experts on this subject based on the ideXlab platform.

  • Reconciling the needs of Architectural Description with object-modeling notations
    Science of Computer Programming, 2002
    Co-Authors: David Garlan, Shang-wen Cheng, Andrew J. Kompanek
    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, an 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 UML. Specifically, we describe (a) the principal 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.

  • reconciling the needs of Architectural Description with object modeling notations
    Lecture Notes in Computer Science, 2000
    Co-Authors: David Garlan, Andrew J. Kompanek
    Abstract:

    Complex software systems require expressive notations for representing their software architectures. Two competing paths have emerged. One is to use a specialized notation for architecture - or architecture Description language (ADL). The other is to adapt a general-purpose modeling notation, such as UML. The latter has a number of benefits, including familiarity to developers, close mapping to implementations, and commercial tool support. However, it remains an open question as to how best to use object-oriented notations for Architectural Description, and, indeed, whether they are sufficiently expressive, as currently defined. In this paper we take a systematic look at these questions, examining the space of possible mappings from ADLs into object notations. Specifically, we describe (a) the principle strategies for representing Architectural structure in UML; (b) the benefits and limitations of each strategy; and (c) aspects of Architectural Description that are intrinsically difficult to model in UML using the strategies.

David L Dill - One of the best experts on this subject based on the ideXlab platform.

  • automatic verification of pipelined microprocessor control
    Computer Aided Verification, 1994
    Co-Authors: J R Burch, David L Dill
    Abstract:

    We describe a technique for verifying the control logic of pipelined microprocessors. It handles more complicated designs, and requires less human intervention, than existing methods. The technique automatically compares a pipelined implementation to an Architectural Description. The CPU time needed for verification is independent of the data path width, the register file size, and the number of ALU operations. Debugging information is automatically produced for incorrect processor designs. Much of the power of the method results from an efficient validity checker for a logic of uninterpreted functions with equality. Empirical results include the verification of a pipelined implementation of a subset of the DLX architecture.

Alessandro Aldini - One of the best experts on this subject based on the ideXlab platform.

  • process algebraic Architectural Description languages generalizing component oriented mismatch detection in the presence of nonsynchronous communications
    arXiv: Software Engineering, 2018
    Co-Authors: Marco Bernardo, Edoardo Bonta, Alessandro Aldini
    Abstract:

    In the original paper, we showed how to enhance the expressiveness of a typical process algebraic Architectural Description language by including the capability of representing nonsynchronous communications. In particular, we extended the language by means of additional qualifiers enabling the designer to distinguish among synchronous, semi-synchronous, and asynchronous ports. Moreover, we showed how to modify techniques for detecting coordination mismatches such as the compatibility check for star topologies and the interoperability check for cycle topologies, in such a way that those two checks are applicable also in the presence of nonsynchronous communications. In this addendum, we generalize those results by showing that it is possible to verify in a component-oriented way an arbitrary property of a certain class (not only deadlock) over an entire Architectural type having an arbitrary topology (not only stars and cycles) by considering also behavioral variations, exogenous variations, endogenous variations, and multiplicity variations, so to deal with the possible presence of nonsynchronous communications. The proofs are at the basis of some results mentioned in the book "A Process Algebraic Approach to Software Architecture Design" by Alessandro Aldini, Marco Bernardo, and Flavio Corradini, published by Springer in 2010.

  • handling communications in process algebraic Architectural Description languages modeling verification and implementation
    Journal of Systems and Software, 2010
    Co-Authors: Marco Bernardo, Edoardo Bonti, Alessandro Aldini
    Abstract:

    Architectural Description languages are a useful tool for modeling complex software systems at a high level of abstraction. If based on formal methods, they can also serve for enabling the early verification of various properties such as component coordination and for guiding the synthesis of code correct by construction. This is the case with process algebraic Architectural Description languages, which are process calculi enhanced with the main Architectural concepts. However, the techniques with which those languages have been equipped are mainly conceived to work with synchronous communications only. The objective of this paper is threefold. On the modeling side, we show how to enhance the expressiveness of a typical process algebraic Architectural Description language by including the capability of representing nonsynchronous communications in such a way that the usability of the original language is preserved. On the verification side, we show how to modify techniques for analyzing the absence of coordination mismatches like the compatibility check for acyclic topologies and the interoperability check for cyclic topologies in such a way that those checks are valid also for nonsynchronous communications. On the implementation side, we show how to generate multithreaded object-oriented software in the presence of synchronous and nonsynchronous communications in such a way that the properties proved at the Architectural level are preserved at the code level.

Wilhelm Hasselbring - One of the best experts on this subject based on the ideXlab platform.

  • the archmapper approach to Architectural conformance checks an eclipse based tool for style oriented architecture to code mappings
    Giesecke Simon Gottschalk Michael and Hasselbring Wilhelm (2010) The ArchMapper Approach to Architectural Conformance Checks: An Eclipse-based Tool fo, 2010
    Co-Authors: Simon Giesecke, Michael Gottschalk, Wilhelm Hasselbring
    Abstract:

    The ArchMapper approach allows performing two activities in the software development process efficiently: checking the conformance of the code to the intended architecture as specified by an Architectural Description, and generating code skeletons and architecture-related configuration files from the Architectural Description. Both directions exploit information based on the Architectural style of the software system. An Architectural style may be as simple as the style of layered architectures, or it may correspond to a specific middleware platform, which allows more specific analyses and generation. We have applied the approach to the style of the Spring MVC framework, where several Architectural properties can be checked, and the Spring configuration file for the application may be automatically generated from the Architectural Description.

  • a style based architecture modelling approach for uml 2 component diagrams
    International Conference on Software Engineering, 2007
    Co-Authors: Simon Giesecke, Matthias Rohr, Florian Marwede, Wilhelm Hasselbring
    Abstract:

    There has been a variety of work arguing that the UML 1.x was not adequate as an Architectural Description Language (ADL). UML 2.x has made a large step towards supporting modelling software architectures, e.g. through the introduction of modelling constructs for composite structures. But many modelling constructs from ADLs can still not be mapped to the UML in a straightforward way. Important examples are typed connectors and Architectural styles. We propose a mapping of of the MidArch modelling approach, which is similar to the well-known ADL Acme, to the UML 2.x and the OCL. The mapping is based on mapping the style/family construct to UML Profiles and the system/configuration construct to UML Component Diagrams. Architectural constraints are directly mapped to OCL constraints. In addition, OCL constraints are used to specialize the architecture modelling constructs of UML 2.x, and thus adapt the UML 2.x to the MidArch modelling approach. We describe a case study applying our approach and discuss our experiences.