Conference Paper

Evolution of understandability in OSS projects

Dipt. di Autom. e Inf., Politecnico di Torino, Italy
DOI: 10.1109/CSMR.2004.1281406 Conference: Software Maintenance and Reengineering, 2004. CSMR 2004. Proceedings. Eighth European Conference on
Source: IEEE Xplore


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.

Download full-text


Available from: Andrea Capiluppi, Feb 02, 2014
  • Source
    • "A number of publications show the usefulness of refactoring for software development. Capiluppi et al. [3] found that understandability was increased by refactorings in several projects. Kataoka et al. [11] try to measure the maintainability enhancement effect of program refactorings based on coupling metrics. "
    [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
    • "In the specific field of libre software, there are some research works from the point of view of evolution: Burd et al. [1] evaluate the evolution of GCC, a compiler collection written mainly in C; Capiluppi, alone or with colleagues, has also authored several works about the evolution of libre software projects [3] and has proposed some models [2] (although those studies are focused on small to middle-sized projects). However, the most relevant study on the evolution of libre software projects is probably the one by Godfrey and Tu [9], who studied the Linux kernel in 2000. "
    [Show abstract] [Hide abstract]
    ABSTRACT: Software evolution research has recently focused on new development paradigms, studying whether laws found in more classic development environments also apply. Previous works have pointed out that at least some laws seem not to be valid for these new environments and even Lehman has labeled those (up to the moment few) cases as anomalies and has suggested that further research is needed to clarify this issue. In this line, we consider in this paper a large set of libre (free, open source) software systems featuring a large community of users and developers. In particular, we analyze a number of projects found in literature up to now, including the Linux kernel. For comparison, we include other libre software kernels from the BSD family, and for completeness we consider a wider range of libre software applications. In the case of Linux and the other operating system kernels we have studied growth patterns also at the subsystem level. We have observed in the studied sample that super-linearity occurs only exceptionally, that many of the systems follow a linear growth pattern and that smooth growth is not that common. These results differ from the ones found generally in classical software evolution studies. Other behaviors and patterns give also a hint that development in the libre software world could follow different laws than those known, at least in some cases.
    10/2005; DOI:10.1109/IWPSE.2005.17
  • Source
    • "However, most of the approaches developed so far, do not rely on an explicit meta model for evolution analysis and do not facilitate the comparison of different evolutions. Various approaches have been proposed to analyze different aspects of software evolution [1] [2] [3] [4] [8] [12] [13] [14] [17] [18] [19] [20] [21]. Each of these approaches typically focuses on only some traits of software evolution (e.g., which parts are changed the most, what kind of changes happened in a particular part etc.), and do not rely on explicit meta models. "
    [Show abstract] [Hide abstract]
    ABSTRACT: Understanding how software systems evolve is useful from different perspectives: reverse engineering, empirical studies etc.. For an effective understanding we need an explicit meta-model. We introduce Hismo, a meta-model which is centered around the notion of history and we show how we can obtain it from a snapshot meta-model. Based on our experience in developing the Hismo reverse engineering system, we show how we can transform a snapshot meta-model in a history meta-model.
    Electronic Notes in Theoretical Computer Science 09/2005; 137(3-137):57-64. DOI:10.1016/j.entcs.2005.07.005
Show more