Search

In the last years we have seen the rise and the fall of many version control systems. These systems collect a large amount of data spanning from the path of the files involved in changes to the exact text changed in every file. This data can be exploited to produce an overview about how the system changed over time and evolved. We have developed a tool, called VCS-Analyzer, to use this information, both for data retrieval and analysis tasks. Currently, VCS-Analyzer implements six different analysis: two based on source code for the computation of metrics and the detection of code smells, and four original analysis based on repositories metadata, which are based on the concepts of Repository Metrics and Code Repository Smells. In this paper, we describe one smell and two metrics we have defined for source code repository analysis.

Version Control Systems (VCSs) provide historical information that can be used to perform deep analyses on the evolution of a software project, with the aim of enhancing the quality of the system and predicting software evolution.

Previous research determined that the analysis of file changes in software repositories is useful for maintenance activities, like defect prediction. Changes rarely modify the entire file contents, but are usually localized in specific code regions.

We can retrieve and integrate knowledge of different kinds. In this paper, we focus our attention on FLOSS (Free, Libre and Open Source Software) projects. With this aim, we introduce RepoFinder, a web application we have developed for the discovery, retrieval and analysis of open source software. RepoFinder supports a keyword-based discovery process for FLOSS projects through google-like queries. Moreover, it allows to analyze the projects according to well-known software metrics and other features of the code, and to compare some structural aspects of the different projects. In the paper, we focus on the discovery capabilities of RepoFinder, evaluating them on different project categories and comparing them with a well-known search engine as Google

In this paper, an approach for information systems reverse engineering is proposed and applied. The aim is to support a unified perspective to the reverse engineering process of both data and software. At the state of the art, indeed, many methods, techniques, and tools for software reverse engineering have been proposed to support program comprehension, software maintenance, and software evolution. Other approaches and tools have been proposed for data reverse engineering, with the aim, for example, to provide complete and up-to-date documentation of legacy databases. However, the two engineering communities often worked independently, and very few approaches addressed the reverse engineering of both data and software as information system's constituencies. Hence, a higher integration is needed to support a better co-evolution of databases and programs, in an environment often characterized by high availability of data and volatility of information flows. Accordingly, the approach we propose leverages the detection of object-relational mapping design patterns to build a conceptual schema of the software under analysis. Then, the conceptual schema is mapped to the domain model of the system, to support the design of the evolution of the information system itself. The approach is evaluated on two large-scale open-source enterprise applications.

Developing software systems by reusing components is a common practice. FLOSS (Free, Libre and Open Source Software) components represent a significant part of the reusable components available. The selection of suitable FLOSS components raises important issues both for software companies and research institutions. RepoFinder supports a keyword- based discovery process for FLOSS components, and applies well-known software metrics and analyses to compare the structural aspects of different components.

Code duplication is considered a widespread code smell, a symptom of bad code development practices or potential design issues. Code smells are also considered to be indicators of poor software maintainability. The refactoring cost associated with removing code clones can be very high, partly because of the number of different decisions that must be made regarding the kind of refactoring steps to apply. Here, we describe a tool that has been developed to suggest the best refactoring steps that could be taken to remove clones in Java code. Our approach is based on the classification of clones, in terms of their location in a class hierarchy, so that decisions can be made from a restricted set of refactorings that have been evaluated using multiple criteria

There has been in the past years a widespread effort in the computer science community to extend the vast information existing on the Internet with “semantic structure” , in the form of ontologies and their associated inference systems, that can be exploited to support complex processes and services as can be carried out by dedicated software agents, as well as the structured querying of information as in database management systems. The Semantic Web [2] and its evolution into the Web of Data [3] represent the most noticeable contributions to this trend. At the core of these approaches there is the idea of replacing the simple Web publishing that has characterized the growth of the WWW since its inception with a more sophisticated form of publishing where, beside the normal content, ontologies and other semantic information is added as meta-content. The theoretical merits of this enterprise notwithstanding, its practical implementation still meets considerable hurdles as identified, for instance, by Halevy et al. [4] : namely, cost of ontology writing and maintenance, technical challenges of Semantic Web publishing, eventual unwillingness of the communities involved in the evolution of an ontology to cooperate to such an evolution, lack of resilience of standard inference systems in the coping with the possibility of mistaken premises and of incorrect data. Our purpose here is to fulfill the objective of a Web-based information space that becomes more usable and meaningful as a consequence of making explicit its underlying semantic structure, but we do so by reversing the direction taken by such frameworks as the Semantic Web and the Web of Data. Indeed, we stick to the general criterion, proposed and argued by Halevi et al. [4] , according to which semantic interpretation, based on techniques derived from artificial intelligence and statistical inference, is easy compared to the daunting task of semantic publishing. Thus, we make a kind of semantic structure dynami