Detecting Coordination Problems in Collaborative Software Development Environments

Software development is rarely an individual effort and generally involves teams of developers collaborating to generate good reliable code. Among the software code there exist technical dependencies that arise from software components using services from other components. The different ways of assigning the design, development, and testing of these software modules to people can cause various coordination problems among them. We claim\ud that the collaboration of the developers, designers and testers must be related to and governed by the technical task structure. These collaboration practices are handled in what we call Socio-Technical Patterns.\ud The TESNA project (Technical Social Network Analysis) we report on in this paper addresses this issue. We propose a method and a tool that a project manager can use in order to detect the socio-technical coordination problems. We test the method and tool in a case study of a small and innovative software product company

Mapping Social Network to Software Architecture to Detect Structure Clashes in Agile Software Development

Software development is rarely an individual effort and generally involves teams of developers collaborating together in order to generate reliable code. Such collaborations require proper communication and regular coordination among the team members. In addition, coordination is required to sort out problems due to technical dependencies that exist when components of one part of the architecture requires services or data input from components of another part of the architecture. The dynamic allocation of the different tasks to people results in various socio-technical structure clashes (STSCs). These STSCs become more pronounced in an Agile Software Development environment and managerial intervention is constantly required to alleviate problems due to STSCs. In this paper we provide a method to detect these STSCs in a longitudinal fashion with the help of a tool that we are developing. We test this method in a case study of a software company and show how such structure clashes can be detected by analyzing the social network (along with the betweenness centrality index) in relation to the task dependencies due to the software architec

Matrix based problem detection in the application of software process patterns

Software development is rarely an individual effort and generally involves teams of developers. Such col- laborations require proper communication and regular coordination among the team members. In addition, coordination is required to sort out problems due to technical dependencies that exist when components of one part of the architecture requires services or data input from components of another part of the architecture. The dynamic allocation of the different tasks to people results in various socio-technical structure clashes (STSCs). These STSCs become more pronounced in an Agile Software Development environment and managerial intervention is constantly required to alleviate problems due to STSCs. In this paper we propose a technique based on dependency matrices that detects STSCs in the organizational process structure. We illustrate this technique using two examples from Organizational and Process Pattern literature

TESNA: A Tool for Detecting Coordination Problems

Detecting problems in coordination can prove to be very difficult. This is especially true in large globally distributed environments where the Software Development can quickly go out of the Project Manager’s control. In this paper we outline a methodology to analyse the socio-technical coordination structures. We also show how this can be made easier with the help of a tool called TESNA that we have developed

Exploring the Impact of Socio-Technical Core-Periphery Structures in Open Source Software Development

In this paper we apply the social network concept of core-periphery structure to the sociotechnical structure of a software development team. We propose a socio-technical pattern that can be used to locate emerging coordination problems in Open Source projects. With the help of our tool and method called TESNA, we demonstrate a method to monitor the socio-technical core-periphery movement in Open Source projects. We then study the impact of different core-periphery movements on Open Source projects. We conclude that a steady core-periphery shift towards the core is beneficial to the project, whereas shifts away from the core are clearly not good. Furthermore, oscillatory shifts towards and away from the core can be considered as an indication of the instability of the project. Such an analysis can provide developers with a good insight into the health of an Open Source project. Researchers can gain from the pattern theory, and from the method we use to study the core-periphery movements

Automatic annotation of the Penn-treebank with LFG f-structure information

Lexical-Functional Grammar f-structures are abstract syntactic representations approximating basic predicate-argument structure. Treebanks annotated with f-structure information are required as training resources for stochastic versions of unification and constraint-based grammars and for the automatic extraction of such resources. In a number of papers (Frank, 2000; Sadler, van Genabith and Way, 2000) have developed methods for automatically annotating treebank resources with f-structure information. However, to date, these methods have only been applied to treebank fragments of the order of a few hundred trees. In the present paper we present a new method that scales and has been applied to a complete treebank, in our case the WSJ section of Penn-II (Marcus et al, 1994), with more than 1,000,000 words in about 50,000 sentences

Generation of file processing programs based on JSP

This paper describes the generation of file processing programmes within the TUBA environment. Program structures are derived from data structures according to the JSP method. Expressions describing output data are specified in user-system dialogues. The program specifications are stored in the dictionary. Complete executable programs can be generated from these specifications

On the Conversion of Program Specifications into Pseudo Code using Jackson Structured Programming

In this paper, we present a technique to automatically translate program specifications into pseudo code. This technique is developed in the context of the well-known programming method Jackson Structured Programming (JSP). The objective of our research is to investigate to what extent a programming method can be automated. Current CASE tools are only able to automate programming methods to a very limited extent, whereas our technique automates the entire programming cycle by creating pseudo code from program specifications. We show that the JSP programming method can be transformed into a set of formal rules when the scope of the technique is limited to a well-defined area of problems. The rules are implemented in a CASE tool, called JSPTool, which is currently operative, although still in a prototyping phase. We believe that the strength of the CASE tool lies in the fact that it is able to automate the programming process completely, although its scope possibly is still rather limited. In this paper, the technique is explained by solving an example programming problem. The source language that has been developed to enter program specifications is briefly explained. Also, the differences between other JSP CASE tools and JSPTool are dealt with. Some additional features of the method are discussed and suggestions for future research are given