Dependencies among Software Development Teams. Coordination, Communication and Collaboration

Table of contents

List of figures

List of abbreviations

1 Introduction
1.1 Motivation
1.2 Goal of the paper
1.3 Structure of the paper

2 Research methodology

3 Software dependencies resulting in team dependencies
3.1 Software dependencies
3.2 Coordination among software development teams
3.3 Communication and collaboration among software development teams

4 Software development teams dependencies model

5 Conclusion

Bibliography

Appendix

List of figures

Figure 1: What are dependencies based on (Duda & Keramane, 1995)

Figure 2: Organizational boundaries based on (Nguyen-Duc & Cruzes, 2013)

Figure 3: Determinants of communication frequency (Sosa et al., 2002)

Figure 4: Software development teams dependencies model based on (Li & Maedche, 2012; Scheerer et al., 2014; Sosa et al., 2002; Strode, 2013)

Figure 5: Call-graph with social information (Trainer et al., 2005)

Figure 6: Conceptual framework of coordination types (Scheerer et al., 2014)

Figure 7: Strategy types of coordination (Scheerer et al., 2014)

Figure 8: Sub-strategy types (Scheerer et al., 2014)

List of abbreviations

1 Introduction

1.1 Motivation

In the past the way of working in business was different than nowadays. Tasks were mostly defined and given to the employees by the corresponding manager. After the tasks were distributed to the employees, they started working on them individually and nearly separately. This way of working was justified in the characteristics of the tasks since they were mostly not dependent of each other. However, these days the complexity of tasks increased significantly in comparison to former tasks, which as a consequence became more and more dependent of each other.

Exactly this development of dependencies between tasks can be applied to software and employees working together on software development: Software used to be developed rather individually or in small teams. In course of time the development of software became more and more complex and thus software dependencies became an important factor in software development and most software development is now performed by teams of software engineers working collaboratively to achieve the determined goals. As a consequence the teams, developing software, became more dependent of each other. (Arora & Goel, 2012, page 1)

Furthermore, maintenance and development costs are also higher because of the mentioned inevitable changes in software and hence software complexity. This also means that designing software also depends on how well the software is structured, so that collaboration, coordination and communication among the software development teams are an important aspect in developing software.(Breivold et al., 2008) These three aspects are also a consequence of the development from single software development to large-scale multi-team development.

So, teaching employees how to write programs concerning software development is not the only ability to learn anymore. What is more, developers need to conceive that it is very important to be able to write programs comprehensivly for others and to understand programs, written by others. However, a lot more important factor is that developers must be able to work effeciently with others. This is due to the increased dependencies of software.(Arora & Goel, 2012, page 1)

1.2 Goal of the paper

The goal of this seminar paper is to find out which dependencies exist in software development teams. These dependencies and their consequences will be identified and defined. These findings will be gathered by a systematic literature review based on the guidelines of Kitchenham, which will be explained in the second chapter. After that these findings will serve as a reference for constructing a framework respectively model, which illustrates and summarizes the impact of the dependencies for the software development teams. What is more, the literature review and the built model will be finally the answer to the following two research questions of this paper:

Q1: What types of dependencies between software development teams are reported in the Information Systems and Software Engineering literature? Q2: What are the current theories on effects of team interdependencies?

1.3 Structure of the paper

The first chapter describes the motivation, problem and goal of the seminar paper and serves as an introduction to the topic of this seminar paper. Moreover, the two research questions are illustrated, which will be answered in the further course of this paper. In the second chapter the applied research methodology will be explained. The main focus of this paper will lie on the third chapter, in which first software dependencies will be determined and then derived to software development teams. The fourth chapter will illustrate the constructed framework respectively model based on the key findings of the third chapter. The fifth and last chapter will be a summary of the seminar paper and evaluate the findings critically. What is more, it will be defined how the work of this paper could be continued.

2 Research methodology

For this seminar paper a systematic literature review methodology has been chosen, which is based on the guidelines of Kitchenham. This methodolgy has been especially chosen because some literature already exists about software dependencies as well as dependencies among software development teams. Furthermore, it is the goal to leverage the existing literature about the mentioned topics in order to answer the research questions ideally.

The following search engines have been used in order to find the relevant literature for this seminar paper:

IEEE Xplore: http://ieeexplore.ieee.org

AIS Electronic Library: http://aisel.aisnet.org

Springerlink: http://link.springer.com

EBSCO: http://search.ebscohost.com

The keywords for the related topic were “Dependency“, “Interdependency“, “Coordination“, “Collaboration“ and “Roles“ and the keywords for the searching area were “Teams“, “Software Development Teams“, “Software Development“, “Systems Development“, “Team Performance“ and “Programming Teams“. After having defined these keywords, they were used to search in the above mentioned search engines. But, this resulted in hundreds of retrieved papers. In order to reduce the high number of papers and limit them to the only relevant ones, first only those were considered which were addressing topics concerning dependencies. Second, all papers were filtered out which were not referring to dependencies and software as well as dependencies and teams. Third, the abstract of the papers became relevant and helped to filter out approximately 50 papers so that in sum a much smaller number of papers were relevant for this seminar paper. Finally, all the relevant gathered papers were classified by their relevance in “relevance 1“, “relevance 2“ and “relevance 3“. This classification process helped a lot for using the best relevant literature in this seminar paper.

3 Software dependencies resulting in team dependencies

In order to determine and understand software dependencies and the resulting dependencies among software development teams, it is important to get a comprehensive about dependencies in general. For this purpose the following figure has been slightly adjusted from the original one of Andrzej Duda and Chérif Keramane:

Figure 1: What are dependencies based on (Duda & Keramane, 1995)

illustration not visible in this excerpt

Figure 1 shows three different situations with each two variables “a“ and “b“. The first situation “a starts b“ is a dependency because “b“ is dependent of “a“. This is true as “b“ cannot start unless “a“ has not finished. What is more, “b“ stops “a“ also illustrates a dependency between both variables. If “b“ does not break “a“, “a“ will not stop doing its task and therefore “a“ is dependent of “b“. The last situation shows a state in which no dependency exits. Since “a“ and “b“ are unrelated to each other “a“ and “b“ are independent. This means that “a“ and “b“ can perform tasks independently.(Duda & Keramane, 1995)

To sum up, dependencies can be best explained by quoting Strode and Huff: “[a dependency is] a situation that occurs when the progress of one action relies upon the timely output of a previous action or the presence of a specific thing.“(Strode, 2013)

3.1 Software dependencies

After having defined dependencies in general, this section will focus on the different dependencies of software, which are the basis for dependencies among software development teams. It is important to know that the literature suggests many dependencies regarded from different perspectives like source code, design or structure. Since analyzing all dependencies of software would be a research question for another paper, only selected dependencies of software will be presented in the following.

Before introducing the different dependency views, one view of software dependencies will be presented as a hypothesis first. This hypothesis has been chosen because the author of this paper believes that this view is the general comprehensive of software dependencies:

Ghezzi et al. believe that the more independent the modules of software are, the more independently software development teams can work (Ghezzi, Jazayeri, & Mandrioli, 2002, page 241). It is clearly noticeable, that they link software dependencies with modular components of software. In general, software modules are dependent of each other if a module relies on another module to conduct its operations (Spanoudakis & Zisman, 2004). What is more, Herbsleb et al. and Parnas have the same opinion and state that if one wants to lower software development teams’ dependencies, the modular component dependencies need to be reduced (Herbsleb et al., 2000; Parnas, 1972). In the following, the key findings of two authors concerning software dependencies will be presented:

Futrell et al. differentiate between two dependencies in software development – internal and external dependencies (Futrell et al., 2002, page 340):

External dependencies include any connection to the results of other projects, which means that the software development has dependencies to higher-level or lower-level projects. This means that one’s software development tasks may be dependent of e.g. hardware, installation or training. What is more, stakeholders can also be external dependencies. One example would be that one is dependent of them concerning financials. Another example for stakeholder dependency can be suppliers because one may be dependent of another software project which implements an interface to a third-party system for example which you need to use.(Futrell et al., 2002, page 340)

Internal dependencies are related to the software development project. These emerge in the form of dependencies between modules, components and processes since they are highly interrelated. They are a direct result of relationships between various components. Moreover, integral process dependencies are also internal ones like software quality audits etc.(Futrell et al., 2002, page 341)

Strode and Huff were focusing on internal dependencies in software development projects. They found out that there exists three major dependencies:

“Knowledge dependency“

“Task dependency“

“Resource dependency“ (Strode, 2013)

Knowledge dependency appears if any form of information is required to progress in a project. Strode and Huff identified four forms of knowledge dependency: “Requirement“: This means that a requirement or domain knowledge is not known and must be identified. On top of that, this issue affects the software development process. The second form of knowledge dependency is “expertise“: This appears during a situation where technical or task information is not known by everyone and this affects the software development process. Another form of knowledge dependency is “task allocation“: Task allocation occurs when it is not known who is doing what and this affects the software development process. The last form of knowledge dependency is “historical“: Historical is a situation in which knowledge about former decisions is required and this influences the software development process.(Strode, 2013)

Task dependency appears when one task needs to be finished before another task can be started, proceeded or finished during software development. Task dependency is differentiated between two forms: “Activity“: This is a situation in which an activity cannot proceed because another activity has not been completed and this situation affects the software development process. The last form of task dependency is “business process“: business process is a situation in which an existing business process causes activities to be proceeded in a certain order, which affects the software development process.(Strode, 2013)

The last of the three major identified dependencies by Strode and Huff is “resource dependency“. Resource dependency is defined as the requirement of an object for the software development project to progress. Resource dependency is differentiated between two forms: “Entity“: entity is a situation in which a resource like a person, place or thing is not availabe, which influences the software development process. The last form of resource dependency is “technical“: this means that a technical aspect of the software development affects the progress because one software component needs to interact with another software component and its availability affects the software development process.(Strode, 2013)

Based on the three major dependencies, which have been explained above, Diane Strode conducted an experiment, in which four different projects have been observed. Three of this project were an agile project and one was a non-agile project. Since the observations did not show a difference among all four projects, it can be assumed that the three dependencies can be applied to all software development projects. The goal of her research was to find out which of the three dependencies is dominant.(Strode, 2013)

[...]