Lajos Jeno Fulop

Towards a Benchmark for Evaluating Design Pattern Miner Tools

Recovering design pattern usage in source code is a very difficult task. Several tools are described in the literature for this purpose, but there is little work invested in evaluating them. The main reason for this is the lack of an approved benchmark for these tools. In this paper we present work in progress towards creating a benchmark, called DEEBEE (design pattern evaluation benchmark environment), for evaluating and comparing design pattern miner tools. It is programming language, tool, pattern and software independent, and it is open to the community and freely available. Currently, the benchmark database contains the results of three tools: Columbus (C++), Maisa (C++), and design pattern detection tool (Java). The tools were evaluated on reference implementations of patterns and on open source software (Mozilla, NotePad++, JHotDraw, JRefactory and JUnit). Additionally, instances recovered by researchers are added from NotePad++ as well. Some recovered patterns are already verified by experienced developers. This work is the first step in building a large reference database of design pattern usage in open source software and we expect that researchers will join us in this effort.

Evaluating C++ Design Pattern Miner Tools

Many articles and tools have been proposed over the years for mining design patterns from source code. These tools differ in several aspects, thus their fair comparison is hard. Besides the basic methodology, the main differences are that the tools operate on different representations of the subject system and that the pattern definitions differ as well. In this paper we first provide a common measurement platform for three well-known pattern mining systems, Columbus, Maisa and CrocoPat. Then we compare these tools on four C++ open-source systems: DC++,WinMerge, Jikes and Mozilla. Columbus can discover patterns from the C++ source code itself, while Maisa and CrocoPat require the representation of a software system in a special textual format, so we extended Columbus to provide the common input for the two other tools. We compared these tools in terms of speed, memory consumption and the differences between the hits. While the first two aspects showed comparable results, the recognition capabilities were quite diverse. This is probably due to the significant difference in how the patterns to be recognized and formalized by the tools. Therefore we conclude that a more precise and formal description of design patterns would be desirable.

Towards a Benchmark for Evaluating Reverse Engineering Tools

In this paper we present work in progress towards implementing a benchmark called BEFRIEND (benchmark for reverse engineering tools working on source code), with which the outputs of reverse engineering tools can be evaluated and compared easily and efficiently. Such tools are e.g. design pattern miners, duplicated code detectors and coding rule violation checkers. BEFRIEND supports different kinds of tool families, programming languages and software systems, and it enables the users to define their own evaluation criteria.

DPDX--Towards a Common Result Exchange Format for Design Pattern Detection Tools

Tools for design pattern detection (DPD) can ease program comprehension, helping programmers understand the design and intention of certain parts of a system’s implementation. Many tools have been proposed in the past. However, the many different output formats used by the tools make it difficult to compare their results and to improve their accuracy and performance through data fusion. In addition, all the output formats have been shown to have several limitations in both their forms and contents. Consequently, we develop DPDX, a rich common exchange format for DPD tools, to overcome previous limitations. DPDX provides the basis for an open federation of tools that perform comparison, fusion, visualisation, and–or validation of DPD results.

Software Quality Model and Framework with Applications in Industrial Context

Software Quality Assurance involves all stages of the software life cycle including development, operation and evolution as well. Low level measurements (product and process metrics) are used to predict and control higher level quality attributes. There exists a large body of proposed metrics, but their interpretation and the way of connecting them to actual quality management goals is still a challenge. In this work, we present our approach for modelling, collecting, storing and evaluating such software measurements, which can deal with all types of metrics collected at any stage of the life cycle. The approach is based on the Goal Question Metric paradigm, and its novelty lies in a unified representation of the metrics and the questions that evaluate them. It allows the definition of various complex questions involving different types of metrics, while the supporting framework enables the automatic collection of the metrics and the calculation of the answers to the questions. We demonstrate the applicability of the approach in three industrial case studies: two instances at local software companies with different quality assurance goals, and an application to a large open source system with a question related to testing and complexity, which demonstrates the complex use of different metrics to achieve a higher level quality goal.

FaultBuster: An automatic code smell refactoring toolset

One solution to prevent the quality erosion of a software product is to maintain its quality by continuous refac-toring. However, refactoring is not always easy. Developers need to identify the piece of code that should be improved and decide how to rewrite it. Furthermore, refactoring can also be risky; that is, the modified code needs to be re-tested, so developers can see if they broke something. Many IDEs offer a range of refactorings to support so-called automatic refactoring, but tools which are really able to automatically refactor code smells are still under research. In this paper we introduce FaultBuster, a refactoring toolset which is able to support automatic refactoring: identifying the problematic code parts via static code analysis, running automatic algorithms to fix selected code smells, and executing integrated testing tools. In the heart of the toolset lies a refactoring framework to control the analysis and the execution of automatic algorithms. FaultBuster provides IDE plugins to interact with developers via popular IDEs (Eclipse, Netbeans and IntelliJ IDEA). All the tools were developed and tested in a 2-year project with 6 software development companies where thousands of code smells were identified and fixed in 5 systems having altogether over 5 million lines of code.

Development of a Methodology, Software -- Suite and Service for Supporting Software Architecture Reconstruction

Having an up-to-date knowledge of the architecture of a software system is of primary importance, since it affects every aspect of software development. It aids under-standing the system, helps defining high level conditions and constraints for making decisions, supports dependency analysis, logical grouping of components, evaluation of high level design, etc. During the evolution of a software, the documentation of its architecture may not be maintained because of the strict deadlines, resulting in an increasing gap between the architectural design and implementation. The national grant project named GOP-1.1.1-07/1-2008-0077 sponsored by the New Hungarian Development Plan, supports the development of appropriate tools for automatic architecture reconstruction and reverse engineering of software systems. The project will result in a complex solution for automatic architecture reconstruction of software systems by offering both a flexible and highly customizable set of services and a state-of-the-art boxed product. On one hand, architecture reconstruction in the scope of the project deals with visualization of the components and their relations. On the other hand, tracking the changes of the architectural elements during software evolution will also be supported. The tools of the project are being developed by FrontEndART Ltd. while the theoretical and technological background is provided by the Department of Software Engineering at University of Szeged.

CIASYS--Change Impact Analysis at System Level

The research field of change impact analysis plays an important role in software engineering theory and practice nowadays. Not only because it has many scientific challenges, but it has many industrial applications too (e.g., cost estimation, test optimization), and the current techniques are still not ready to fulfill the requirements of industry. Typically, the current solutions lack a whole-system view and give either precise results with high computation costs or less precise results with fast algorithms. For these reasons, they are not applicable to large industrial systems where both scalability and precision are very important. In this paper, we present a project whose main goal is to develop an innovative change impact analysis software-suit based on recent scientific results and modern technologies. The suite will use hybrid analysis techniques to benefit from all the advantages of static and dynamic analyses. In addition, it will be able to determine the dependencies at system level of software systems with heterogeneous architecture. The software is being developed by FrontEndART Ltd. while the theoretical and technological background is provided by the Department of Software Engineering at the University of Szeged. The project is funded by the Economic Development Operational Programme, New Hungary Development Plan.

ELI-ALPS Control System Status Report

ELI-ALPS will provide a wide range of attosecond pulses which will be used for performing chemical, biological, physical or medical experiments by international research groups. It is one pillar of the first international laser facility for the scientific user communities. ELI-ALPS use the TANGO Controls framework to build up the central control system and to integrate the autonomous subsystems regarding monitoring and control. It will be also used for the implementation of some autonomous systems’ control system while others will be implemented differently. The central control system and the integration strategy of the autonomous systems is designed. The centralization and integration needs are surveyed and the requirements are collected. Prototypes have been developed to clarify the requirements and to test the designs. Requirements elicitation, designing and prototype development follows a Lean-Agile approach and includes several fields: device drivers and simulators; integration logic; central supervision, archiving, logging and error recovery; graphical user interfaces and so on.