Monday, Sep 11:

9:15 – 9:45: Welcome and Introduction
9:45 – 10:30: “Software Architecture Reconstruction and Compliance Checking – A Case Study” presented by Metin Altinisik (Slides)
10:30 – 11:00: Coffee Break
11:00 – 11:45: “Evaluating Software Architecture Erosion for PL/SQL Programs” presented by Tobias Olsson (Slides)
11:45 – 12:30: “The Relationship of Code Churn and Architectural Violations in the Open Source Software JabRef” by Jörg Lenhard (Slides)
12:30 – 13:30: Lunch
13:30 – 13:45: Architecting Session Introduction Planning
13:45 – 14:30: Introduction to TEAMMATES by Wilson Kurniawan
14:30 – 17:00: Architecting Session I (incl. Coffee Break): Modelling and Consistency Checking of the architecture of TEAMMATES

17:00: End of day one

Tuesday, Sep 12:

9:00 – 9:45: “Modeling Embedded Systems Using a Tailored View Framework and Architecture Modeling Constraints” presented by Sandra Schröder (Slides)
9:45 – 10:30: “Are Code Smell Detection Tools Suitable for Detecting Architecture Degradation?” presented by Pablo Antonio
10:30 – 11:00: Coffee Break
11:00 – 11:45: “Architecture Conformance Checking with Description Logics” presented by Najd Altoyan (Slides)
11:45 – 12:30: “Towards a Well-Formed Software Architecture Analysis” presented by Leo Pruijt (Slides)
12:30 – 13:30: Lunch
13:30 – 13:45: Planning of the architecting session
13:45 – 16:45: Architecting session 2: Feedback on session 1 and further experiments
16:45 – 17:00: Wrap-up

17:00 End of day two and end of workshop.


Accepted Papers

P1: Are Code Smell Detection Tools Suitable for Detecting Architecture Degradation?
Jörg Lenhard, Mohammad Mahdi Hassan, Martin Blom, and Sebastian Herold

Abstract: Context: Several studies suggest that there is a relation between code smells and architecture degradation. They claim that classes, which have degraded architecture-wise, can be detected on the basis of code smells, at least if these are manually identified in the source code.
Objective: To evaluate the suitability of contemporary code smell detection tools by combining different smell categories for fi€nding classes that show symptoms of architecture degradation.
Method: A case study is performed in which architectural inconsistencies in an open source system are detected via reflexion modeling and code smell metrics are collected through several tools. Using data mining techniques, we investigate if it is possible to automatically and accurately classify classes connected to architectural inconsistencies based on the gathered code smell data.
Results: Results suggest that existing code smell detection techniques, as implemented in contemporary tools, are not sufficiently accurate for classifying whether a class contains architectural inconsistencies, even when combining categories of code smells.
Conclusion: It seems that current automated code smell detection techniques require €fine-tuning for a speci€fic system if they are to be used for finding classes with architectural inconsistencies. More research on architecture violation causes is needed to build more accurate detection techniques that work out-of-the-box.

P2: Software Architecture Reconstruction and Compliance Checking – A Case Study
Leo Pruijt and Wiebe Wiersema

Abstract: In cases where architectural documentation is outdated or missing, software architecture reconstruction (SAR) techniques may be used to create architectural views of a system. This paper describes a case study in which SAR techniques are applied to reconstruct module views of a case system; a debt settlements suite for local governments, developed in C#. A manual approach and its results are described and compared to the outcome of a layers reconstruction algorithm. Furthermore, this paper explains how software architecture compliance checking (SACC) techniques may help to test the results of reconstruction activities. In this study, SAR and SACC were supported by HUSACCT, a tool that provides rich sets of module and rule types in support of layers, facade, and gateway patterns.

P3: The Relationship of Code Churn and Architectural Violations in the Open Source Software JabRef
Tobias Olsson, Morgan Ericsson, and 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.

P4: Evaluating Software Architecture Erosion for PL/SQL Programs
Metin Altınışık, Ersin Ersoy, and Hasan Sözer

Abstract: PL/SQL procedures are grouped into packages for providing modularity. These procedures are indirectly coupled due to their use of common database tables. We define a cohesion metric and cluster PL/SQL procedures based on this type of coupling. The metric and clustering results are used for evaluating divergence from modularity as a result of architecture erosion. A divergence is detected for each package by a combination of two criteria: i) calculated cohesion metric for the package and ii) the number of clusters that are associated with the package. Low cohesion and high number
of clusters indicate low modularity. We performed an industrial case study with a large-scale legacy system from the telecommunications domain. The results turned out to be promising, where some procedures are identified to be misplaced in packages from the modularity perspective. We also observed that divergence from modularity is consistently represented by our metric.

P5: Architecture Conformance Checking with Description Logics
Sandra Schröder and Matthias Riebisch

Abstract: Today, a lot of commercial and open source tools exist allowing to describe the intended architecture and to check architecture conformance automatically in order to detect and eventually minimize erosion. Unfortunately, those tools are restricted in terms of which architecture concepts can be used in order to describe the intended architecture. Additionally, those approaches lack an appropriate formal foundation in terms of a well-defined syntax and semantic. Nevertheless, this is a crucial requirement for automatic support in architecture conformance checking. In this paper, we propose a formal approach enabling a) the definition of an architecture concept language that allows to capture the most important architecture concepts and their related architecture rules, b) the validation of the consistency of this language, c) the mapping of
architecture concepts to source code and capturing this mapping in an explicit language in order to d) check architecture conformance. We also present an evaluation of the approach using the Common Component Modelling Example (CoCoME) case study in order to demonstrate the applicability.

P6: Towards a Well-Formed Software Architecture Analysis
Najd Altoyan and Dewayne E. Perry

Abstract: Over the past decade Software Architecture has proved to be a core component in software development processes. Therefore, the correctness of the software architecture is unsurprisingly crucial for the success of software products. Many methods for analyzing software architecture have been proposed in the literature in order to predict potential risks that impose far-reaching effects on the final product. However, almost none of these methods have been adopted in the industry as many of them require special knowledge or are simply not intuitive enough for the software developer. In this paper, we address this issue by proposing (the first step of) a framework for analyzing software architecture that is built using a semi-formal
architecture description language (ADL), and a constraint based relational model. Architecture instances following our approach are then analyzed against a set of properties such as whether the architecture is complete, self-sufficient and self-contained. Satisfying these properties yields a well-formed architecture.

P7: Modeling Embedded Systems Using a Tailored View Framework and Architecture Modeling Constraints
Andreas Morgenstern, Pablo Oliveira Antonino, Thomas Kuhn, Patrick Pschorn and Benno Kallweit

Abstract: Due to the increasing amount of computation in embedded devices, there is a need for software and systems architecture approaches specifically tailored for the needs of the domain. We present in this paper a view framework for the design of embedded systems that has evolved during various projects with industry customers. Our approach is complemented by architecture modeling constraints that can be used to automatically check the completeness and consistency of the created architecture models. In this article, we present our approach together with a preliminary experience report of the application of our approach in different domains.