Modern software engineering is a highly social activity, which is in contrast aimed at producing technical artifacts. As a result, complex dependencies between the technical elements of software systems and the social structures of the developers that are tasked with their creation have a direct effect on software quality: in projects that exhibit a high degree of congruence between the design of a software system and the social communication structures of its developers, teams are more productive and systems contain fewer faults. This research project aims to create the necessary tool support so that software engineers can be made keenly aware of these socio-technical dependencies within the familiar context of their everyday development activities. By providing this information in this specific context ? at a time when it is useful and actionable ? the broader impacts of this research have the potential to dramatically transform software engineering habits and practices by bringing into sharper focus the existing and emerging socio-technical trends of a development effort, allowing developers to intervene when they diverge, and ultimately improving the quality of the software systems produced.
To achieve these objectives, this research project is grounded on the creation of an architecture-centric toolset that supports the analysis of social network patterns, designed to be an addition to the popular Eclipse development environment. This toolset will support continuous awareness of emerging socio-technical dependencies by collecting data and providing a host of displays that allow developers to visualize their project?s software architecture, dependencies between source code units, and the social network formed through analysis of developer communications. Key contributions and advances of this work include the novel integration of social aspects of development with the architecture of software systems, the provision of concrete socio-architectural congruence metrics, and the presentation of this information to developers during ongoing development efforts.
Software engineering is a highly social activity with the end goal of producing technical artifacts, such as running software systems and accompanying documentation. As a result, the activity exhibits a complex interplay of technical and social concerns that are closely dependent on one another. One of the most important of these is the interplay between software architecture and the social structures of the developers charged with creating software systems. The focus of this software engineering research grant is an investigation of the methods and research challenges in better integrating insights from the study of socio-architectural dependencies into software engineering practice in a way that is useful during ongoing development efforts. The architectural design of a software system captures the system’s decomposition into modules and the interface contracts that govern their interactions, which makes it play a key role in determining the communication needs of the developers assigned to the project. This influence, however, is not one-way: architectures are also affected by the existing organizational and communication structure of developers who are assigned to specific work tasks: The divisions between teams, the distribution of technical expertise, the co-location or distribution of developers, and the communication practices of developers are just a few examples of factors that may influence architectural design. Given this interplay between architectural design and organizational structure, a key factor in the software engineering of successful systems is the degree of congruence or match between the design of a system and the communicative behaviors of its developers. The research area of socio-technical analysis (STA) has grown around the study of these dependencies between technical and social artifacts: Interesting results from this research show that a high degree of match between the technical dependencies among artifacts and the actual communication patterns exhibited by the team result in higher quality software and faster development times, which ultimately results in better software systems that are less costly. Applying these insights in an ongoing software development process, however, is very challenging: In modern development settings, architectures evolve rapidly and often drift away from their original form. As a result, it is unlikely that a high degree of congruence between communication patterns and architectural design will be maintained, even if the original design was carefully crafted to exhibit it. Current STA research has also been largely centered on data collected from already complete development efforts that are of little value to the software development process itself. Further exacerbating this is the fact that the analytical focus has been heavily placed at the level of source code files, which does not focus on the cross-boundary design artifacts that are most critical in understanding the communication needs of a development effort and limits how well these analyses scale. This project focused on providing the means with which to leverage insights from socio-technical dependencies in ongoing development efforts. Our Architecture-centric Social Network Awareness Environment (ArSoNAE) toolset (built in the Eclipse development environment) provides software developers with functionality that provides continuous awareness and supports in-depth exploration of a software system’s socio-architectural dependencies: the couplings between a system’s architectural design and developer communication patterns. This project laid the groundwork for transitioning the research community’s increased understanding of the complex dependencies between the social and technical artifacts of software engineering into the everyday work of software engineers, while also answering research questions concerning the integration of social insights into architectural designs. As our project addressed software engineering practice, broader impacts extend widely to all domains for which software is developed – particularly those that involve multi-team, distributed development settings. This work has the potential to drastically transform the way software developers work by bringing their communication habits and practices into sharper focus. Our work also tightly integrated education in our research activities through the inclusion of graduate students as well as the significant involvement of undergraduate students.
