Eleni Constantinou

Towards Open Source Software System Architecture Recovery Using Design Metrics

Over the past years, software development practices include open source code reuse. Since documentation gives little or no information about the system architecture, a prohibitive amount of effort is required to comprehend the source code and the overall system architecture. In this paper, we investigate how design metrics can reveal architectural information about a software system and more specifically, how architectural layers are correlated to design metrics. Finally, we present an empirical study on two large open source systems written in Java, attempting to identify metrics revealing information about the system architecture.

Socio-technical evolution of the Ruby ecosystem in GitHub

The evolution dynamics of a software ecosystem depend on the activity of the developer community contributing to projects within it. Both social and technical changes affect an ecosystems evolution and the research community has been investigating the impact of these modifications over the last few years. Existing studies mainly focus on temporary modifications, often ignoring the effect of permanent changes on the software ecosystem. We present an empirical study of the magnitude and effect of permanent modifications in both the social and technical parts of a software ecosystem. More precisely, we measure permanent changes with regard to the ecosystems projects, contributors and source code files and present our findings concerning the effect of these modifications. We study the Ruby ecosystem in GitHub over a nine-year period by carrying out a socio-technical analysis of the co-evolution of a large number of base projects and their forks. This analysis involves both the source code developed for these projects as well as the developers having contributed to them. We discuss our findings with respect to the ecosystem evolution according to three different viewpoints: (1) the base projects, (2) the forks and (3) the entire ecosystem containing both the base projects and forks. Our findings show an increased growth in both the technical and social aspects of the Ruby ecosystem until early 2014, followed by an increased contributor and project abandonment rate. We show the effect of permanent modifications in the ecosystem evolution and provide preliminary evidence of contributors migrating to other ecosystems when leaving the Ruby ecosystem.

Layer assessment of object-oriented software

Highlights? We analyze using multiple linear regression nearly 22,000 classes of 29 Open Source Java systems. ? In our analysis Chidamber and Kemerer metrics were used as predictors of the layer of each class. ? Analysis resulted in a new metric, suitable for the white-box reuse of object-oriented software. ? The new metric is compared against three other proposed metrics and shows significant advantages. ? The metric is suitable for the white box reuse of classes, componentization and rearchitecting. Software reuse has the potential to shorten delivery times, improve quality and reduce development costs. However software reuse has been proven challenging for most organizations. The challenges involve both organizational and technical issues. In this work we concentrate on the technical issues and we propose a new metric facilitating the reuse of object-oriented software based on the popular Chidamber and Kemerer suite for object-oriented design. We derive this new metric using linear regression on a number of OSS java projects. We compare and contrast this new metric with three other metrics proposed in the literature. The purpose of the proposed metric is to assist a software developer during the development of a software system in achieving reusability of classes considered important for future reuse and also in providing assistance during re-architecting and componentization activities of existing systems.

Quantifying Reuse in OSS: A Large-Scale Empirical Study

Reuse is an established software development practice, whose benefits have attracted the attention of researchers and practitioners. In order for software reuse to advance from an opportunistic activity to a well-defined, systematic state of practice, the reuse phenomenon should be empirically studied in a real-world environment. To this end, OSS projects consist a fitting context for this purpose. In this paper, the authors aim at assessing the: a strategy and intensity of reuse activities in OSS development, beffect of reuse activities on design quality, c modification of reuse decisions from a chronological viewpoint and d effect of these modifications on software design quality. In order to achieve these goals, the authors performed a large-scale embedded multi-case study on 1,111 Java projects, extracted from Google Code repository. The results of the case study provide a valuable insight on reuse processes in OSS development, that can be exploited by both researchers and practitioners.

An empirical comparison of developer retention in the RubyGems and npm software ecosystems

Software ecosystems can be viewed as socio-technical networks consisting of technical components (software packages) and social components (communities of developers) that maintain the technical components. Ecosystems evolve over time through socio-technical changes that may greatly impact the ecosystem’s sustainability. Social changes like developer turnover may lead to technical degradation. This motivates the need to identify those factors leading to developer abandonment, in order to automate the process of identifying developers with high abandonment risk. This paper compares such factors for two software package ecosystems, RubyGems and npm. We analyse the evolution of their packages hosted on GitHub, considering development activity in terms of commits, and social interaction with other developers in terms of comments associated to commits, issues or pull requests. We analyse this socio-technical activity for more than 30 and 60k developers for RubyGems and npm, respectively. We use survival analysis to identify which factors coincide with a lower survival probability. Our results reveal that developers with a higher probability to abandon an ecosystem: do not engage in discussions with other developers; do not have strong social and technical activity intensity; communicate or commit less frequently; and do not participate to both technical and social activities for long periods of time. Such observations could be used to automate the identification of developers with a high probability of abandoning the ecosystem and, as such, reduce the risks associated to knowledge loss.

Landmark selection for spectral clustering based on Weighted PageRank

Abstract Spectral clustering methods have various real-world applications, such as face recognition, community detection, protein sequences clustering etc. Although spectral clustering methods can detect arbitrary shaped clusters, resulting thus in high clustering accuracy, the heavy computational cost limits their scalability. In this paper, we propose an accelerated spectral clustering method based on landmark selection. According to the Weighted PageRank algorithm, the most important nodes of the data affinity graph are selected as landmarks. Furthermore, the selected landmarks are provided to a landmark spectral clustering technique to achieve scalable and accurate clustering. In our experiments, by using two benchmark face and shape image data sets, we examine several landmark selection strategies for scalable spectral clustering that either ignore or consider the topological properties of the data in the affinity graph. Also, we show that the proposed method outperforms baseline and accelerated spectral clustering methods, in terms of computational cost and clustering accuracy, respectively. Finally, we provide future directions in spectral clustering.

Social and technical evolution of software ecosystems: a case study of rails

Software ecosystems evolve through an active community of developers who contribute to projects within the ecosystem. However, development teams change over time, suggesting a potential impact on the evolution of the technical parts of the ecosystem. The impact of such modifications has been studied by previous works, but only temporary changes have been investigated, while the long-term effect of permanent changes has yet to be explored. In this paper, we investigate the evolution of the ecosystem of Ruby on Rails in GitHub in terms of such temporary and permanent changes of the development team. We use three viewpoints of the Rails ecosystem evolution to discuss our preliminary findings: (1) the base project; (2) the forks; and (3) the entire ecosystem containing both base project and forks.

Architectural stability and evolution measurement for software reuse

Software reuse has been established as a development practice due to several benefits like development cost reduction. However, successful reuse depends on several factors, including high level attributes of the reused software. Architectural stability is an important factor for software reuse, either during the reusable asset selection or library upgrades. In this paper, we introduce two sets of metrics that measure the architectural stability and the evolution of software projects in the context of software reuse. The first set of architectural stability metrics measures the degree of consistency between consecutive versions of the same system and considers the common architectural elements. The second set of architectural evolution metrics quantifies the architectural evolution between consecutive versions of the same system and considers the newly introduced architectural elements, as well as how they interact with the remaining elements of the system. Finally, we present the application of the proposed metrics to two categories of software projects: (1) projects developed for reuse and (2) projects that were not originally intended for reuse.

Scalable Spectral Clustering with Weighted PageRank

In this paper, we propose an accelerated spectral clustering method, using a landmark selection strategy. According to the weighted PageRank algorithm, the most important nodes of the data affinity graph are selected as landmarks. The selected landmarks are provided to a landmark spectral clustering technique to achieve scalable and accurate clustering. In our experiments with two benchmark face and shape image data sets, we examine several landmark selection strategies for scalable spectral clustering that either ignore or consider the topological properties of the data in the affinity graph. Finally, we show that the proposed method outperforms baseline and accelerated spectral clustering methods, in terms of computational cost and clustering accuracy, respectively.

An Empirical Analysis of Technical Lag in npm Package Dependencies

Software library packages are constantly evolving and increasing in number. Not updating to the latest available release of dependent libraries may negatively affect software development by not benefiting from new functionality, vulnerability and bug fixes available in more recent versions. On the other hand, automatically updating to the latest release may introduce incompatibility issues. We introduce a technical lag metric for dependencies in package networks, in order to assess how outdated a software package is compared to the latest available releases of its dependencies. We empirically analyse the package update practices and technical lag for the npm distribution of JavaScript packages. Our results show a strong presence of technical lag caused by the specific use of dependency constraints, indicating a reluctance to update dependencies to avoid backward incompatible changes.