Search

Code smell detection is one of the essential tasks in the field of software engineering. Identifying whether a code snippet has a code smell is subjective and varies by programming language, developer, and development method. Moreover, developers tend to focus on code smells that have a real impact on development and ignore insignificant ones. However, existing static code analysis tools and code smell detection approaches exhibit a high false positive rate in detecting code smells, which makes insignificant smells drown out those smells that developers value. Therefore, accurately reporting those actionable code smells that developers tend to spend energy on refactoring can prevent developers from getting lost in the sea of smells and improve refactoring efficiency. In this paper, we aim to detect actionable code smells that developers tend to refactor. Specifically, we first collect actionable and non-actionable code smells from projects with numerous historical versions to construct our datasets. Then, we propose a dual-stream model for fusion learning of code metrics and code semantics to detect actionable code smells. On the one hand, code metrics quantify the code's structure and even some rules or patterns, providing fundamental information for detecting code smells. On the other hand, code semantics encompass information about developers' refactoring tendencies, which prove valuable in detecting actionable code smells. Extensive experiments show that our approach can detect actionable code smells more accurately compared to existing approaches. • We provide a method to collect actionable code smells automatically. • We propose a dual-stream model for detecting and identifying actionable code smells. • We comprehensively evaluate our approach on the publicly available and collected datasets. • We provide several valuable suggestions for practitioners and a benchmark for identifying actionable code smells. [ABSTRACT FROM AUTHOR]

Software Product Lines (SPLs) constitute a popular method for encouraging the methodical reuse of software artefacts. Just like any other piece of software, SPLs require management throughout their evolution, namely to preserve the consistency between requirements and the code. Over time, for a given SPL, many change requests are made and all of them need to be integrated in a consistent and coordinated way. The evolution of an SPL is facilitated if there exist links between its artefacts, namely between each feature and its respective pieces of implementation code. This paper proposes FMap, a systematic feature mapping approach to be used within SPLs. FMap traces a Feature Model (FM) to other artefacts of an SPL, the reference architecture, and the code, and it establishes connections between each feature of the FM and its locations in the code-base. Additionally, we have created a tool called friendlyMapper to provide some automatic support for the approach. Using two case studies from two different companies, FMap and friendlyMapper are evaluated. The evaluation of the case studies indicates that the FMap approach outperforms the baseline approach (i.e., the branching approach). This work contributes with FMap, a novel tool-based approach that supports feature-architecture-code mappings based on reference architecture. FMap assists software engineers in adapting the evolution of the SPLs to accommodate new features and change requests as the SPLs evolve. The case studies for both companies demonstrate that the approach is applicable to real-world products and is able to support feature traceability and maintain consistency among features, architecture, and code. [ABSTRACT FROM AUTHOR]

We report on our success stories in developing and using Model-Driven Engineering (MDE) tools for information systems on real-world projects within different application domains. It is necessary that we ensure the extensibility and adaptability of code generators if we want to reuse them for different domains. Up to now, research on reusing software has been mainly conducted in the software product line community but rarely discussed in the context of code generators. This paper introduces the generation framework MontiGem and shows how it has been used and evolved within five different research and industry projects in the domains of financial management, IoT, energy management, privacy policy, and wind turbine engineering. We have developed the code generator within the first project and further refined it with each of the following projects. This paper describes the projects, shows how MDE helped us in the software engineering process, and discusses the lessons we learned. These examples show how MDE techniques can be successfully applied to the development of information systems in practice, although further requirements have been met over time. [ABSTRACT FROM AUTHOR]

Accessible design focuses on enabling as many people as possible to access software products and services, which has drawn extensive attention from software engineering researchers and developers. Currently, developers are improving the accessibility of software in a simple way, and researchers are putting much effort into investigating the characteristics of accessibility issues. No studies have explored the interaction of accessibility with other factors that affect software performance, although some researchers have found that these accessibility problems interact with other quality attributes (e.g., functionality , efficiency , and security) when they categorize accessibility issues. To fill this gap, we conducted the first comprehensive study to characterize symptoms, the violated standard, causes, and solutions for the accessibility issues along with quality attributes of software with 4,572 accessibility issues collected from GitHub. Specifically, we first investigated the symptoms of the interaction between the accessibility issues and software quality attributes. Second, we manually assessed accessibility issues where the interaction occurs to determine the violated standards. We then analyzed the causes of these interaction problems. Finally, we explored the commits that fix these accessibility issues along with quality attributes to find solutions. Our results indicate that: i) usability and functionality are the quality attributes that most frequently interact with accessibility, appearing more than 66% of the time; ii) 87% of the interaction issues violated Perceivable and Operable in the Web Content Accessibility Guidelines; iii) the main reason for these interaction problems is that UI Component Related (UCR) and Contrast Related (CR) issues show up more than 52% of the time. • Study the relationship between accessibility and attributes. • Summary how developers address accessibility problems. • Create a reliable dataset. [ABSTRACT FROM AUTHOR]

Semantic processing of conceptual models is a focus of research for several years, bridging the disciplines of knowledge-based systems, conceptual modeling, and model-driven software engineering. With Knowledge Graphs, this research area gained momentum. In this paper, we introduce CM2KGcloud, a generic and extensible Web-based platform for transforming conceptual models into Knowledge Graphs. The platform can work on models created by state-of-the-art metamodeling platforms (e.g., EMF, Papyrus, ADOxx) and transforms models created with them into standardized Knowledge Graph representations like GraphML, RDF, and OWL. CM2KGcloud can be used as a service and can be integrated into software systems by its exposed API. • We introduce CM2KGcloud, a cloud platform for transforming conceptual models into Knowledge Graphs. • CM2KGcloud can process models created with ADOxx, EMF, and Papyrus-based modeling tools. • CM2KGcloud comes with pre-defined queries that are able to detect models smells. • Query results are graphically superimposed to the transformed Knowledge Graph. • The software is available at http://me.big.tuwien.ac.at/cm2kg. [ABSTRACT FROM AUTHOR]