Article

Strengthening the Case for Pair-Programming

Authors:
To read the full-text of this research, you can request a copy directly from the authors.

Abstract

The software industry has practiced pair programming (two programmers working side by side at one computer on the same problem) with great success for years, but people who haven't tried it often reject the idea as a waste of resources. The authors demonstrate that using pair programming in the software development process yields better products in less time-and happier, more confident programmers

No full-text available

Request Full-text Paper PDF

To read the full-text of this research,
you can request a copy directly from the authors.

... and wholly share the ownership of the work product. [35] The study [35] found that almost the only defects that made it through unit and functional testing were written by solo programmers, as opposed to pair programmers. [35] "A side effect of pair programming is a high order of staff cross training which removes additional long-term costs from development." ...
... and wholly share the ownership of the work product. [35] The study [35] found that almost the only defects that made it through unit and functional testing were written by solo programmers, as opposed to pair programmers. [35] "A side effect of pair programming is a high order of staff cross training which removes additional long-term costs from development." ...
... [35] The study [35] found that almost the only defects that made it through unit and functional testing were written by solo programmers, as opposed to pair programmers. [35] "A side effect of pair programming is a high order of staff cross training which removes additional long-term costs from development." [35] Since Truls would be programming mostly for iOS, and Erling and Toni for Android, we believed setting up mixed teams between the two platforms would help in ensuring everybody understands as much as possible about the entire product we were creating. ...
Thesis
Full-text available
The goal of this study is to examine if several smaller mobile applications work as well as one big application, from a usability and security perspective. To answer this, we developed a cross-platform SSO (Single Sign-On) library capable of providing a secure, invisible SSO experience. We also tested an implementation of inter-app navigation on 13 users and found that only 2/13 noticed noticed a difference when solving two tasks in one big app, as opposed to three different apps. Using the System Usability Scale on our inter-app navigation implementation, we found the average usability of the three small apps solution to be just 5 points below the big app.
... The popularity of collaborative practices, such as pair programming (PP), have continuously grown along with the growing interest in implementing agile software development methodologies. The increased interest in PP has been linked with that joint problem solving outperforms individual capabilities [2] and that developers enjoy pairing more than working solo [3]. ...
... Last but not least, PP has also been found to be a practice that developers enjoy. Williams et al. [3] found that more than 90% stated that they enjoyed collaborative programming more than solo programming. ...
... Our findings support the earlier research emphasizing the importance of and consensus over good tools for RPP [19,20]. Concerning RPP benefits, our study confirms that engineers pair program because they enjoy it [3], especially as an important mean for socialization while WFH, which goes beyond RPP for quality and efficacy [11] and is not much discussed in the existing literature. ...
Chapter
Along with the increasing popularity of agile software development, software work has become much more social than ever. Contemporary software teams rely on a variety of collaborative practices, such as pair programming, the topic of our study. Many agilists advocated the importance of collocation, face-to-face interaction, and physical artefacts incorporated in the shared workspace, which the COVID-19 pandemic made unavailable; most software companies around the world were forced to send their engineers to work from home. As software projects and teams overnight turned into distributed collaborations, we question what happened to the pair programming practice in the work-from-home mode. This paper reports on a longitudinal study of remote pair programming in two companies. We conducted 38 interviews with 30 engineers from Norway, Sweden, and the USA, and used the results of a survey in one of the case companies. Our study is unique as we collected the data longitudinally in April/May 2020, Sep/Oct 2020, and Jan/Feb 2021. We found that pair programming has decreased and some interviewees report not pairing at all for almost a full year. The experiences of those who paired vary from actively co-editing the code by using special tools to more passively co-reading and discussing the code and solutions by sharing the screen. Finally, we found that the interest in and the use of PP over time, since the first months of the forced work from home to early 2021, has admittedly increased, also as a social practice.
... People who participate in pair programming through this method take on different computerrelated responsibilities (Campe et al., 2020). One of the partners types and develops code as a driver, while the other acts as navigator and monitors the driver to identify problems, defines possible strategies, checks for errors throughout the process, and suggests solutions for problems (Williams et al., 2000. By exchanging positions at specific times or when specific task pieces are completed, partners become active participants in the entire project (Tsan et al., 2020;Williams et al., 2000). ...
... One of the partners types and develops code as a driver, while the other acts as navigator and monitors the driver to identify problems, defines possible strategies, checks for errors throughout the process, and suggests solutions for problems (Williams et al., 2000. By exchanging positions at specific times or when specific task pieces are completed, partners become active participants in the entire project (Tsan et al., 2020;Williams et al., 2000). In this way, both partners become involved in the brainstorming process throughout the activities . ...
... Pair programming is an approach where two students, one navigator and one driver, program collaboratively on a computer. The literature suggests that the collaborative programming approach is more effective than working alone (Williams et al., 2000. The navigator examines all the code written by the driver and thinks about strategic directions and improvements. ...
... The popularity of collaborative practices, such as pair programming (PP), have continuously grown along with the growing interest in implementing agile software development methodologies. The increased interest in PP has been linked with that joint problem solving outperforms individual capabilities [2] and that developers enjoy pairing more than working solo [3]. ...
... Last but not least, PP has also been found to be a practice that developers enjoy. Williams et al. [3] found that more than 90% stated that they enjoyed collaborative programming more than solo programming. ...
... Our findings support the earlier research emphasizing the importance of and consensus over good tools for RPP [19,20]. Concerning RPP benefits, our study confirms that engineers pair program because they enjoy it [3], especially as an important mean for socialization while WFH, which goes beyond RPP for quality and efficacy [11] and is not much discussed in the existing literature. ...
Preprint
Along with the increasing popularity of agile software development, software work has become much more social than ever. Contemporary software teams rely on a variety of collaborative practices, such as pair programming, the topic of our study. Many agilists advocated the importance of collocation, face-to-face interaction, and physical artefacts incorporated in the shared workspace, which the COVID-19 pandemic made unavailable; most software companies around the world were forced to send their engineers to work from home. As software projects and teams overnight turned into dis-tributed collaborations, we question what happened to the pair programming practice in the work-from-home mode. This paper reports on a longitudinal study of remote pair programming in two companies. We conducted 38 interviews with 30 engineers from Norway, Sweden, and the USA, and used the results of a survey in one of the case companies. Our study is unique as we collected the data longitudinally in April/May 2020, Sep/Oct 2020, and Jan/Feb 2021. We found that pair programming has decreased and some interviewees report not pairing at all for almost a full year. The experiences of those who paired vary from actively co-editing the code by using special tools to more passively co-reading and discussing the code and solutions by sharing the screen. Finally, we found that the interest in and the use of PP over time, since the first months of forced work from home to early 2021, has admittedly increased, also as a social practice.
... Pair programming has primarily been studied with high school and university-aged students (e.g. Missiroli et al., 2016;Williams et al., 2000), but there is a growing interest in applying it with younger students since collaborative learning strategies are regularly used in elementary classrooms (e.g. Gillies & Boyle, 2010). ...
... In CS education, collaborative work often takes the form of pair programming. Traditional pair programming entails two students working on a single computer, each student has a designated role -the driver who has control of the input devices and the navigator who strategically guides the work (Williams et al., 2000). Both programmers are expected to talk continuously about their work, engage in collaborative problem solving, and to switch roles after a set amount of time or portion of the task has been completed. ...
... Both programmers are expected to talk continuously about their work, engage in collaborative problem solving, and to switch roles after a set amount of time or portion of the task has been completed. This pedagogical configuration has been used in industry (Canfora et al., 2007), in undergraduate classes (Williams et al., 2000), and in high school (Missiroli et al., 2016). As interest in CS education has moved to earlier grades, there is a growing interest in using pair programming with younger students (e.g. ...
... People who participate in pair programming through this method take on different computerrelated responsibilities (Campe et al., 2020). One of the partners types and develops code as a driver, while the other acts as navigator and monitors the driver to identify problems, defines possible strategies, checks for errors throughout the process, and suggests solutions for problems (Williams et al., 2000. By exchanging positions at specific times or when specific task pieces are completed, partners become active participants in the entire project (Tsan et al., 2020;Williams et al., 2000). ...
... One of the partners types and develops code as a driver, while the other acts as navigator and monitors the driver to identify problems, defines possible strategies, checks for errors throughout the process, and suggests solutions for problems (Williams et al., 2000. By exchanging positions at specific times or when specific task pieces are completed, partners become active participants in the entire project (Tsan et al., 2020;Williams et al., 2000). In this way, both partners become involved in the brainstorming process throughout the activities . ...
... Pair programming is an approach where two students, one navigator and one driver, program collaboratively on a computer. The literature suggests that the collaborative programming approach is more effective than working alone (Williams et al., 2000. The navigator examines all the code written by the driver and thinks about strategic directions and improvements. ...
Article
The pair programming approach is used to overcome the difficulties of the programming process in education environments. In this study, the interaction sequences during the paired programming of preservice teachers was investigated. Lag sequential analysis were used to explore students’ behavioral patterns in pair programming. The participants of the study consist of 14 students, seven pairs enrolled in a Programming Languages course. The findings indicate that there are significant behavioral learning sequences. During the program development process, students hesitated to create an algorithm and to improve an existing one while proposing the next step. In addition, they constantly waited for approval. Collaborative behaviors such as giving and receiving feedback and helping other partners were less observed in females. In addition, significant sequential driver and navigator behaviors were presented. The findings of the study have important implications for instructors and designers when using a pair programming approach in teaching programming. In the future, programming instruction environments can be designed by considering the learner behaviors that are presented in this study.
... While several studies have investigated pair-programming at professional or higher educational levels [1]- [3], the present research aims to explore whether and under what conditions game-programming in a pair setting benefits students' problem-solving in the context of learning to program in secondary (K9) classrooms. Thus, the subjects of this research were 41 students (age: [14][15] in four computer science classes (CS) located in Vienna, Austria. In brief, the present study investigates students' technical outcomes in the pairversus the solo-programming setting and explores any differences in students' coding achievements in the two settings. ...
... Jensen [13] found that the error rate for a project with pair-programming was three orders of magnitude smaller than for other similar projects. In an academic environment, the most cited study is probably the one described in Williams et al. [14], in which 13 university students worked individually on a project and 28 chose to work in pairs. The findings showed that code produced by the pairs passed more automated tests over four different programming exercises. ...
Conference Paper
This Research to Practice Full Paper depicts and evaluates a secondary school project on using pair-and solo-programming of mini-games in introductory programming classes. In addition to investigating various factors influencing students' problem-solving skills (K9; age 14-15), we introduce the software metric Lines Of Code (LOC) to compare outcomes on that specific measure in the pair-and solo-programming setting. The mini-games were developed with the free personal edition of the game development engine Unity™ and C#. In the current study, four different classes at the secondary level were instructed and researched. All classes had approximately the same number of students, the same tasks, the same tutorials, but were using a different social setting for programming. In response to the worldwide pandemic in the years 2020 and 2021, instruction and research proceeded either in virtual or in hybrid-learning mode. We chose participatory action research to accommodate for the complexity of factors inherent in the field as well as for its iterative, cyclic nature. The current cycle is the third of a series on studies that have investigated various aspects of introductory pair-programming. The evaluation phase employs a digital questionnaire with open and closed questions aimed to capture student's perceptions regarding problem solving. In addition, the software metric Lines Of Code" (LOC), traditionally used to measure the size of a computer program by counting the number of lines of the program's source code, was adapted to measure students' achievement in pair-and solo-programming. With our research we aim to contribute to make learning to program more effective, engaging, and inclusive, and we would like to promote 21 st century competences besides programming skills. In addition, we are eager to share our practice of pair-programming with educators in order to inspire them to experiment with pair-programming as a social setting with high potential, even in times of required social distancing.
... An agent may "envy" another agent because the other agent has some special qualification. The central authority wants to improve the situation by building teams of two agents where, due to a daily extensive cooperation, one teaches the other the missing qualification (for instance, a realization of this is the concept of pair programming that also has other benefits besides knowledge sharing [Williams et al., 2000]). ...
... This approach is justified when the burden of sharing is neutralized by its advantages. Indeed, in our knowledge sharing example a hassle of cooperation is often compensated by a better working experience or higher quality outcomes (as shown by Williams et al. [2000]). Note that such complicated mutual dependencies that would be extremely hard to describe formally form a natural field for our approach. ...
Preprint
Given an initial resource allocation, where some agents may envy others or where a different distribution of resources might lead to higher social welfare, our goal is to improve the allocation without reassigning resources. We consider a sharing concept allowing resources being shared with social network neighbors of the resource owners. To this end, we introduce a formal model that allows a central authority to compute an optimal sharing between neighbors based on an initial allocation. Advocating this point of view, we focus on the most basic scenario where a resource may be shared by two neighbors in a social network and each agent can participate in a bounded number of sharings. We present algorithms for optimizing utilitarian and egalitarian social welfare of allocations and for reducing the number of envious agents. In particular, we examine the computational complexity with respect to several natural parameters. Furthermore, we study cases with restricted social network structures and, among others, devise polynomial-time algorithms in path- and tree-like (hierarchical) social networks.
... In pair programming, the person controlling the keyboard and mouse acts as the driver, while the person who is tasked with planning ahead and looking for mistakes acts as the navigator. Researchers have discovered the educational efficacy of collaborative programming for undergraduate novice programmers [45,47], such as increased undergraduate retention in CS courses [35]. In light of these results, educators and researchers have begun to incorporate this approach into learning activities for middle and upper-elementary school students as well (e.g., [11,29]). ...
... Although pair programming has been shown to be beneficial to novices, much of the research has focused on undergraduate students and industry professionals [45,47]. Supporting younger learners in collaborative CS learning brings new challenges where we must be cognizant of the students' level of socio-emotional development. ...
... There are many studies on agile (Williams et al., 2000;Moe et al., 2009;Chuang et al., 2014;Mergel et al., 2020), and there is pointed out that Agile methods are created based on critiques of formalized methods (Baskerville et al., 1992;Wang et al., 2012). Despite the conducted research, there is still a gap in the range of customizing university management control systems to agile requirements and the research problem -whether the university's management control systems' legal framework favours agile. ...
... This concept's success, measured by the companies' results that implemented it, resulted in the scientific community's great interest in the agility concept. The research focuses on issues related to the way agile is used in various types of organizations (Boehm, 2002;Nerur et al., 2005;Erdogmus et al., 2005;Janzen and Saiedian, 2005;Chuang et al., 2014;Potdar et al., 2017;Masood et al., 2018), effectiveness in achieving the assumed goals (Williams et al., 2000;Sarkis, 2001), the influence of trust and communication on agile (Moe et al.,2009;McHugh et al., 2012), the impact of agile on project management (Hodgson and Briand, 2013). Attention is also drawn to the possibility of applying the agile concept in the public organization (Soe and Drechsler, 2018;Mergel et al., 2018;Ribeiro and Domingues, 2018;Mergel et al., 2020;Greve et al., 2020). ...
Article
Full-text available
Purpose: Little is known about the agile management control systems at public universities, their effects, and limitations in different contexts. This preliminary study addresses this research gap through an empirical study of the management control systems required at Polish universities. Approach/Methodology/Design: This paper's insights have emerged iteratively by considering both theory and the empirical case based on Agile Manifesto and management control systems' requirements at the universities. Findings: A study revealed a need to use Agile concept framing to develop and implement management control systems at public universities. Lack of managerial and employees' self-assessment focused on Agile issues leads to the potentially radical suggestion that decision-makers should change their current approach to management control systems if they want to avoid poor outcomes in different levels and areas of university activity. The findings make two main contributions. First, they contribute to grounding the Agile approach within public management by showing how Agile may use across contexts; Second, this study can form a source for an inquiry process at any university, thus contributing to a better contextual diagnosis of the stage where the university is building the quality of its research, managerial and financial process. Practical Implications: The article brings several valuable pieces of information and provides practical tips. Originality/Value: There are several studies on Agile, management control systems, and university issues; however, the research question – whether the legal framework of the university's management control systems favors agile was without an answer.
... Especially when working on practical tasks requiring creative or otherwise mental demanding solutions, teamwork has proven to be beneficial. In our case of programming, writing code collaboratively has been promoted in the form of pair programming to help programmers share learnings and improve their code's quality [105,175]. ...
... Another benefit of this "guided programming", where students are lead by the tutor but need to solve all tasks themselves, is that it e↵ectively circumvents students falling into pitfalls that would leave beginners stuck. Especially debugging sometimes feels cumbersome and demotivates students [175]. Experienced tutors can explain rather cryptic compiler errors and stack traces and help during debugging, allowing students to focus on their program design and algorithms. ...
Thesis
Massive Open Online Courses (MOOCs) open up new opportunities to learn a wide variety of skills online and are thus well suited for individual education, especially where proffcient teachers are not available locally. At the same time, modern society is undergoing a digital transformation, requiring the training of large numbers of current and future employees. Abstract thinking, logical reasoning, and the need to formulate instructions for computers are becoming increasingly relevant. A holistic way to train these skills is to learn how to program. Programming, in addition to being a mental discipline, is also considered a craft, and practical training is required to achieve mastery. In order to effectively convey programming skills in MOOCs, practical exercises are incorporated into the course curriculum to offer students the necessary hands-on experience to reach an in-depth understanding of the programming concepts presented. Our preliminary analysis showed that while being an integral and rewarding part of courses, practical exercises bear the risk of overburdening students who are struggling with conceptual misunderstandings and unknown syntax. In this thesis, we develop, implement, and evaluate different interventions with the aim to improve the learning experience, sustainability, and success of online programming courses. Data from four programming MOOCs, with a total of over 60,000 participants, are employed to determine criteria for practical programming exercises best suited for a given audience. Based on over five million executions and scoring runs from students' task submissions, we deduce exercise difficulties, students' patterns in approaching the exercises, and potential flaws in exercise descriptions as well as preparatory videos. The primary issue in online learning is that students face a social gap caused by their isolated physical situation. Each individual student usually learns alone in front of a computer and suffers from the absence of a pre-determined time structure as provided in traditional school classes. Furthermore, online learning usually presses students into a one-size-fits-all curriculum, which presents the same content to all students, regardless of their individual needs and learning styles. Any means of a personalization of content or individual feedback regarding problems they encounter are mostly ruled out by the discrepancy between the number of learners and the number of instructors. This results in a high demand for self-motivation and determination of MOOC participants. Social distance exists between individual students as well as between students and course instructors. It decreases engagement and poses a threat to learning success. Within this research, we approach the identified issues within MOOCs and suggest scalable technical solutions, improving social interaction and balancing content difficulty. Our contributions include situational interventions, approaches for personalizing educational content as well as concepts for fostering collaborative problem-solving. With these approaches, we reduce counterproductive struggles and create a universal improvement for future programming MOOCs. We evaluate our approaches and methods in detail to improve programming courses for students as well as instructors and to advance the state of knowledge in online education. Data gathered from our experiments show that receiving peer feedback on one's programming problems improves overall course scores by up to 17%. Merely the act of phrasing a question about one's problem improved overall scores by about 14%. The rate of students reaching out for help was significantly improved by situational just-in-time interventions. Request for Comment interventions increased the share of students asking for help by up to 158%. Data from our four MOOCs further provide detailed insight into the learning behavior of students. We outline additional significant findings with regard to student behavior and demographic factors. Our approaches, the technical infrastructure, the numerous educational resources developed, and the data collected provide a solid foundation for future research.
... A particularly active area of research in secondary CS education has been on collaborative (pair) programming [e.g. 24,44]. Developmental differences, in addition to varied experiences with technology, underscore the need to examine how much younger learners interact in such environments. ...
... 3.2.1 1C with Roles. In traditional pair programming, the roles are driver and navigator [44]. The driver inputs all coding changes via the keyboard and mouse/trackpad, whereas the navigator checks the driver's work and makes suggestions. ...
... Meanwhile, we notice that all the projects of Figure 6b have many outliers. In the modern software development, pair programming has been widely used [55], and researchers [15] are advocating this practice in distributed environments (e.g., open source projects). The outliers may be a side evidence for the practice of pair programming in open source communities, because in such a programming paradigm, two programmers typically make equivalent contributions to a file. ...
... Peer support can be important for computing students' interest, success, retention, and feelings of connectedness and competence [53,62,79,85]. Using pair programming, a technique by which students work together to accomplish a programming task, improves not only enjoyment but also retention [16,124]. Additionally, sense of belonging is noted as affecting students' perception of their own abilities, perhaps even more so than students' actual performance [120]. ...
Article
Despite increasing demands for skilled workers within the technological domain, there is still a deficit in the number of graduates in computing fields (computer science, information technology, and computer engineering). Understanding the factors that contribute to students’ motivation and persistence is critical to helping educators, administrators, and industry professionals better focus efforts to improve academic outcomes and job placement. This article examines how experiences contribute to a student’s computing identity, which we define by their interest, recognition, sense of belonging, and competence/performance beliefs. In particular, we consider groups underrepresented in these disciplines, women and minoritized racial/ethnic groups (Black/African American and Hispanic/Latinx). To delve into these relationships, a survey of more than 1,600 students in computing fields was conducted at three metropolitan public universities in Florida. Regression was used to elucidate which experiences predict computing identity and how social identification (i.e., as female, Black/African American, and/or Hispanic/Latinx) may interact with these experiences. Our results suggest that several types of experiences positively predict a student’s computing identity, such as mentoring others, having a job, or having friends in computing. Moreover, certain experiences have a different effect on computing identity for female and Hispanic/Latinx students. More specifically, receiving academic advice from teaching assistants was more positive for female students, receiving advice from industry professionals was more negative for Hispanic/Latinx students, and receiving help on classwork from students in their class was more positive for Hispanic/Latinx students. Other experiences, while having the same effect on computing identity across students, were experienced at significantly different rates by females, Black/African American students, and Hispanic/Latinx students. The findings highlight experiential ways in which computing programs can foster computing identity development, particularly for underrepresented and marginalized groups in computing.
... One of our team members is a strong proponent of pair programming (Williams et al., 2000;Hanks et al., 2011), where two students work together on a single machine to solve problems. This allows each pair of students to learn from each other as well as from their teacher(s) and thereby helps to broaden participation and to dispel the myth that programmers work on their own (Williams, 2006). ...
Preprint
Full-text available
In this paper we provide an account of how we ported a text and data mining course online in summer 2020 as a result of the COVID-19 pandemic and how we improved it in a second pilot run. We describe the course, how we adapted it over the two pilot runs and what teaching techniques we used to improve students' learning and community building online. We also provide information on the relentless feedback collected during the course which helped us to adapt our teaching from one session to the next and one pilot to the next. We discuss the lessons learned and promote the use of innovative teaching techniques applied to the digital such as digital badges and pair programming in break-out rooms for teaching Natural Language Processing courses to beginners and students with different backgrounds.
... In the computational physic lab course, students practiced pair programming-a software development technique shown to improve code quality and educational outcomes [12,13]. In pair programming, one student controls the mouse and keyboard to write code (the driver) and the partner gives feedback and suggestions on the code that was written and provides a road map of what needs to be done next (the navigator). ...
Article
Full-text available
The COVID-19 pandemic has made conducting in-person research a health risk for interviewers and participants. Near the start of the pandemic, many universities pivoted to emergency remote teaching where courses were delivered remotely in observance of safety guidelines. The safety guidelines also necessitated that research be done remotely. We designed a remote interview protocol for a computational physics based qualitative interview. Using Zoom’s features, we created an interview that allowed participants many modes of interacting with the interviewer and the interview task materials. We present the interview methods and evaluate the utility of remote interviews. We then generalize the experiences from designing and conducting remote interviews for contexts outside of computational physics and describe how task design choices were influenced by technology. We find that conducting interactive remote interviews can be an effective method for physics education researchers even outside of the pandemic.
... One comprehensive review found some evidence that PP contributes to student success in both introductory and intermediate programming courses (Hanks et al., 2011). Specific benefits to university students include improved performance, confidence, deeper conceptual understanding of the central ideas of computer science, and continued interest in pursuing a computing-related major McDowell et al., 2006;Sawyer & Goldman, 2010;Watkins & Watkins, 2009;Williams et al., 2000). Another study showed that women who pair programmed in an introductory computing class were more likely to take and pass the next class (Werner, Hanks, et al., 2004). ...
Article
Background: Learning to program and success in computer science requires persistence in the face of challenges. This study contributes to research on the social context of learning by describing how children’s peer interactions can support or hinder the pair’s problem solving on the computer. Methods: Video recordings from eight pairs of middle school students programming a computer game are used to explore how working with a partner supports or hinders the pair’s persistence in the face of challenges, what we call intrepid exploration (IE). Findings: IE thrives when partners are responsive to each other both verbally and non-verbally, and when they switch driver and navigator roles to share and build on each other’s expertise. IE is hindered when partners engage in a power struggle that results in disengagement with each other and giving up on their goal. For pair programming to result in interactions that promote persistence, both students must be willing and able to embrace their assigned roles: the navigator supporting their shared goal, and the driver responding to their navigator. Contribution: The types of interactions described in this paper provide a tool for teachers to evaluate and support productive collaboration among novice pair programmers.
... One of our team members is a strong proponent of pair programming (Williams et al., 2000;Hanks et al., 2011), where two students work together on a single machine to solve problems. This allows each pair of students to learn from each other as well as from their teacher(s) and thereby helps to broaden participation and to dispel the myth that programmers work on their own (Williams, 2006). ...
... Sustainable planning adoption is an attempt by software experts to solve current climate problems, and it can also improve the overall economic performances of software program organizations. Software program practitioners use sustainable practices to be useful to society, climate, and humanity [57,58]. Existing techniques particularly stress realizing sustainability when software program experts improve software. ...
Article
Full-text available
Agile software development methodologies have become the most popular software development methods in the last few years. These methodologies facilitate rapid development. The low cost and prioritized user satisfaction make these methodologies more attractive. These methodologies were also intended for small scale developmental teams. Therefore, challenges were encountered when these methodologies were used in large-scale development teams. This study was based on the identification of factors which were discovered in our previous study. Some of the factors included “leadership strong commitment and team autonomy”, “cooperative organizational culture”, and “team competency—agile development expertise”. A total of 147 practices were identified in this study via a systematic literature review. These practices will help practitioners and project managers to adopt agile software methodologies and encourage them to the enhance them.
... Consiste na prática de dois programadores lado a lado atuando na solução de um problema em uma mesma máquina, o que pode incluir atividades de elaboração de algoritmos, codificação, design e teste [Williams et al., 2000] (2) (3) (3) ...
Conference Paper
Full-text available
Incorporar agilidade aos processos de software é um tema que vai além do debate sobre a aplicação de métodos ágeis pré-definidos. Visando reforçar as evidências sobre a viabilidade de introduzir características de agilidade e práticas ágeis previamente mapeadas para obtenção de agilidade em processos de software, este artigo apresenta a reexecução em larga escala de um survey sobre a pertinência e a relevância destas características e práticas, coletando a opinião de 292 participantes. Os resultados sugerem um consenso sobre a pertinência da maioria das características e das práticas investigadas, embora a relevância delas não seja percebida na mesma intensidade. Em adição, novas características e práticas foram propostas.
... Collaborative Programming. Although CrossFix is inspired by the concept of collaborative testing (Tan and Li, 2020;Xie et al., 2014;Long et al., 2014 and pair programming (Williams et al., 2000), CrossFix is designed with the goal of recommending GitHub issues for assisting developers in debugging and fixing rather than finding bugs. Moreover, our study of similar bugs strengthens the observation of prior research on collaborative bug finding. ...
Preprint
Full-text available
Many automated program repair techniques have been proposed for fixing bugs. Some of these techniques use the information beyond the given buggy program and test suite to improve the quality of generated patches. However, there are several limitations that hinder the wide adoption of these techniques, including (1) they rely on a fixed set of repair templates for patch generation or reference implementation, (2) searching for the suitable reference implementation is challenging, (3) generated patches are not explainable. Meanwhile, a recent approach shows that similar bugs exist across different projects and one could use the GitHub issue from a different project for finding new bugs for a related project. We propose collaborative bug fixing, a novelapproach that suggests bug reports that describe a similar bug. Our studyredefines similar bugs as bugs that share the (1) same libraries, (2) same functionalities, (3) same reproduction steps, (4) same configurations, (5) sameoutcomes, or (6) same errors. Moreover, our study revealed the usefulness of similar bugs in helping developers in finding more context about the bug and fixing. Based on our study, we design CrossFix, a tool that automatically suggests relevant GitHub issues based on an open GitHub issue. Our evaluation on 249 open issues from Java and Android projects shows that CrossFix could suggest similar bugs to help developers in debugging and fixing.
... In our case, we required students to form teams to collectively work with these tools in programming projects. This has several advantages: (1) team members can use pair programming, 1 which helps them learn an unfamiliar platform more quickly, and results in higher quality code (Williams et al., 2000); (2) working in teams cultivates the students' collaboration and communication skills; and (3) collaborative activities are closer to industrial practice, which is bene cial for the career development of students. ...
Chapter
Full-text available
In today’s digital society, many digitally mediated tools are designed, developed, and used to teach students how to program. One example is the educational programming tool Scratch, developed at MIT. However, most educational tools are designed for K-12 and CS0 to CS2 students. Relatively few are developed for advanced undergraduate or graduate students. This chapter introduces several digitally mediated tools that can be used by more advanced students in industry-like programming projects. The first tool is test skeletons, which are test methods without the test bodies. The second one is an IDE (Integrated Development Environment) plugin to record student programming steps. Then, we introduce three Internet bots, which are either open source or free to use. These bots can not only detect system-specific guideline violations but also aggregate that information (including code smells (https://en.wikipedia.org/wiki/Code_smell) and the results of test execution) on a single GitHub (https://en.wikipedia.org/wiki/GitHub) pull-request (https://en.wikipedia.org/wiki/Distributed_version_control#Pull_requests) page. These tools aim to facilitate programming and code reviewing and help student teams to write high-quality code.
... Findings included more confident students, greater course completion and pass rates [22], a more likely to persist in computerrelated majors, reduced workload for the teaching staff [87]. There are studies that prove the speed of getting the tasks done: assignments 40-50% faster than solo developers [88]. It often benefits women and can be a solution for more women in computer science courses [76,89]. ...
Chapter
Full-text available
Teaching and learning how to program are not easy tasks: they can be very challenging. Introductory programming courses traditionally have high rates of failures and dropouts. Teachers and researchers must develop strategies to combat this problem. The purpose of this paper is to analyse the scientific production on strategies on teaching how to program in higher education in journals indexed in an international database’ indexed in Elsevier’s Scopus in the years 2000 to 2019. We provide an up-to-date review of the existing literature. To provide a comprehensive survey, we not only categorize existing strategies but also present detailed descriptions of relevant topics such as Active Learning, Pair Programming, Flipped Classroom and Project Based Learning. The sample was composed by 92 articles in total. The first results obtained by bibliometric analysis showed that publication rates increased slowly but have expanded in the last two years, in which journals the articles are published, which are the organizations and countries that publish the most and which are the most cited articles. The motivation for this study is to bear in mind the research that has been done so that it strategies can be used and experienced by teachers who teach programming to undergraduate students.
... At first, it may seem counter-intuitive that having two people working on one section of software at the same time can be more efficient than having each work on their own section. However, pair programming has been shown to produce higher-quality software in shorter times than traditional independent programming [19]. Summaries of studies on pair programming can be found in [20] and [21]. ...
... Pair programming, for example, is a practice that involves two developers collaborating as a single individual on the design, coding, and testing of the same programming task. This practice has been shown to be productive and to render higher-quality code than either developer may produce alone (Lui & Chan, 2006;Nosek, 1998;Williams, 2001;Williams, Kessler, Cunningham, & Jeffries, 2000;Williams & Upchurch, 2001), especially with novice programmers or challenging programming problems (Lui & Chan, 2006), and positive effects have been found in educational contexts as well (Braught, Wahls, & Eby, 2011;Tunga & Tokel, 2018;Umapathy & Ritzhaupt, 2017). Another popular practice involves explaining line by line what a nonworking piece of code is supposed to do. ...
Article
Full-text available
There is growing interest in teaching computer science and programming skills in schools. Here we investigated the efficacy of peer tutoring, which is known to be a useful educational resource in other domains but never before has been examined in such a core aspect of applied logical thinking in children. We compared (a) how children (N = 42, age range = 7 years 1 month to 8 years 4 months) learn computer programming from an adult versus learning from a peer and (b) the effect of teaching a peer versus simply revising what has been learned. Our results indicate that children taught by a peer showed comparable overall performance—a combination of accuracy and response times—to their classmates taught by an adult. However, there was a speed–accuracy trade-off, and peer-taught children showed more exploratory behavior, with shorter response times at the expense of lower accuracy. In contrast, no tutor effects (i.e., resulting from teaching a peer) were found. Thus, our results provide empirical evidence in support of peer tutoring as a way to help teach computer programming to children. This could contribute to the promotion of a widespread understanding of how computers operate and how to shape them, which is essential to our values of democracy, plurality, and freedom.
... Two individuals hence work to achieve the same aim, share resources, and also share knowledge. This makes solving programming problems easier and faster [40]. Various benefits of pair programming have been reported so far. ...
... The development of the agile presented in the Manifesto for Agile Software Development published in 2001 resulted in unprecedented changes in software engineering (Boehm, 2002;Chuang et al., 2014). Agile research focuses on topics related to how to apply the idea of agile in organizations (Boehm, 2002;Nerur et al., 2005), effectiveness in achieving assumed goals (Williams et al., 2000), the impact of trust and communication on the concept of agile (Moe et al., 2009), the possibilities of its application in various organizations and the areas of their functioning (Erdogmus et al., 2005;Janzen and Saiedian, 2005;Chuang et al., 2014;Wells, 2014;Potdar et al., 2017;Masood et al., 2018;Hodgson and Briand, 2013). Attention also focused on the possibility of using the agile concept in public administration, emphasizing the positive effects of such thought as rapid identification of changes, anticipating their potential impact on public administration and its clients, modifying standard operating procedures (Mergel et al., 2018;Dobrowolski, 2019). ...
Article
Full-text available
Purpose: Public organizations operate in a turbulent and increasingly less predictable environment. According to Wagner's law, they must meet better growing social needs, which increase as civilization progresses. Such a situation creates challenges for supreme audit institutions (SAIs), which are the most important public auditors. They must determine how the public organizations realized programs in the past and what factors may disrupt the realization of plans in the future. No one questions the public auditors' role in financial accountability and management. However, are the public auditors agile? This research aims to resolve this research question. Approach/Methodology/Design: The insights in this paper have emerged iteratively by considering both theory and the empirical case based on public auditors' database analysis and unstructured interviews with randomly selected Polish SAI auditors. Such methodology is consistent with an abductive approach. Findings: Based on available evidence, I offer the potentially radical generalization that SAI's current role is partially useless for society. Therefore, there is a need to implement an agile concept in SAI. Practical Implications: The article brings several valuable pieces of information that can be the base material and reference to further research. Study results can be a starting point of discussion and analysis on each auditor's agility, both from the public and private sectors. The twelve original and universal agile principles relating to the activity of auditors have been formulated. Originality/Value: There are several studies on SAIs; however, it is the first study, which aims to determine whether public auditors are agile, and first, where such agile principles of auditing were created.
... In a typical programming educational session, it is commonplace to work in pairs in a computer lab setting. Often, one of the students will be hands-on, (typing) while the other sits next to the driver discussing solutions hands-off, then switching places (Williams, Kessler, Cunningham, & Jeffries, 2000). We artificially imposed fixed hands-on or hands-off roles upon the participants, randomly assigned. ...
Thesis
Full-text available
Computer programming is fast becoming a required part of School curricula, but students find the topic challenging and university dropout rates are high. Observations suggest that hands-on keyboard typing improves learning, but quantitative evidence for this is lacking and the mechanisms are still unclear. Here we study neural and behavioral processes of programming in general, and Hands-on in particular. In project 1, we taught naïve teenagers programming in a classroom-like session, where one student in a pair typed code (Hands-on) while the other participated by discussion (Hands-off). They were scanned with fMRI 1-2 days later while evaluating written code, and their knowledge was tested again after a week. We find confidence and math grades to be important for learning, and easing of intrinsic inhibitions of parietal, temporal, and superior frontal activation to be a typical neural mechanism during programming, more so in stronger learners. Moreover, left inferior frontal cortex plays a central role; operculum integrates information from the dorsal and ventral streams and its intrinsic connectivity predicts confidence and long-term memory, while activity in Broca’s area also reflects deductive reasoning. Hands-on led to greater confidence and memory retention. In project 2, we investigated the impact of feedback on motivation and reaction time in a rule-switching task. We find that feedback targeting personal traits increasingly impair performance and motivation over the experiment, and we find that activity in precentral gyrus and anterior insula decrease linearly over time during the personal feedback condition, implicating these areas in this effect. These findings promote hands-on learning and emphasize possibilities for feedback interventions on motivation. Future studies should investigate interventions for increasing Need for Cognition, the relationship between computer programming and second language learning (L2), and the role of explicit verbalization of knowledge for successful coding, given the language-like processing of code.
... In particular, feedback opportunities can be included into classroom and lab sessions. For example, both peer instruction [13] and pair programming [90] create opportunities for reflection. In peer instruction, the reflection is partially guided by the teacher responsible for the peer instruction questions, while in pair programming, students interact and reflect on the program that is being worked on. ...
Preprint
This article explores the natural language generation capabilities of large language models with application to the production of two types of learning resources common in programming courses. Using OpenAI Codex as the large language model, we create programming exercises (including sample solutions and test cases) and code explanations, assessing these qualitatively and quantitatively. Our results suggest that the majority of the automatically generated content is both novel and sensible, and in some cases ready to use as is. When creating exercises we find that it is remarkably easy to influence both the programming concepts and the contextual themes they contain, simply by supplying keywords as input to the model. Our analysis suggests that there is significant value in massive generative machine learning models as a tool for instructors, although there remains a need for some oversight to ensure the quality of the generated content before it is delivered to students. We further discuss the implications of OpenAI Codex and similar tools for introductory programming education and highlight future research streams that have the potential to improve the quality of the educational experience for both teachers and students alike.
... In general, software practitioners have several means to detect bugs. These can range from QA practices such as code review [50,56,14], and inspection to different testing approaches, and even development methodologies such as pair programming [109,66,95], and Test Driven Development (TDD) [18,57,10,78]. When a bug is detected, it is common for the development teams to consider the most severe/important bugs first which helps them to prevent extreme consequences. ...
Preprint
Full-text available
In the past couple of decades, significant research efforts are devoted to the prediction of software bugs (i.e., defects). These works leverage a diverse set of metrics, tools, and techniques to predict which classes, methods, lines, or commits are buggy. However, most existing work in this domain treats all bugs the same, which is not the case in practice. The more severe the bugs the higher their consequences. Therefore, it is important for a defect prediction method to estimate the severity of the identified bugs, so that the higher severity ones get immediate attention. In this paper, we provide a quantitative and qualitative study on two popular datasets (Defects4J and Bugs.jar), using 10 common source code metrics, and also two popular static analysis tools (SpotBugs and Infer) for analyzing their capability in predicting defects and their severity. We studied 3,358 buggy methods with different severity labels from 19 Java open-source projects. Results show that although code metrics are powerful in predicting the buggy code (Lines of the Code, Maintainable Index, FanOut, and Effort metrics are the best), they cannot estimate the severity level of the bugs. In addition, we observed that static analysis tools have weak performance in both predicting bugs (F1 score range of 3.1%-7.1%) and their severity label (F1 score under 2%). We also manually studied the characteristics of the severe bugs to identify possible reasons behind the weak performance of code metrics and static analysis tools in estimating the severity. Also, our categorization shows that Security bugs have high severity in most cases while Edge/Boundary faults have low severity. Finally, we show that code metrics and static analysis methods can be complementary in terms of estimating bug severity.
Article
With the availability of cloud-based software, ubiquitous internet and advanced digital modeling capabilities, a new potential has emerged to design physical products with methods previously embraced by the software engineering community. One such example is pair programming, where two coders work together synchronously to develop one piece of code. Pair programming has been shown to lead to higher quality code and designer satisfaction. Cutting-edge collaborative Computer-aided Design (CAD) technology affords the possibility to apply synchronous collaborative access in mechanical design. We test the generalizability of findings from the pair programming literature to the same dyadic configuration of work in CAD, which we call pair CAD. We performed human subject experiments with 60 participants to test three working styles: individuals working by themselves, pairs sharing control of one model instance and input, and pairs able to edit the same model simultaneously from two inputs. We compare the working styles on speed and quality, and propose mechanisms for our observations via interpretation of patterns of communication, satisfaction, and user cursor activity. We find that on a per-person basis, individuals were faster than pairs due to coordination and overhead inefficiencies. We find that pair work, when done with a single shared input, but not in a parallel mode, leads to higher quality models. We conclude that it is not Industry 4.0 technologies alone that influence designer output; choices regarding work process have a major effect on design outcomes, and we can tailor our process to suit project requirements.
Chapter
Full-text available
The pandemic situation COVID-19 requires teachers to rethink some of the activities proposed to students since even though they are physically in the same room at the university, they cannot join and must maintain a social distance. The curricular unit of introduction to programming in the first year of computer courses requires several activities: students only learn by doing. One of the activities that has been used a lot in the academic community is pair programming: a single computer for two students working together. In the case that this article reports the pair works sharing a ZOOM room and alternates the position of driver (writes the code) with navigator (one that comments on the code). This article uses the technique of pair programming for writing top-down, algorithm and traces to verify the behavior of variables along the algorithm. If the pair programming technique has had very interesting results in terms of task speed and code quality far superior to programmers alone, there are some doubts about the problem of the constitution pf the groups. In this article we use two opposite strategies: group students with opposite knowledge or group students with similar knowledge. We found that students who prefer this activity are the worst ones (in both strategies) and the best students when grouped with colleagues with similar knowledge.
Book
Full-text available
This open access book constitutes the proceedings of the 22nd International Conference on Agile Software Development, XP 2021, which was held virtually during June 14-18, 2021. XP is the premier agile software development conference combining research and practice. It is a unique forum where agile researchers, practitioners, thought leaders, coaches, and trainers get together to present and discuss their most recent innovations, research results, experiences, concerns, challenges, and trends. XP conferences provide an informal environment to learn and trigger discussions and welcome both people new to agile and seasoned agile practitioners. This year’s conference was held with the theme “Agile Turns Twenty While the World Goes Online”. The 11 full and 2 short papers presented in this volume were carefully reviewed and selected from 38 submissions. They were organized in topical sections named: agile practices; process assessment; large-scale agile; and short contributions.
Chapter
Eine der Kernaufgaben in der Entwicklung von Software ist die Implementierung des Softwaresystems mit Hilfe einer oder mehrerer passend gewählter Programmiersprachen. Dadurch wird ein ablauffähiges Programmsystem geschaffen. Abhängig vom gewählten Vorgehensmodell wird mit der Implementierung vergleichsweise früh begonnen, etwa bei Scrum, oder nach Abschluss der wesentlichen Entwurfsarbeiten, etwa bei der Nutzung des V-Modells. Folgt die Entwicklung einem modellbasierten Ansatz, kann ablauffähiger Programmcode auch aus Modellen generiert werden. Insbesondere bei manuell entwickeltem Code ist es entscheidend, den Code lesbar zu halten und angemessen zu dokumentieren und dabei gute, „sprechende“ sowie systematisch aufgebaute Identifikatoren zu wählen und eine Reihe methodischer Vorgaben einzuhalten, sodass gut strukturierter, leicht verifizierbarer, verständlicher Code entsteht. In diesem Kapitel werden die wesentlichen Aufgaben bei der Implementierung von Software beschrieben. Dies umfasst auch die Richtlinien und Empfehlungen zur Erstellung hochqualitativen Programmcodes und seiner Organisation und Verwaltung in Versionskontrollsystemen. Ferner gewährt dieses Kapitel einen Einblick in die Schritte und Aufgaben in der modellbasierten Softwareentwicklung.
Chapter
Scrum is an agile process that incrementally, iteratively and continuously delivers software based on time boxes (sprints). It comprises user stories stored in product backlogs and delivered through sprints by a Scrum teams consisting of team members, Scrum Master and Product Owner. The performance of a Scrum team is largely dependent on the team members and the technical practices that they adopt. One such practice, pair programming has been studied in a variety of contexts but not extensively in a Scrum context. Pair programming is a technique where two programmers work side by side at one computer to collaborate on the same design, algorithm, code, or test. The use of pair programming within Scrum has not been widely researched. A multi agent system is used to simulate the scrum environment where a team (with varying team members’ capability) work on delivering user stories (which consists of multiple tasks with varying complexities) in multiple sprints. Using this simulated environment, various strategies are investigated. Impact is measured based on the team’s work efficiency, completion time, effort time and idle time. Experiments were carried to test these strategies in varying environments and results showed that a intelligent pairing strategy performed the best in environments as it avoided any negative pairing impacts.
Article
Revealing the failure of agile software projects is a great challenge faced by software companies. This paper focuses on the using of intelligent techniques such as fuzzy logic, multiple linear regressions, support vector machine, neural network to address this challenge. This paper also presents a review of some works related to this area of interest. In this paper, the researchers propose an approach for revealing the failure of agile software projects based on two intelligent techniques: fuzzy logic and multiple linear regressions (MLR). MLR is used to determine crucial failure factors of agile software projects. Fuzzy logic is used for revealing failure of agile software projects.
Chapter
Until recently, collaborative programming in elementary contexts largely involved traditional one-computer pair programming, more commonly used in industry and university settings. This chapter outlines the historical background of traditional pair programming and if and how its use with elementary-aged children holds as much promise. We then explore alternative paradigms, which generally include the addition of a second computer; we call this configuration two-computer pair programming. Harnessing the advances in programming applications that permit synchronized collaboration, we then report on our work with both one- and two-computer pair programming in block-based programming environments. We conclude by providing a summary of student experiences and opinions on the one- and two-computer studies, and a set of actionable guidelines for practitioners who would like to implement these different collaborative paradigms in their elementary computer science lessons and digitally mediated team learning (DMTL) researchers who will develop support features in these types of environments.
Chapter
Scrum is an agile process that incrementally, iteratively and continuously delivers software based on sprints. It is comprised of user stories stored in product backlogs and delivered through sprints by a Scrum team consisting of developers, a Scrum Master and a Product Owner. The performance of a Scrum team is largely dependent on the capabilities of team members and the technical practices they adopt. One such practice, pair programming has been studied in a variety of contexts but not extensively in a Scrum context. Pair programming is a technique where two programmers work side by side to design, code, and test their program.
Article
Full-text available
In order to promote the practice of co-creation, a real-time collaboration (RTC) version of the popular block-based programming (BBP) learning environment, MIT App Inventor (MAI), was proposed and implemented. RTC overcomes challenges related to non-collocated group work, thus lowering barriers to cross-region and multi-user collaborative software development. An empirical study probed into the differential impact on self-efficacy and collaborative behavior of learners in the environment depending upon their disciplinary background. The study serves as an example of the use of learning analytics to explore the frequent behavior patterns of adult learners, in this case specifically while performing BBP in MAI integrated with RTC. This study compares behavior patterns that are collaborative or individual that occurred on the platform, and investigates the effects of collaboration on learners working within the RTC depending on whether they were CS-majors or not. We highlight advantages of the new MAI design during multi-user programming in the online RTC based on the connections between the interface design and BBP as illustrated by two significant behavior patterns found in this instructional experiment. First, the multi-user programming in the RTC allowed multiple tasks to happen at the same time, which promoted engagement in joint behavior. For example, one user arranged components in the interface design while another dragged blocks to complete the program. Second, this study confirmed that the Computer Programming Self-Efficacy (CPSE) was similar for individual and multi-user programming overall. The CPSE of the homogeneous CS-major groups engaged in programming within the RTC was higher than that of the homogeneous non-CS-major groups and heterogeneous groups. There was no significant difference between the CPSE of the homogenous non-CS group and the CPSE of the heterogeneous groups, regardless of whether they were engaged in individual programming or collaborative programming within their groups. The results of the study support the value of engaging with MAI collaboratively, especially for CS-majors, and suggest directions for future work in RTC design.
Conference Paper
View Video Presentation: https://doi.org/10.2514/6.2022-2248.vid The use of geometric models is becoming central in the analysis and design of complex configurations, such as aerospace vehicles. Traditionally these models have been developed by a single engineer, working alone because of the way the modeling tools have been designed. While collaboration is possible via file sharing or screen sharing, none of the traditional design environments facilitate real-time collaboration. A similar problem in software development (programming) has been fixed with the introduction of pair-programming, wherein two programmers sit side by side, and work together. Pair programming has been shown to greatly improve the software development process, while only incurring a small cost penalty. Herein, the pair-programming concepts have been applied to the development of geometric models in the Engineering Sketch Pad. The efficacy of this new approach is demonstrated via two case studies.
Article
his paper describes a qualitative study of how undergraduate students majoring in Information Technology perceive the effectiveness and evaluate the learning experience of pair-programming. The phenomenographic research approach was used to analyze student interviews and revealed 4 categories of descriptions: Effective Problem Solving, Participation, Enjoyment and Coding. Pair-programming as a teaching methodology was commonly perceived as a positive experience. The resulting outcome space maps a logical hierarchy of students’ conceptions of reality (categories of description). Findings of this research identify the factors that affect student engagement in a problem-solving process and can be used as a guiding principle on how to improve students’ learning experience of computer programming.
Conference Paper
Background: Pair programming (PP) can have many benefits in industry. Researchers and practitioners recognize that successful and productive PP involves some skill that might take time to learn and improve. Question: What are the elements of pair programming skill? Method: We perform qualitative analyses of industrial pair programming sessions following the Grounded Theory Methodology. We look for patterns of problematic behavior to conceptualize key elements of what ‘good’ and ‘bad’ pairs do differently. Results: Here, we report two elements of pair programming skill: Good pairs (1) manage to maintain their Togetherness and (2) keep an eye on their session’s Expediency. We identify three problematic behavioral patterns that affect one or both of these elements: Getting Lost in the Weeds, Losing the Partner, and Drowning the Partner. Conclusion: Pair programming skill is separate from general software development skill. Years of PP experience are neither a prerequisite nor sufficient for successful pair programming.
Article
Full-text available
This paper introduces a new approach — Distributed Cognition — to viewing collaborative activities and analyzes a pair of programmers performing a perfective software maintenance task in accordance with this approach. Distributed Cognition takes as its unit of analysis a complex cognitive system: collections of individual and artifacts that participate in the performance of a task. The external structures exchanged by the agents of complex cognitive systems comprise its "mental" state and unlike individual cognition, where mental states are inaccessible, these states are observable and available for direct analysis. Through an analysis of these structures, their trajectories through the system, and their transformations, it will be demonstrated that complex cognitive systems engaged in software development tasks possess cognitive properties distinct from those of individual programmers. These properties are important for the system's successful completion of the task, yet they are ignored in studies of individual programmers. Studies of system level cognitive properties, when combined with existing research on the cognitive properties of individual programmers, should lead to a more comprehensive understanding of the process of software development. Before this integration can be made, however, these system level properties must be uncovered. The following research is a step in this direction.
Article
Full-text available
This article presents a technical opinion in the case of collaborative programming for a large, complex system, in which two programmers are working jointly on the same algorithm and code. A field experiment was conducted using experienced programmers who worked on a challenging problem important to their organization, in their own environments, and with their own equipment. Findings revealed that all the teams outperformed the individual programmers, enjoyed the problem-solving process more, and had greater confidence in their solutions. Several aspects of this experiment make the results significant. First, there may be a tendency to dismiss results using small groups. Questions may arise at the value of these results if the collaborators do not perform twice as well as individuals, at least in the amount of time spent. The article concludes that the crunch-time information systems development will demand innovative ways to produce high-quality systems in a short time, with companies increasingly introducing new products. This rare experimental research is phenomenon considering the luxury of using collaborative programming while many companies are experiencing shortages of experienced programmer/analysts.
Article
Abstract All I Really Need to Know I Learned in Kindergarten By Robert Fulghum (Fulghum 1988) Share everything. Play fair. Don’t hit people. Put things back where you found them. Clean up your own mess. Don’t take things that aren’t yours. Say you’re sorry when,you hurt somebody. Wash your hands before you eat. Flush. Warm cookies and cold milk are good for you. Live a balanced life – learn some,and think some,and draw and paint and sing and
Article
The book, The Mythical Man-Month, Addison-Wesley, 1975 (excerpted in Datamation, December 1974), gathers some of the published data about software engineering and mixes it with the assertion of a lot of personal opinions. In this presentation, the author will list some of the assertions and invite dispute or support from the audience. This is intended as a public discussion of the published book, not a regular paper.
All I Ever Needed to Know About Pair Programming I Learned in Kindergarten The Wisdom of Teams: Creating the High- Performance Organization: Harper Business
  • J O Coplien
  • L A Williams
  • R R Kessler Flor
  • E L Hutchins
J. O. Coplien, " A Development Process Generative Pattern Language, " in Pattern Languages of Program Design, James O. Coplien and Douglas C. Schmidt, Ed. Reading, MA: Addison-Wesley, 1995, pp. 183-237. [4] L. A. Williams and R. R. Kessler, " All I Ever Needed to Know About Pair Programming I Learned in Kindergarten, " in Communications of the ACM, vol. 43, no. 5, 2000. [5] T. DeMarco and T. Lister, Peopleware. New York: Dorset House Publishers, 1977. [6] J. R. Katzenbach and D. K. Smith, The Wisdom of Teams: Creating the High- Performance Organization: Harper Business, 1994. [7] N. V. Flor and E. L. Hutchins, " Analyzing Distributed Cognition in Software Teams: A Case Study of Team Programming During Perfective Software Maintenance, " presented at Empirical Studies of Programmers: Fourth Workshop, 1991. [8]
Pair Programming Questionnaire
  • L Williams
L. Williams, "Pair Programming Questionnaire," http://limes.cs.utah.edu/questionnaire/questionnaire.htm.