149 research outputs found
Clone Removal in Java Programs as a Process of Stepwise Unification
Cloned code is one of the most important obstacles against consistent
software maintenance and evolution. Although today's clone detection tools find
a variety of clones, they do not offer any advice how to remove such clones. We
explain the problems involved in finding a sequence of changes for clone
removal and suggest to view this problem as a process of stepwise unification
of the clone instances. Consequently the problem can be solved by backtracking
over the possible unification steps
How do Developers Improve Code Readability? An Empirical Study of Pull Requests
Readability models and tools have been proposed to measure the effort to read
code. However, these models are not completely able to capture the quality
improvements in code as perceived by developers. To investigate possible
features for new readability models and production-ready tools, we aim to
better understand the types of readability improvements performed by developers
when actually improving code readability, and identify discrepancies between
suggestions of automatic static tools and the actual improvements performed by
developers. We collected 370 code readability improvements from 284 Merged Pull
Requests (PRs) under 109 GitHub repositories and produce a catalog with 26
different types of code readability improvements, where in most of the
scenarios, the developers improved the code readability to be more intuitive,
modular, and less verbose. Surprisingly, SonarQube only detected 26 out of the
370 code readability improvements. This suggests that some of the catalog
produced has not yet been addressed by SonarQube rules, highlighting the
potential for improvement in Automatic static analysis tools (ASAT) code
readability rules as they are perceived by developers
Energy efficient software in an engineering course
Sustainable development has become an increasingly important theme not only in the world politics, but also an increasingly central theme for the engineering professions around the world. Software
engineers are no exception as shown in various recent research studies.
Despite the intensive research on green software, today’s undergraduate
computing education often fails to address our environmental responsibility. We present a module on energy efficient software that we introduced
as part of an advanced course on software analysis and testing. In this
module we study techniques and tools to analyze and optimize energy
consumption of software systems. Preliminary results of the first four instances of this course show that students are able to optimize the energy
consumption of software systems.ERDF European Regional Development Fund
through the Operational Programme for Competitiveness and Internationalisation - COMPETE 2020 Programme within project POCI-01-0145-FEDER006961, and by National Funds through the Portuguese funding agency, FCT -
Fundação para a Ciência e a Tecnologia within project POCI-01-0145-FEDER016718 and UID/EEA/50014/2013
Deuce: A Lightweight User Interface for Structured Editing
We present a structure-aware code editor, called Deuce, that is equipped with
direct manipulation capabilities for invoking automated program
transformations. Compared to traditional refactoring environments, Deuce
employs a direct manipulation interface that is tightly integrated within a
text-based editing workflow. In particular, Deuce draws (i) clickable widgets
atop the source code that allow the user to structurally select the
unstructured text for subexpressions and other relevant features, and (ii) a
lightweight, interactive menu of potential transformations based on the current
selections. We implement and evaluate our design with mostly standard
transformations in the context of a small functional programming language. A
controlled user study with 21 participants demonstrates that structural
selection is preferred to a more traditional text-selection interface and may
be faster overall once users gain experience with the tool. These results
accord with Deuce's aim to provide human-friendly structural interactions on
top of familiar text-based editing.Comment: ICSE 2018 Paper + Supplementary Appendice
Moving beyond Deletions: Program Simplification via Diverse Program Transformations
To reduce the complexity of software, Developers manually simplify program
(known as developer-induced program simplification in this paper) to reduce its
code size yet preserving its functionality but manual simplification is
time-consuming and error-prone. To reduce manual effort, rule-based approaches
(e.g., refactoring) and deletion-based approaches (e.g., delta debugging) can
be potentially applied to automate developer-induced program simplification.
However, as there is little study on how developers simplify programs in
Open-source Software (OSS) projects, it is unclear whether these approaches can
be effectively used for developer-induced program simplification. Hence, we
present the first study of developer-induced program simplification in OSS
projects, focusing on the types of program transformations used, the
motivations behind simplifications, and the set of program transformations
covered by existing refactoring types. Our study of 382 pull requests from 296
projects reveals that there exist gaps in applying existing approaches for
automating developer-induced program simplification. and outlines the criteria
for designing automatic program simplification techniques. Inspired by our
study and to reduce the manual effort in developer-induced program
simplification, we propose SimpT5, a tool that can automatically produce
simplified programs (semantically-equivalent programs with reduced source lines
of code). SimpT5 is trained based on our collected dataset of 92,485 simplified
programs with two heuristics: (1) simplified line localization that encodes
lines changed in simplified programs, and (2)checkers that measure the quality
of generated programs. Our evaluation shows that SimpT5 are more effective than
prior approaches in automating developer-induced program simplification
A heuristic-based approach to code-smell detection
Encapsulation and data hiding are central tenets of the object oriented paradigm. Deciding what data and behaviour to form into a class and where to draw the line between its public and private details can make the difference between a class that is an understandable, flexible and reusable abstraction and one which is not. This decision is a difficult one and may easily result in poor encapsulation which can then have serious implications for a number of system qualities. It is often hard to identify such encapsulation problems within large software systems until they cause a maintenance problem (which is usually too late) and attempting to perform such analysis manually can also be tedious and error prone. Two of the common encapsulation problems that can arise as a consequence of this decomposition process are data classes and god classes. Typically, these two problems occur together – data classes are lacking in functionality that has typically been sucked into an over-complicated and domineering god class. This paper describes the architecture of a tool which automatically detects data and god classes that has been developed as a plug-in for the Eclipse IDE. The technique has been evaluated in a controlled study on two large open source systems which compare the tool results to similar work by Marinescu, who employs a metrics-based approach to detecting such features. The study provides some valuable insights into the strengths and weaknesses of the two approache
Understanding the motivations, challenges, and practices of software rejuvenation
The continuous evolution of programming languages has brought benefits and new challenges for software developers. In recent years, we have witnessed a rapid release of new versions of mainstream programming languages like Java. While these advancements promise better security, enhanced performance, and increased developers’ productivity, the constant release of new language versions has posed a particular challenge for practitioners: how to keep their systems up-to-date with new language releases. This thesis aims to understand the pains, motivations, and practices developers follow during rejuvenating efforts—a particular kind of software maintenance whose goal is to avoid obsolesce due to the evolution of programming languages. To this end, we are building and validating a theory using a mixed methods study. In the first study, we interviewed 23 software developers and used the Constructivist Grounded Theory Method to identify recurrent challenges and practices used in rejuvenation efforts. In the second study, we mined the software repositories of open-source projects written in C++ and JavaScript to identify the adoption of new language features and whether or not software developers conduct large rejuvenation efforts. The first study highlights the benefits of new feature adoption and rejuvenation, revealing developer methods and challenges. The second study emphasizes open-source adoption trends and patterns for modern features. In the third and final study, our goal is to share our theory on software rejuvenation with practitioners through the Focus Group method with industrial patterns.(undefined
Code smells detection and visualization: A systematic literature review
Context: Code smells (CS) tend to compromise software quality and also demand
more effort by developers to maintain and evolve the application throughout its
life-cycle. They have long been catalogued with corresponding mitigating
solutions called refactoring operations. Objective: This SLR has a twofold
goal: the first is to identify the main code smells detection techniques and
tools discussed in the literature, and the second is to analyze to which extent
visual techniques have been applied to support the former. Method: Over 83
primary studies indexed in major scientific repositories were identified by our
search string in this SLR. Then, following existing best practices for
secondary studies, we applied inclusion/exclusion criteria to select the most
relevant works, extract their features and classify them. Results: We found
that the most commonly used approaches to code smells detection are
search-based (30.1%), and metric-based (24.1%). Most of the studies (83.1%) use
open-source software, with the Java language occupying the first position
(77.1%). In terms of code smells, God Class (51.8%), Feature Envy (33.7%), and
Long Method (26.5%) are the most covered ones. Machine learning techniques are
used in 35% of the studies. Around 80% of the studies only detect code smells,
without providing visualization techniques. In visualization-based approaches
several methods are used, such as: city metaphors, 3D visualization techniques.
Conclusions: We confirm that the detection of CS is a non trivial task, and
there is still a lot of work to be done in terms of: reducing the subjectivity
associated with the definition and detection of CS; increasing the diversity of
detected CS and of supported programming languages; constructing and sharing
oracles and datasets to facilitate the replication of CS detection and
visualization techniques validation experiments.Comment: submitted to ARC
- …