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

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.

Download full-text

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.
    Preview · Conference Paper · Oct 2007
  • Source
    • "In [2] , Burd et al. have evaluated the evolution of the GCC compiler and found interesting results. Capiluppi et al. have also authored several works on the evolution of open source software projects [4] and have proposed some models [3] working with mid-size projects. Succi et al. [17] also observed super-linearity in the evolution of the Linux kernel, but found linear growth for both GCC and Apache. "
    [Show abstract] [Hide abstract]
    ABSTRACT: For real-world software to remain satisfactory to its stake- holders requires its continual enhancement and adaptation. Acceptance of this phenomenon, termed software evolution, as intrinsic to real world software has led to an increasing interest in disciplined and systematic planning, management and improvement of the evolution process. Al- most all of the previous work on software evolution has been concerned with the evolution of large scale real-world software systems developed within a single company using traditional management techniques, or with the large scale open source software systems (LSOSSS). However, there is to our knowledge little or no work that has considered small scale open source software systems (SSOSSS). This paper presents an analysis of the evolution behavior of two small size open source software systems, the Barcode Library and Zlib. Surprisingly, unlike large scale open source software systems, the evolution behavior of these small size open source software systems appears to follow Lehman's laws for software evolution.
    Full-text · Article · Jan 2006
  • 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.
    Full-text · Article · Oct 2005
Show more