The Open University s repository of research publications and other research outputs The Challenge of Software Complexity Conference Item
Given the interdisciplinary nature of complex network studies, there is a practical need for dialogue between theorists proposing graph measurements and those seeking to apply them into a domain. We consider this in the domain of software complexity by highlighting the distinctive nature of networks representing software's internal structure and also by describing the application of one such proposal, the offdiagonal complexity, against two examples of software. The results showed the promise of using complex networks to measure software complexity but also demonstrated the confounding effects of size. Based on that application we make proposals to improve the dialogue between theory and experiment. Software's importance and the need to measure complexity Today's society is heavily dependant on software. It runs our computers, our phones and the internet, while managing economies and communications. This pervasiveness means that any improvement in understanding software has a potentially enormous payback from better project management, control of costs and increased quality. Past practice of software development could be seen as a chimera of art form and engineering with success or failure in projects seemingly dependent on anecdotal wisdoms. While a comprehensive theoretical framework seems elusive, current and future practice has become increasingly evidence based and draws from a wide range of disciplines such as psychology, sociology, data mining and complexity theories. That software is complex is also largely self evident. Brooks (1987) (of "The Mythical Man Month" fame) argues that complexity is one of the fundamental essences associated with software. As such, understanding this inherent property would make great inroads into understanding software overall. While there are several viewpoints into software such as its cognitive, computational, problem or solution complexity (Cardoso et al. 2000) this paper focuses on the structural complexity of the code, arguing that it provides the most direct understanding of the product. Software as a complex network The variety of coding languages, styles and paradigms makes processing and quantifying code hard to generalise. One solution is to abstract the code into a network graph, with vertices representing a chosen unit of code and edges representing an arbitrary relationship between those units. By representing the interconnections between collaborating modules, objects, classes, methods, and subroutines with a network graph, software becomes another domain capable of investigation with the interdisciplinary toolset of complex networks. The basic technique is well established (Myers 2003; Valverde Sole 2003) and while more recent developments have for instance considered graphing the entire socio technical system (Bird et al. 2009) obtaining a measurement that represents the complexity of source code's basic structure and that can be connected to software development practice remains desirable.