139 research outputs found
Search based software engineering: Trends, techniques and applications
© ACM, 2012. This is the author's version of the work. It is posted here by permission of ACM for your personal use. Not for redistribution. The definitive version is available from the link below.In the past five years there has been a dramatic increase in work on Search-Based Software Engineering (SBSE), an approach to Software Engineering (SE) in which Search-Based Optimization (SBO) algorithms are used to address problems in SE. SBSE has been applied to problems throughout the SE lifecycle, from requirements and project planning to maintenance and reengineering. The approach is attractive because it offers a suite of adaptive automated and semiautomated solutions in situations typified by large complex problem spaces with multiple competing and conflicting objectives.
This article provides a review and classification of literature on SBSE. The work identifies research trends and relationships between the techniques applied and the applications to which they have been applied and highlights gaps in the literature and avenues for further research.EPSRC and E
4D Ariadne the Static Debugger of Java Programs
Development environments support the programmer in numerous ways from syntax highlighting to different refactoring and code generating methods. However, there are cases where these tools are limited or not usable, such as getting familiar with large and complex source codes written by a third person; finding the complexities of huge projects or finding semantic errors.In this paper we present our static analyzer tool, called 4D Ariadne, which concentrates on these problems. 4D Ariadne is a static debugger of Object Oriented applications written in Java programming language. It calculates data dependencies of objects being able to compute them both forward and backward. As 4D Ariadne provides only the direct influences to the user, it can be considered as an alternative of traditional debuggers, without executing the code. 4D Ariadne also provides dynamic call graphs representing polymorphic properties of objects
Getting Things Done: The Eelco Way
Eelco Visser (1966-2022) was a leading member of the department of Software Technology (ST) of the faculty of Electrical Engineering Mathematics, and Computer Science (EEMCS) of Delft University of Technology. He had a profound influence on the educational programs in computer science at TU Delft, built a highly successful Programming Languages Group from the ground up, and used his research results to develop widely used tools and services that have been used by thousands of students and researchers for more than a decade. He realized all these successes not just alone, but in close collaboration with a range of people, who he convinced to follow his lead. In this short reflection, I look back at his achievements, and at the way in which he worked with others to bring ambitious ideas to successful reality
How Clones are Maintained: An Empirical Study
Despite the conventional wisdom concerning the risks related to the use of source code cloning as a software development strategy, several studies appeared in literature indicated that this is not true. In most cases clones are properly maintained and, when this does not happen, is because cloned code evolves independently. Stemming from previous works, this paper combines clone detection and co–change analysis to investigate how clones are maintained when an evolution activity or a bug fixing impact a source code fragment belonging to a clone class. The two case studies reported confirm that, either for bug fixing or for evolution purposes, most of the cloned code is consistently maintained during the same co–change or during temporally close co–changes
Trustworthy Refactoring via Decomposition and Schemes: A Complex Case Study
Widely used complex code refactoring tools lack a solid reasoning about the
correctness of the transformations they implement, whilst interest in proven
correct refactoring is ever increasing as only formal verification can provide
true confidence in applying tool-automated refactoring to industrial-scale
code. By using our strategic rewriting based refactoring specification
language, we present the decomposition of a complex transformation into smaller
steps that can be expressed as instances of refactoring schemes, then we
demonstrate the semi-automatic formal verification of the components based on a
theoretical understanding of the semantics of the programming language. The
extensible and verifiable refactoring definitions can be executed in our
interpreter built on top of a static analyser framework.Comment: In Proceedings VPT 2017, arXiv:1708.0688
Contemporary Approach for Technical Reckoning Code Smells Detection using Textual Analysis
Software Designers should be aware of address design smells that can evident as results of design and decision. In a software project, technical debt needs to be repaid habitually to avoid its accretion. Large technical debt significantly degrades the quality of the software system and affects the productivity of the development team. In tremendous cases, when the accumulated technical reckoning becomes so enormous that it cannot be paid off to any further extent the product has to be abandoned. In this paper, we bridge the gap analyzing to what coverage abstract information, extracted using textual analysis techniques, can be used to identify smells in source code. The proposed textual-based move toward for detecting smells in source code, fabricated as TACO (Textual Analysis for Code smell detection), has been instantiated for detecting the long parameter list smell and has been evaluated on three sampling Java open source projects. The results determined that TACO is able to indentified between 50% and 77% of the smell instances with a exactitude ranging between 63% and 67%. In addition, the results show that TACO identifies smells that are not recognized by approaches based on exclusively structural information
Un formalisme pour la traçabilité des transformations
Dans le développement logiciel en industrie, les documents de
spécification jouent un rôle important pour la communication entre les analystes
et les développeurs. Cependant, avec le temps, les changements de personel et
les échéances toujours plus courtes, ces documents sont souvent obsolètes ou
incohérents avec l'état effectif du système, i.e., son code
source. Pourtant, il est nécessaire que les composants du système logiciel
soient conservés à jour et cohérents avec leurs documents de spécifications pour
faciliter leur développement et maintenance et, ainsi, pour en réduire les
coûts. Maintenir la cohérence entre spécification et code source nécessite de
pouvoir représenter les changements sur les uns et les autres et de pouvoir
appliquer ces changements de manière cohérente et automatique.
Nous proposons une solution permettant de décrire une représentation d'un
logiciel ainsi qu'un formalisme mathématique permettant de décrire et de
manipuler l'évolution des composants de ces représentations. Le formalisme est
basé sur les triplets de Hoare pour représenter les transformations et sur la
théorie des groupes et des homomorphismes de groupes pour manipuler ces
transformations et permettrent leur application sur les différentes
représentations du système.
Nous illustrons notre formalisme sur deux représentations d'un système logiciel
: PADL, une représentation architecturale de haut niveau (semblable à UML), et
JCT, un arbre de syntaxe abstrait basé sur Java. Nous définissons également des
transformations représentant l'évolution de ces représentations et la
transposition permettant de reporter les transformations d'une représentation
sur l'autre. Enfin, nous avons développé et décrivons brièvement une
implémentation de notre illustration, un plugiciel pour l'IDE Eclipse détectant
les transformations effectuées sur le code par les développeurs et un générateur
de code pour l'intégration de nouvelles représentations dans l'implémentation.When developing software system in industry, system specifications are heavily
used in communication among analysts and developers. However, system evolution,
employee turn-over and shorter deadlines lead those documents either not to be
up-to-date or not to be consistent with the actual system source code. Yet,
having up-to-date documents would greatly help analysts and developers and
reduce development and maintenance costs. Therefore, we need to keep those
documents up-to-date and consistent.
We propose a novel mathematical formalism to describe and manipulate the
evolution of these documents. The mathematical formalism is based on Hoare
triple to represent the transformations and group theory and groups
homomorphisms to manipulate these transformations and apply them on different
representations.
We illustrate our formalism using two representation of a same system: PADL,
that is an abstract design specification (similar to UML), and JCT, that is an
Abstract Syntax Tree for Java. We also define transformations describing their
evolutions, and transformations transposition from one representation to
another. Finally, we provide an implementation of our illustration, a plugin for
the Eclipse IDE detecting source code transformations made by a developer and a
source code generator for integrating new representations in the implementation
Using Program Slicing to Identify Faults in Software
This study explores the relationship between program slices and faults. The aim is to investigate whether the characteristics of program slices can be used to identify fault-prone software components. Slicing metrics and dependence clusters are used to characterise the slicing profile of a software component, then the relationship between the slicing profile of the component and the faults in that component are then analysed. Faults can increase the likelihood of a system becoming unstable causing problems for the development and evolution of the system. Identifying faultprone components is difficult and reliable predictors of faultproneness not easily identifiable. Program slicing is an established software engineering technique for the detection and correction of specific faults. An investigation is carried out into whether the use of program slicing can be extended as a reliable tool to predict fault-prone software components. Preliminary results are promising suggesting that slicing may offer valuable insights into fault-proneness
- …