Conference Proceeding

Evolution of understandability in OSS projects

Dipt. di Autom. e Inf., Politecnico di Torino, Italy
Proceedings of the Euromicro Conference on Software Maintenance and Reengineering, CSMR 04/2004; DOI:10.1109/CSMR.2004.1281406 ISBN: 0-7695-2107-X pp.58 - 66 In proceeding of: Software Maintenance and Reengineering, 2004. CSMR 2004. Proceedings. Eighth European Conference on
Source: IEEE Xplore

ABSTRACT Empirical papers on open source software should try and formulate reasons for successes as Linux, Apache and some other flagship projects. What we need to understand about this topic is on the process of producing software through cooperation of different efforts. Albeit many success reasons for these projects are inherently due to the application domain that the project develops, architectural and conceptual views of the code have to be considered as key factors when considering community efforts and joint decisions. We focus our attention on what is perceived of a source code when investigating its structure. We do this considering that structure as a proxy for the conceptual architecture of the application. A metric is developed based on some current assumptions, and it is tested over a sample of open source projects. What is interesting to note, is that refactoring efforts are clearly visible when intended as reduction of complexity of source code. Our second observation is that, based on what an open source software currently does, i.e. its application domain, there's a threshold value that several projects tend to.

0 0
 · 
0 Bookmarks
 · 
18 Views
  • Source
    Conference Proceeding: Mining Software Evolution to Predict Refactoring
    J. Ratzinger, T. Sigmund, P. Vorburger, H. Gall
    [show abstract] [hide abstract]
    ABSTRACT: Can we predict locations of future refactoring based on the development history? In an empirical study of open source projects we found that attributes of software evolution data can be used to predict the need for refactoring in the following two months of development. Information systems utilized in software projects provide a broad range of data for decision support. Versioning systems log each activity during the development, which we use to extract data mining features such as growth measures, relationships between classes, the number of authors working on a particular piece of code, etc. We use this information as input into classification algorithms to create prediction models for future refactoring activities. Different state-of-the-art classifiers are investigated such as decision trees, logistic model trees, prepositional rule learners, and nearest neighbor algorithms. With both high precision and high recall we can assess the refactoring proneness of object-oriented systems. Although we investigate different domains, we discovered critical factors within the development life cycle leading to refactoring, which are common among all studied projects.
    Empirical Software Engineering and Measurement, 2007. ESEM 2007. First International Symposium on; 10/2007
  • Source
    Article: Modeling history to analyze software evolution.
    Tudor Gîrba, Stéphane Ducasse
    Journal of Software Maintenance. 01/2006; 18:207-236.
  • Source
    Conference Proceeding: The Inevitable Stability of Software Change.
    Rajesh Vasa, Jean-Guy Schneider, Oscar Nierstrasz
    [show abstract] [hide abstract]
    ABSTRACT: Real software systems change and become more complex over time. But which parts change and which parts remain stable? Common wisdom, for example, states that in a well-designed object-oriented system, the more popular a class is, the less likely it is to change from one version to the next, since changes to this class are likely to impact its clients. We have studied consecutive releases of several public domain, object-oriented software systems and analyzed a number of measures indicative of size, popularity, and complexity of classes and interfaces. As it turns out, the distributions of these measures are remarkably stable as an application evolves. The distribution of class size and complexity retains its shape over time. Relatively little code is modified over time. Classes that tend to be modified, however, are also the more popular ones, that is, those with greater Fan-In. In general, the more "complex" a class or interface becomes, the more likely it is to change from one version to the next.
    23rd IEEE International Conference on Software Maintenance (ICSM 2007), October 2-5, 2007, Paris, France; 01/2007
Data provided are for informational purposes only. Although carefully collected, accuracy cannot be guaranteed. The impact factor represents a rough estimation of the journal's impact factor and does not reflect the actual current impact factor. Publisher conditions are provided by RoMEO. Differing provisions from the publisher's actual policy or licence agreement may be applicable.

Keywords

application domain
 
community efforts
 
conceptual architecture
 
conceptual views
 
current assumptions
 
different efforts
 
Empirical papers
 
flagship projects
 
interesting
 
joint decisions
 
key factors
 
Linux
 
open source projects
 
open source software
 
refactoring efforts
 
second observation
 
source code
 
success reasons
 
successes
 
threshold value