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

Silvio Loffler - One of the best experts on this subject based on the ideXlab platform.

Georg Buchgeher - One of the best experts on this subject based on the ideXlab platform.

  • APSEC - Formalizing Architectural Rules with Ontologies - An Industrial Evaluation
    2019 26th Asia-Pacific Software Engineering Conference (APSEC), 2019
    Co-Authors: Sandra Schroder, Georg Buchgeher
    Abstract:

    Architecture Conformance checking is an important means for quality control to assess that the system implementation adheres to its defined software Architecture. Ideally, this process is automated to support continuous quality control. Many different approaches exist for automated Conformance checking. However, these approaches are often limited in terms of supported concepts for describing and analyzing software Architectures. We have developed an ontology-based approach that seeks to overcome the limited expressiveness of existing approaches. As a frontend of the formalism, we provide a Controlled Natural Language. In this paper, we present an industrial validation of the approach. For this, we collected architectural rules from three industrial projects. In total, we discovered 56 architectural rules in the projects. We successfully formalized 80% of those architectural rules. Additionally, we discussed the formalization with the corresponding software architect of each project. We found that the original intention of each architectural rule is properly reflected in the formalization. The results of the study show that projects could greatly benefit from applying an ontology-based approach, since it helps to precisely define and preserve concepts throughout the development process.

  • ECSA (Companion) - Discovering architectural rules in practice
    Proceedings of the 13th European Conference on Software Architecture - ECSA '19 - volume 2, 2019
    Co-Authors: Sandra Schroder, Georg Buchgeher
    Abstract:

    Architecture Conformance checking is an important technique to verify whether a software system's implementation adheres to predefined architectural rules. The adherence to architectural rules is crucial, since architectural rules are intended to ensure that fundamental properties are correctly implemented in the source code. A lot of tools have been proposed and developed for automatic Conformance checking. They are also successfully applied in industry. However, those tools mainly focus on the validation of static dependencies between modules or on ensuring the adherence to the layered Architecture. In this poster, we present an industrial case study which discovers architectural rules from three industrial projects. This study shows that software architects also define other types of architectural rules that are not yet covered by state-of-the-art Conformance checking tools. The architectural rules found in the projects are categorized into architectural rule categories. We use four representative tools as examples and show that the tools are able to formalize only a specific extent of the discovered rules. The results of the study motivate for improving existing tools and to collect further examples of architectural rules that can potentially be reused in projects with similar characteristics.

  • automatic reference Architecture Conformance checking for soa based software systems
    IEEE IFIP International Conference on Software Architecture, 2014
    Co-Authors: Rainer Weinreich, Georg Buchgeher
    Abstract:

    Company-wide reference Architectures are an important means for standardization and reuse. Standardization is enforced through reference Architecture Conformance checking. Manual Conformance checking is too time- and resource-intensive to be performed continuously for the various systems that are part of a SOA. We present an approach for automatic reference Architecture Conformance checking of SOA-based software systems. Reference Architectures are defined based on rules consisting of roles and of constraints on roles and role relationships. By mapping the roles to the elements of a software Architecture representation, reference Architecture specifications are reusable for different software systems. Through automating the whole checking process, including Architecture extraction, role mapping, and rule evaluation, the approach can be applied continuously for the different systems that are part of a SOA. The approach has been developed and refined by applying it to a SOA in the banking domain. During its evolution from semi-automatic to a fully automatic approach it has also changed the way of how Architecture information is provided as part of the system implementation in this domain.

  • WICSA - Automatic Reference Architecture Conformance Checking for SOA-Based Software Systems
    2014 IEEE IFIP Conference on Software Architecture, 2014
    Co-Authors: Rainer Weinreich, Georg Buchgeher
    Abstract:

    Company-wide reference Architectures are an important means for standardization and reuse. Standardization is enforced through reference Architecture Conformance checking. Manual Conformance checking is too time- and resource-intensive to be performed continuously for the various systems that are part of a SOA. We present an approach for automatic reference Architecture Conformance checking of SOA-based software systems. Reference Architectures are defined based on rules consisting of roles and of constraints on roles and role relationships. By mapping the roles to the elements of a software Architecture representation, reference Architecture specifications are reusable for different software systems. Through automating the whole checking process, including Architecture extraction, role mapping, and rule evaluation, the approach can be applied continuously for the different systems that are part of a SOA. The approach has been developed and refined by applying it to a SOA in the banking domain. During its evolution from semi-automatic to a fully automatic approach it has also changed the way of how Architecture information is provided as part of the system implementation in this domain.

  • towards continuous reference Architecture Conformance analysis
    European Conference on Software Architecture, 2013
    Co-Authors: Georg Buchgeher, Rainer Weinreich
    Abstract:

    Reference Architectures (RA) are reusable Architectures for artifacts in a particular domain. They can serve as a basis for designing new Architectures, but also as a means for quality control during system development. Quality control is performed through checking the Conformance of systems in development to (company-wide) reference Architectures. If performed manually, reference Architecture Conformance checking is a time- and resource-intensive process. In this paper we outline an approach for reference Architecture Conformance checking of application Architectures in the banking domain. Reference Architectures are defined on the basis of reusable rules, consisting of roles and of constraints on roles and role relationships. Conformance checking can be performed semi-automatically and continuously by automating important steps like the extraction of the actual application Architecture, the binding of reference Architecture roles to the elements of a specific application Architecture, and the evaluation of the reference Architecture rules for an application Architecture.

Anna Wingkvist - One of the best experts on this subject based on the ideXlab platform.

  • ECSA (Companion) - Semi-automatic mapping of source code using naive Bayes
    Proceedings of the 13th European Conference on Software Architecture - ECSA '19 - volume 2, 2019
    Co-Authors: Tobias Olsson, Morgan Ericsson, Anna Wingkvist
    Abstract:

    The software industry has not adopted continuous use of static Architecture Conformance checking. One hindrance is the needed mapping from source code elements to elements of the Architecture. We present a novel approach of generating and combining dependency and semantic information extracted from an initial set of mapped source code files. We use this to train a Naive Bayes classifier that is then used to map the remainder of the source code files. We compare this approach with the HuGMe technique on six open source projects with known mappings. We find that our approach provides an average performance improvement of 0.22 and an average precision and recall F1-score improvement of 0.26 in comparison to HuGMe.

  • ECSA (Companion) - Towards improved initial mapping in semi automatic clustering
    Proceedings of the 12th European Conference on Software Architecture: Companion Proceedings, 2018
    Co-Authors: Tobias Olsson, Morgan Ericsson, Anna Wingkvist
    Abstract:

    An important step in Static Architecture Conformance Checking (SACC) is the mapping of source code entities to entities in the intended Architecture. This step is currently relying on manual work, which is one hindrance for more widespread adoption of SACC in industry. Semi-automatic clustering is a promising approach to improve this, and the HuGMe clustering algorithm is an example of such a technique for use in SACC. But HuGMe relies on an initial set of clustered source code elements and algorithm parameters. We investigate the automatic mapping performance of HuGMe in two experiments to gain insight into what influence the starting set has in a medium-sized open source system, JabRef, which contain a relatively large number of architectural violations. Our results show that the highest automatic mapping performance can be achieved with a low number of elements within the initial set. However, the variability of the performance is high. We find a benefit in favoring source code elements with a high fan-out in the initial set.

  • ECSA (Companion) - The relationship of code churn and architectural violations in the open source software JabRef
    Proceedings of the 11th European Conference on Software Architecture: Companion Proceedings, 2017
    Co-Authors: Tobias Olsson, Morgan Ericsson, Anna Wingkvist
    Abstract:

    The open source application JabRef has existed since 2003. In 2015, the developers decided to make an architectural refactoring as continued development was deemed too demanding. The developers also introduced Static Architecture Conformance Checking (SACC) to prevent violations to the intended Architecture. Measurements mined from source code repositories such as code churn and code ownership has been linked to several problems, for example fault proneness, security vulnerabilities, code smells, and degraded maintainability. The root cause of such problems can be architectural. To determine the impact of the refactoring of JabRef, we measure the code churn and code ownership before and after the refactoring and find that large files with violations had a significantly higher code churn than large files without violations before the refactoring. After the refactoring, the files that had violations show a more normal code churn. We find no such effect on code ownership. We conclude that files that contain violations detectable by SACC methods are connected to higher than normal code churn.

  • motivation and impact of modeling erosion using static Architecture Conformance checking
    IEEE International Conference on Software Architecture Workshops, 2017
    Co-Authors: Tobias Olsson, Morgan Ericsson, Anna Wingkvist
    Abstract:

    We motivate and describe why erosion modeling from a static Architecture Conformance checking point of view is important as well as the impact we think it can have on industry. Our research goal is to get a better understanding of erosion and develop smarter and simpler methods to assess erosion. We describe preliminary results from a retrospective, longitudinal case study of an open source software. The software system we study, JabRef, was created in 2003, and refactored to a layered structure to "transition from a spaghetti to a more structured Architecture" in 2015. We construct a model from this new, layered Architecture, and assess 30 versions of JabRef to find architectural Conformance violations. Our preliminary results show a significant difference in productivity after refactoring and suggest that there is a connection between our model of erosion and productivity where more erosion gives lower productivity.

  • ICSA Workshops - Motivation and Impact of Modeling Erosion Using Static Architecture Conformance Checking
    2017 IEEE International Conference on Software Architecture Workshops (ICSAW), 2017
    Co-Authors: Tobias Olsson, Morgan Ericsson, Anna Wingkvist
    Abstract:

    We motivate and describe why erosion modeling from a static Architecture Conformance checking point of view is important as well as the impact we think it can have on industry. Our research goal is to get a better understanding of erosion and develop smarter and simpler methods to assess erosion. We describe preliminary results from a retrospective, longitudinal case study of an open source software. The software system we study, JabRef, was created in 2003, and refactored to a layered structure to "transition from a spaghetti to a more structured Architecture" in 2015. We construct a model from this new, layered Architecture, and assess 30 versions of JabRef to find architectural Conformance violations. Our preliminary results show a significant difference in productivity after refactoring and suggest that there is a connection between our model of erosion and productivity where more erosion gives lower productivity.

Sebastian Herold - One of the best experts on this subject based on the ideXlab platform.

  • Real-Time Reflexion Modelling in Architecture reconciliation
    Information and Software Technology, 2015
    Co-Authors: Jim Buckley, Jacek Rosik, Nour Ali, Michael English, Sebastian Herold
    Abstract:

    ContextReflexion Modelling is considered one of the more successful approaches to Architecture reconciliation. Empirical studies strongly suggest that professional developers involved in real-life industrial projects find the information provided by variants of this approach useful and insightful, but the degree to which it resolves Architecture Conformance issues is still unclear. ObjectiveThis paper aims to assess the level of Architecture Conformance achieved by professional architects using Reflexion Modelling, and to determine how the approach could be extended to improve its suitability for this task. MethodAn in vivo, multi-case-study protocol was adopted across five software systems, from four different financial services organizations. Think-aloud, video-tape and interview data from professional architects involved in Reflexion Modelling sessions were analysed qualitatively. ResultsThis study showed that (at least) four months after the Reflexion Modelling sessions less than 50% of the architectural violations identified were removed. The majority of participants who did remove violations favoured changes to the architectural model rather than to the code. Participants seemed to work off two specific architectural templates, and interactively explored their architectural model to focus in on the causes of violations, and to assess the ramifications of potential code changes. They expressed a desire for dependency analysis beyond static-source-code analysis and scalable visualizations. ConclusionThe findings support several interesting usage-in-practice traits, previously hinted at in the literature. These include (1) the iterative analysis of systems through Reflexion models, as a precursor to possible code change or as a focusing mechanism to identify the location of Architecture Conformance issues, (2) the extension of the approach with respect to dependency analysis of software systems and architectural modelling templates, (3) improved visualization support and (4) the insight that identification of architectural violations in itself does not lead to their removal in the majority of instances.

  • a rule based approach to Architecture Conformance checking as a quality management measure
    Relating System Quality and Software Architecture, 2014
    Co-Authors: Sebastian Herold, Andreas Rausch
    Abstract:

    Abstract The process of divergence between intended software Architecture and its actual implementation, often called Architecture erosion or architectural drifts, has in general negative effects on the overall quality of the system. It is hence very important to be able to check whether the realization of a system conforms to its intended Architecture. Consistency between models and Conformance are important issues in model-based software development. Conformance between models can be guaranteed partially “by construction” through Conformance preserving (semi-)automatic model transformations. Nevertheless, due to manual modification of models and the refinement and abstraction steps from high-level models to more detailed models, complete inter-model consistency cannot be guaranteed a priori in general but must be checked regularly. In this work, we address the checking of architectural Conformance in a model-based development setting. The broad range of sources for architectural rules , that is, constraints restricting the way an Architecture can be implemented and the large number of different artifacts influenced by them, requires very flexible tool support that is challenging to realize. We describe an approach to flexible Architecture Conformance checking based on a formalization of architectural rules as logical formulas. The approach is implemented prototypically and is applied in small application scenario.

  • Relating System Quality and Software Architecture - A Rule-Based Approach to Architecture Conformance Checking as a Quality Management Measure
    Relating System Quality and Software Architecture, 2014
    Co-Authors: Sebastian Herold, Andreas Rausch
    Abstract:

    Abstract The process of divergence between intended software Architecture and its actual implementation, often called Architecture erosion or architectural drifts, has in general negative effects on the overall quality of the system. It is hence very important to be able to check whether the realization of a system conforms to its intended Architecture. Consistency between models and Conformance are important issues in model-based software development. Conformance between models can be guaranteed partially “by construction” through Conformance preserving (semi-)automatic model transformations. Nevertheless, due to manual modification of models and the refinement and abstraction steps from high-level models to more detailed models, complete inter-model consistency cannot be guaranteed a priori in general but must be checked regularly. In this work, we address the checking of architectural Conformance in a model-based development setting. The broad range of sources for architectural rules , that is, constraints restricting the way an Architecture can be implemented and the large number of different artifacts influenced by them, requires very flexible tool support that is challenging to realize. We describe an approach to flexible Architecture Conformance checking based on a formalization of architectural rules as logical formulas. The approach is implemented prototypically and is applied in small application scenario.

  • EDOC - Checking Conformance with Reference Architectures: A Case Study
    2013 17th IEEE International Enterprise Distributed Object Computing Conference, 2013
    Co-Authors: Sebastian Herold, Andreas Rausch, Matthias Mair, Ingrid Schindler
    Abstract:

    Reference Architecture can help in enterprise Architecture management to develop and operate standardized and maintainable software landscapes. Similar to the software Architectures of single systems, however, they are threatened by Architecture erosion, i.e. the continuous divergence between intended Architectures and their actual realizations. Architecture erosion has negative effects on the maintainability of software systems and on other quality attributes. In this paper, we report on the application of a rule-based Architecture Conformance checking approach in an industrial case study in which we investigate an industrial reference Architecture for the German public administration. The reference Architecture and its constraints for implementations are formalized as Architecture rules enabling automatic Conformance checking tool support. The results from the case study show that the approach is capable of checking reference Architecture Conformance in realistic settings and helps to avoid software Architecture erosion.

Walter R Bischofberger - One of the best experts on this subject based on the ideXlab platform.