| 131. |
- Olsson, Tobias, 1974-, et al.
(författare)
-
s4rdm3x : A Tool Suite to Explore Code to ArchitectureMapping Techniques
- 2021
-
Ingår i: Journal of Open Source Software. - : Open journals. - 2475-9066. ; 6:58
-
Tidskriftsartikel (refereegranskat)abstract
- Architectural drift and erosion, where the implementation starts to deviate from the intended software architecture or the rules set by it, are common problems in long-lived software systems. This can be avoided by using techniques, such as Reflexion modeling, to validate that the implementation conforms to the indented architecture. Unfortunately, such techniques require a mapping from source code modules (e.g., classes) to elements of the architecture, something that is not always available or up to date. This is a known problem when, e.g., companies want to adopt static architecture conformance checking; the effort to manually create or bring this mapping up to date is just too time-consuming and error-prone. The s4rdm3x tool suite is designed for researchers and practitioners to study and evaluate algorithms that perform part of the mapping automatically, such as orphan-adoption clustering or information retrieval techniques. It includes a graphical user interface to define and run experiments with mapping algorithms and their parameters, and visualize and explore the results of these experiments. The experiments can be executed locally or in a remote high-performance computing environment. The tool suite includes reference implementations of state of the art mapping algorithms and a set of Java systems with validated mappings between classes and architecture elements. The tool suite is extensible, so it is easy to add new mapping algorithms and visualizations to explore their performance.
|
|
| 132. |
- Olsson, Tobias, 1974-, et al.
(författare)
-
Semi-Automatic Mapping of Source Code Using Naive Bayes
- 2019
-
Ingår i: ECSA '19 Proceedings of the 13th European Conference on Software Architecture -. - New York, NY, USA : ACM Publications. - 9781450371421 ; , s. 209-216
-
Konferensbidrag (refereegranskat)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.
|
|
| 133. |
- Olsson, Tobias, 1974-, et al.
(författare)
-
Studying expert initial set and hard to map cases in automated code-to-architecture mappings
- 2021
-
Ingår i: Companion Proceedings of the 15th European Conference on Software Architecture. - : CEUR-WS.
-
Konferensbidrag (refereegranskat)abstract
- We study the mapping of software source code to architectural modules. Background: To evaluate techniques for performing automatic mapping of code-to-architecture, a ground truth mapping, often provided by an expert, is needed. From this ground truth, techniques use an initial set of mapped source code as a starting point. The size and composition of this set affect the techniques’ performance, and to make comparisons, random sizes and compositions are used. However, while randomness will give a baseline for comparison, it is not likely that a human expert would compose an initial set on random to map source code. We are interested in letting an expert create an initial set based on their experience with the system and study how this affects how a technique performs. Also, previous research has shown that when comparing an automatic mapping with the ground truth mappings, human experts often accept the automated mappings and, if not, point to the need for refactoring the source code. We want to study this phenomenon further. Audience: Researchers and developers of tools in the area of architecture conformance. The system expert can gain valuable insights into where the source code needs to be refactored. Aim: We hypothesize that an initial set assigned by an expert performs better than a random initial set of similar size and that an expert will agree upon or find opportunities for refactoring in a majority of cases where the automatic mapping and expert mapping disagrees. Method: The initial set will be extracted from an interview with the expert. Then the performance (precision and recall f1 score) will be compared to mappings starting from random initial sets and using an automatic technique. We will also use our tool to find the cases where the automatic and human mapping disagrees and then let the expert review these cases. Results: We expect to find a difference when performance is compared. We expect the expert review to reveal source code that should be remapped, source code that needs refactoring (e.g., possible architectural violations), and points where the automatic technique needs to be improved. Limitations: The study will only focus on only a single system, which limits the external validity significantly. The protocol for the interaction with the human expert can also introduce validity problems; for example, a mapping presented by an algorithm could be perceived as more objective and thus more acceptable for a software engineer. Conclusions: We seek to improve our understanding of how a human creates an initial set for automatic mapping and its effect on how well an automated mapping technique performs. By improving the ground truth mappings, we can improve our techniques, tools, and methods for architecture conformance checking.
|
|
| 134. |
- Olsson, Tobias, 1974-, et al.
(författare)
-
The relationship of code churn and architectural violations in the open source software JabRef
- 2017
-
Ingår i: ECSA '17 Proceedings of the 11th European Conference on Software Architecture. - New York, NY, USA : ACM Publications. - 9781450352178 ; , s. 152-158
-
Konferensbidrag (refereegranskat)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.
|
|
| 135. |
- Olsson, Tobias, 1974-, et al.
(författare)
-
To automatically map source code entities to architectural modules with Naive Bayes
- 2022
-
Ingår i: Journal of Systems and Software. - : Elsevier. - 0164-1212 .- 1873-1228. ; 183
-
Tidskriftsartikel (refereegranskat)abstract
- Background: The process of mapping a source code entity onto an architectural module is to a large degree a manual task. Automating this process could increase the use of static architecture conformance checking methods, such as reflexion modeling, in industry. Current techniques rely on user parameterization and a highly cohesive design. A machine learning approach would potentially require fewer parameters and better use of the available information to aid in automatic mapping.Aim: We investigate how a classifier can be trained to map from source code to architecture modules automatically. This classifier is trained with semantic and syntactic dependency information extracted from the source code and from architecture descriptions. The classifier is implemented using multinomial naive Bayes and evaluated.Method: We perform experiments and compare the classifier with three state-of-the-art mapping functions in eight open-source Java systems with known ground-truth-mappings.Results: We find that the classifier outperforms the state-of-the-art in all cases and that it provides a useful baseline for further research in the area of semi-automatic incremental clustering.Conclusions: We conclude that machine learning is a useful approach that performs better and with less need for parameterization compared to other approaches. Future work includes investigating problematic mappings and a more diverse set of subject systems.
|
|
| 136. |
- Olsson, Tobias, 1974-, et al.
(författare)
-
Towards Improved Initial Mapping in Semi Automatic Clustering
- 2018
-
Ingår i: ECSA 2018. - New York, NY, USA : Association for Computing Machinery (ACM). - 9781450364836
-
Konferensbidrag (refereegranskat)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.
|
|
| 137. |
- Olsson, Tobias, 1974-, et al.
(författare)
-
Using Repository Data for Driving Software Architecture
- 2018
-
Ingår i: Proceeding of the 40th International Conference on Software Engineering. - New York, NY, USA : ACM Publications. - 9781450356633 ; , s. 197-198
-
Konferensbidrag (refereegranskat)abstract
- We are in the pursuit of establishing a method for continuous data driven software architecture. We describe the problem with current methods for measuring the impact of refactoring long lived systems at the architectural level and architecture compliance checking. We summarize our studies of code churn, productivity and an automatic tool for compliance checking. We conclude that architecture violations seem to play an important role, but current methods are infeasible for industry practice. Finally we propose to use repository data mining to improve current methods for architecture compliance checking.
|
|
| 138. |
|
|
| 139. |
- Pecl, Gretta T., et al.
(författare)
-
Climate-driven 'species-on-the-move' provide tangible anchors to engage the public on climate change
- 2023
-
Ingår i: People and Nature. - : John Wiley & Sons. - 2575-8314. ; 5:5, s. 1384-1402
-
Tidskriftsartikel (refereegranskat)abstract
- Over recent decades, our understanding of climate change has accelerated greatly, but unfortunately, observable impacts have increased in tandem. Both mitigation and adaptation have not progressed at the level or scale warranted by our collective knowledge on climate change. More effective approaches to engage people on current and future anthropogenic climate change effects are urgently needed. Here, we show how species whose distributions are shifting in response to climate change, that is, ‘species-on-the-move’, present an opportunity to engage people with climate change by linking to human values, and our deep connections with the places in which we live, in a locally relevant yet globally coherent narrative. Species-on-the-move can impact ecosystem structure and function, food security, human health, livelihoods, culture and even the climate itself through feedback to the climate system, presenting a wide variety of potential pathways for people to understand that climate change affects them personally as individuals. Citizen science focussed on documenting changes in biodiversity is one approach to foster a deeper engagement on climate change. However, other possible avenues, which may offer potential to engage people currently unconnected with nature, include arts, games or collaborations with rural agriculture (e.g. new occurrences of pest species) or fisheries organisations (e.g. shifting stocks) or healthcare providers (e.g. changing distributions of disease vectors). Through the importance we place on the aspects of life impacted by the redistribution of species around us, species-on-the-move offer emotional pathways to connect with people on the complex issue of climate change in profound ways that have the potential to engender interest and action on climate change. Read the free Plain Language Summary for this article on the Journal blog.
|
|
| 140. |
- Picha, Petr, et al.
(författare)
-
Process anti-pattern detection : a case study
- 2022
-
Ingår i: Proceedings of the 27th European Conference on Pattern Languages of Programs, EuroPLop 2022, Irsee, Germany, July 6-10, 2022. - New York, NY, USA : ACM Publications. - 9781450395946 ; , s. 1-18
-
Konferensbidrag (refereegranskat)abstract
- Anti-patterns are harmful phenomena repeatedly occurring, e.g., in software development projects. Though widely recognized and well-known, their descriptions are traditionally not fit for automated detection. The detection is usually performed by manual audits, or on business process models. Both options are time-, effort- and expertise-heavy, prone to biases, and/or omissions. Meanwhile, collaborative software projects produce much data as a natural side product, capturing their status and day-to-day history. Long-term, our research aims at deriving models for the automated detection of process and project management anti-patterns, applicable to project data. Here, we present a general approach for studies investigating occurrences of these types of anti-patterns in projects and discuss the entire process of such studies in detail, starting from the anti-pattern descriptions in literature. We demonstrate and verify our approach with the Fire Drill anti-pattern detection as a case study, applying it to data from 15 student projects. The results of our study suggest that reliable detection of at least some process and project management anti-patterns in project data is possible, with 13 projects assessed accurately for Fire Drill presence by our automated detection when compared to the ground truth gathered from independent data. The overall approach can be similarly applied to detecting patterns and other phenomena with manifestations in Application Lifecycle Management data.
|
|
