Structural Epochs in Software

Structural Epochs in Software

Patrick A. Gray (Colorado Technical University, Colorado Springs, CO, USA), Bo Sandén (Colorado Technical University, Colorado Springs, CO, USA) and Phillip Laplante (Penn State, State College, PA, USA)
DOI: 10.4018/ijsita.2014040101
OnDemand PDF Download:
No Current Special Offers


A way to measure the complexity of object-oriented software involves topological features of the code's hierarchical organization at the method, class, package, and component levels. Sangwan et al (2008) suggested that as certain software products evolve, this complexity shifts from lower to higher structural levels, or vice-versa. They studied three widely used open source software programs and showed that these structural shifts called “epochs” were present and suspected that this phenomenon was pervasive. To support or refute this assertion, 30 open source programs were studied and structural shifts in complexity were found significantly in 27 of them. In those projects where no complexity shift was evident, no refactoring had occurred. These findings further suggest that in large, open source software projects, when refactoring occurs a shifting in complexity from one level to another will occur.
Article Preview

1. Introduction

Software complexity has been a subject of great interest since the work of Belady and Lehman (1976), McCabe (1976) and others. Belady and Lehman’s work led to “Lehman’s laws” of software evolution, which are largely informal observations about a software product’s tendency to become more complex, that is, more difficult to understand over time. McCabe’s cyclomatic complexity metric, which is a topological measure of code execution paths, or its close relative, weighted methods per class, is widely used in modern software metric tools such as SourceMonitor (2013) and in Structure 101 (2013).

More recently, Eick et al (2001) used multiple statistical methods and a rich data set to show that code decays over time. Informally they stipulate that code is “decayed if it is more difficult than it should be.” In their study, code decay is more precisely reflected in the cost of the change, the time to complete the change and the quality of the changed software.

In a pioneering survey, Bandi, Williams & Allen (2013) examined different ways in which code decay has been historically evaluated. 30 peer-reviewed articles studying code decay over time and over successive versions of the code were reviewed. The authors found that decay and architectural degeneration was measured in two principal ways – through developer observations, and semi-automatically using code analysis tools and metrics.

Human-based assessments of code decay include manual inspections of source code and related historical project artifacts. In one example study, a web-based questionnaire was used to gather input from developers in detecting “code smells” such as bloated classes and long method parameter lists. Semi-automated assessments of code decay include the use of generated software metrics. Various metrics having to do with coupling were most indicative of source code decay. It was verified that violating architectural and design rules leads to code decay. Other aspects of the measurement of code decay were explored such as historical data analysis. This includes an evaluation of change-management data and the history of defect fixes. Additionally, quality attributes of source code were considered including maintainability, understandability and extensibility. There are also developer and process attributes that lead to code decay including novice developers, developers simply focused on functionality, the violation of object-oriented principles, and the adverse effects of tight deliverable deadlines.

Izurieta, C., & Bieman, J. M. (2007) studied code decay in relationship to design patterns in the evolution of the JRefactory program over a four-year period. The design patterns selected were Visitor, State, and Singleton. Modular and organizational code decay was considered. Modular code decay principally includes increases in coupling. Organizational decay includes decay in relation to source code files, object-oriented classes, and namespaces. Some modular decay was found with the Visitor and Singleton patterns. As patterns evolve they break down in modularity. The Adapter pattern alone showed increases in organizational code decay.

Capiluppi & Beecher (2009) focused on software structural components in relation to code decay. They studied 50 projects each from the Debian and SourceForge repositories. The Debian repository has a greater barrier to entry. Repositories that have higher barriers to accessibility, such as Debian, contain code that is more evolvable and maintainable.

Larger source code projects require extra active measures to reduce complexity and decay. The integrity of software decreases as the software evolves. Structural complexity grows as evolutionary activity increases. Debian projects have greater functional coupling due to interconnectedness. Not surprisingly, the authors found that Debian received greater complexity control work than did projects in SourceForge.

Complete Article List

Search this Journal:
Open Access Articles: Forthcoming
Volume 10: 4 Issues (2019)
Volume 9: 4 Issues (2018)
Volume 8: 4 Issues (2017)
Volume 7: 4 Issues (2016)
Volume 6: 4 Issues (2015)
Volume 5: 4 Issues (2014)
Volume 4: 4 Issues (2013)
Volume 3: 4 Issues (2012)
Volume 2: 4 Issues (2011)
Volume 1: 4 Issues (2010)
View Complete Journal Contents Listing