How Agile Practices Influence the Performance of Software Development Teams: The Role of Shared Mental Models and Backup

This study draws on team adaptation theory to examine how agile behavior within Information Systems development (ISD) teams influences team performance. We conceptualize agile behavior as the degree to which ISD teams use agile practices and test a theoretical model that links agile practice use to two key components of team adaptation—shared mental models and backup behavior. Moreover, in line with team adaption theory, shared mental models among team members are hypothesized to increase backup behavior, which in turn is suggested to lead to higher levels of ISD team performance in complex environments. To test our hypotheses, we collected data from Scrum masters, project leaders and more than 490 professional software engineers of a global enterprise software development company. Our findings broadly confirm our theoretical model linking agility, adaptation, and ISD team performance, leading to several theoretical and practical contributions. Project Management and IS Development 2 Thirty Fifth International Conference on Information Systems, Auckland 2014 Introduction Many software companies have adopted an agile development approach during the last years in order to achieve process flexibility and cope with volatile user requirements (Abrahamsson et al. 2009; Baskerville et al. 2006; Dybå and Dingsøyr 2008; MacCormack et al. 2001). While initially introduced as a countermovement from the traditional, plan-driven approach, agile development is mainstream today (VersionOne 2012; West et al. 2010). The traditional approach divided the development process into sequential phases of planning, implementation, validation and a single software release at the end of the project (Boehm 2006). Agile development, by contrast, follows an iterative approach with frequent software releases of incremental functionality (Highsmith and Cockburn 2001; Lindstrom and Jeffries 2004). This requires developers to assure software quality throughout the entire development process rather than relying on dedicated testers that validate the software after it is fully implemented. As a consequence, numerous quality-oriented development practices have become popular during the last years, such as pair programming, code review, or automated testing (Beck 2000), labeled as agile practices. Agile developers write test cases to automatically check their software for bugs (automated testing), ask their colleagues for feedback on work results (code reviews), or even solve the development task together working on a single computer (pair programming). In addition, the popularity of Scrum (Schwaber and Beedle 2002), an agile project management framework, emphasizes the importance of teamwork in most software development organizations. A number of studies within the IS field have examined software development processes and particularly software development teams (Faraj and Sproull 2000; Harter and Slaughter 2003; Henderson and Lee 1992; Hoegl and Gemuenden 2001). While previous studies have focused on agile software development (Lee and Xia 2010; Maruping et al. 2009; McAvoy and Butler 2009; Ramesh et al. 2012; Sarker and Sarker 2009; Strode et al. 2012; Vidgen and Wang 2009), a comprehensive understanding and evaluation of the agile approach in software development teams is still in its infancy (Dingsøyr et al. 2012). There is a clear need for more theory-based, industrial studies on agile software development teams (Dingsøyr et al. 2012; Dybå and Dingsøyr 2008). This study addresses this research gap by investigating the impact of using agile development practices on the performance of software development teams. Our key assertion is that the use of agile practices not only directly influences the performance of software development teams, but that it also affects various teamwork mechanisms. Hence, the study draws on team effectiveness research from organization sciences and social psychology (Mathieu et al. 2008; Salas et al. 2005) to answer the central research question: how do agile software development practices influence the performance of software development teams. Team adaptation theory (Burke et al. 2006) holds that shared mental models and backup behavior are central makers of adaptive teams. This study posits that the use of agile practices is positively related to both markers providing a so far unrecognized explanation for performance effects of agile software development on team performance building on the idea that agile development increases team adaptability. We first develop a research model focusing on shared mental models and backup behavior as determinants of team performance in agile software development teams. We test our hypotheses with survey data from more than 490 professional software developers working in 81 development teams in a large, international enterprise software company. Finally, we discuss the study’s findings. Schmidt et al. / How Agile Practices Influence Software Development Team Performance Thirty Fifth International Conference on Information Systems, Auckland 2014 3 Theoretical and Conceptual Background Agile Development Practices Organizations increasingly follow an agile software development approach with software engineers using agile development practices such as pair programming, code review, or automated testing (Beck 2000; Highsmith and Cockburn 2001). These development practices are behavioral norms introduced, e.g. through training programs, to standardize developers’ work processes (Mintzberg 1980) and to direct developers towards company-wide goals, e.g. by encouraging software engineers to focus on software quality right from writing the first line of code. In many agile software companies, however, software development teams are not obliged to apply agile practices. Developers mostly have a great level of freedom to decide how they organize their personal work and how they collaborate within their teams. One the one hand, agile software engineers are not formally monitored or controlled how they fulfill their tasks (Cockburn 2001; Highsmith and Cockburn 2001; Schwaber and Sutherland 2011). Instead, they have a high level of autonomy for decision-making and task fulfillment. On the other hand, software developers have the responsibility for software quality assurance knowing that there is no team-external validation step before the software gets shipped to the customer. Hence, team autonomy coincides with responsibility to deliver software quality that meets customer expectations. To fulfill these responsibilities and to frame this high degree of autonomy, agile teams therefore develop and follow organizational work norms. This study takes a more general perspective and examines the behavioral norms framed by the agile development approach. We assume that agile software practices are a specific way to instantiate the agile work norms. There are numerous agile software development practices that software development teams use. In this study, we focus on pair programming, code reviews, and automated testing. These practices fundamentally influence software developers’ implementation work based on the core agile values and principles. Moreover, our research context comprises thousands of software developers familiar with these three practices as the studied company had decided to formally introduce them through a training program. Finally, these practices are among the most widely adopted agile methods according to a worldwide survey among software engineers (VersionOne 2012). Hence, we conceptualize our independent variable, called ‘agile practices use’, as the degree to which software development teams apply pair programming, code reviews, and automated testing as a means for standardizing work norms. Even though these particular development practices are specific to software development, we view them as a context-specific instantiation of an agile work mode. This work style may be relevant for new product development teams working in dynamic and uncertain environments. Team Adaptation Theory Previous research suggests that most software development teams work in highly dynamic project contexts (MacCormack and Verganti 2003; Schmidt et al. 2001). Lee and Xia (2005) found that businessand technology-related volatility is the major sources of change in software development projects. Regarding business-related change, the team setup may shift, there might be a change in the functional or non-functional system requirements, or due dates may be modified. Second, technology-related change might occur. For instance, the used technology, the system architecture, or other technical components the software relies upon could change unpredictably (Kude et al. 2014a). We propose the ability of a software development team to adapt to novel situations as an essential antecedent of high performance software development teams. Therefore, we draw on team adaptation theory (Burke et al. 2006) and develop a research model that links the use of agile development practices to team performance explained through two central teamwork factors proposed by the theory (see Figure 1). Team adaptability is defined as a team’s “ability to change team performance processes in response to cues from the environment in a manner that results in functional team outcomes” (Burke et al. 2006). Team adaptation theory holds that adaptive teams successfully manage to (1) assess situations appropriately and build a coherent understanding of a new situation, (2) adjust their plans accordingly, (3) coordinate their work to fit the new situation, and (4) learn by evaluating their effectiveness. While iterating this four-step adaptation process, the team develops emergent states and behavioral markers (Marks et al. 2001; Rosen et al. 2011). This adaptation model is very complex and therefore difficult to Project Management and IS Development 4 Thirty Fifth International Conference on Information Systems, Auckland 2014 apply. Hence, researchers suggested studying behavioral markers which are expected to be more pronounced in adaptive teams. We follow Salas et al. (2005) who proposed that team adaptation is positively related with a high sharedness of team members’ mental models (DeChurch and MesmerMagnus 2010) and strong team backup behavior (Marks et al. 2001). In the following sections, we argue that a team’s shared mental models as well as team backup behavior are key antecedents for the performance of software development teams. Both are proposed to be either directly or indirectly affected by the use of agile software development practices. Shared Mental Models Mental models are organized knowledge structures consisting of the content as well as the structure of the concepts in the mind of individuals (Byrne 2001). Mental model theory was first proposed by Johnson‐ Laird (1980) as a cognitive concept that can represent knowledge structures and relationships. People use mental models to describe, explain, and predict a system or people they interact with. For example, software engineers may possess a mental model of the software architecture or mental models about the expertise of their coworkers. This helps them coordinate collaboration within the team or make good software design decision if the model properly mirrors the actual functioning of the software. Shared mental models are team members' shared, organized understandings and mental representation of knowledge about key elements of the team's work environment (Klimoski and Mohammed 1994). They are defined as the degree of similarity among the mental models of members (Burke et al. 2006; Byrne 2001; Klimoski and Mohammed 1994; Mohammed and Dumville 2001; Salas et al. 2005). Shared mental model theory holds that effective teams need to maintain a shared understanding within the team that allows team members to interpret information in a similar way, leading to better communication and coordination (Cannon-Bowers et al. 1993). Byrne (2001) suggested that task-related, i.e. shared knowledge about the task, and team-related mental models, i.e. shared knowledge about roles and responsibilities of team members, exist in parallel. Both have been found to have a positive impact on team adaptation in novel situations (Burke et al. 2006). Previous IS studies have applied shared mental models theory to show how agile development methods might influence collaboration within the team (Yu and Petter 2014) and how team members’ personality influences the emergence of shared mental models (Yang et al. 2008). Previous research suggested social interaction (Levesque et al. 2001) such as frequent communication, information sharing, participation, or negotiation (Klimoski and Mohammed 1994) to be the primary mechanism through which shared mental models develop. Second, spending time together to learn the dominant logic prevailing within a team strongly influences the development of a shared understanding. Furthermore, role differentiation plays a major role in the development of shared mental models. For teams with diverse roles, cross-training and carrying out other team members’ duties can have a positive influence on the development of shared mental models (Marks et al. 2002). Finally, performance monitoring and self-correction was found to be positively related to higher mental model congruency (Rasker et al. 2000). Markers of Adaptive Team Performance Backup behavior Task complexity