Charles E. McDowell

The effects of pair-programming on performance in an introductory programming course

The purpose of this study was to investigate the effects of pair-programming on student performance in an introductory programming class. Data was collected from approximately 600 students who either completed programming assignments with a partner or programmed independently. Students who programmed in pairs produced better programs, completed the course at higher rates, and performed about as well on the final exam as students who programmed independently. Our findings suggest that collaboration is an effective pedagogical tool for teaching introductory programming.

Pair programming improves student retention, confidence, and program quality

Pair programming produces more proficient, confident programmers---and may help increase female representation in the field.

Pair-programming helps female computer science students

Pair-programming has been found to be very beneficial in educational settings. Students who pair in their introductory programming course are more confident, have greater course completion and pass rates, and are more likely to persist in computer-related majors. Although pairing helps all students, we believe that it is particularly beneficial for women because it addresses several significant factors that limit womens participation in computer science. We provide reasons for our belief that pair-programming helps women persist in these majors. We also repeat, with special emphasis on the impact on women, some details published elsewhere regarding our experiments on pair-programming with college and university students. Additionally, we provide new data that supports our original findings.

Building pair programming knowledge through a family of experiments

Pair programming is a practice in which two programmers work collaboratively at one computer on the same design, algorithm, code, or test. Pair programming is becoming increasingly popular in industry and in university curricula. A family of experiments was run with over 1200 students at two US universities, North Carolina State University and the University of California Santa Cruz, to assess the efficacy of pair programming as an alternative learning technique in introductory programming courses. Students who used the pair programming technique were at least as likely to complete the introductory course with a grade of C or better when compared with students who used the solo programming technique. Paired students earned exam and project scores equal to or better than solo students. Paired students had a positive attitude toward collaboration and were significantly more likely to be registered as computer science-related majors one year later. Our findings also suggest that students in paired classes continue to be successful in subsequent programming classes continue to be successful in subsequent programming classes that require solo programming.

Program quality with pair programming in CS1

Prior research on pair programming has found that compared to students who work alone, students who pair have shown increased confidence in their work, greater success in CS1, and greater retention in computer-related majors. In these earlier studies, pairing and solo students were not given the same programming assignments. This paper reports on a study in which this factor was controlled by giving the same programming assignments to pairing and solo students. We found that pairing students were more likely to turn in working programs, and these programs correctly implemented more required features. Our findings were mixed when we looked at some standard complexity measures of programs. An unexpected but significant finding was that pairing students were more likely to submit solutions to their programming assignments.

Experimenting with pair programming in the classroom

There is now a substantial body of evidence in support of the use of pair programming in the classroom[3, 4, 10, 11, 13, 14]. Some of the data is anecdotal and some is the result of formal experiments. We are not aware of any published data that raises concerns about allowing students to complete programming projects using pair programming.In this paper we present data from three studies performed at UCSC. All three studies support the position that pair programming results in more student learning.

Modelling speedup (n) greater than n

A simple model of parallel computation which is capable of explaining speedups greater than n on n processors is presented. Necessary and sufficient conditions for these exceptional speedups are derived from the model. Several of the contradictory previous results relating to parallel speedup are resolved by using the model. >

Success in introductory programming: what works?

How pair programming, peer instruction, and media computation have improved computer science education.

A practical algorithm for static analysis of parallel programs

Abstract One approach to analyzing the behavior of a concurrent program requires determining the reachable program states. A program state consists of a set of task states, the values of shared variables used for synchronization, and local variables that derive the values directly from synchronization operations. However, the number of reachable states rises exponentially with the number of tasks and becomes intractable for many concurrent programs. A variation of this approach merges a set of related states into a single virtual state . Using this approach, the analysis of concurrent programs becomes feasible as the number of virtual states is often orders of magnitude less than the number of reachable states. This paper presents a method for determining the virtual states that describe the reachable program states, and the reduction in the number of states is analyzed. The algorithms given have been implemented in a static program analyzer for multitasking Fortran, and the results obtained are discussed.

Determining possible event orders by analyzing sequential traces

One of the fundamental problems encountered when debugging a parallel program is determining the possible orders in which events could have occurred. Various problems, such as data races and intermittent deadlock, arise when there is insufficient synchronization between the tasks in a parallel program. A sequential trace of an execution can be misleading, as it implies additional event orderings, distorting the concurrent nature of the computation. Algorithms to generate, from the trace of an execution, those event orderings that can be relied on by the programmer are described. By its very nature, the information in an execution trace pertains only to that execution of the program, and may not generalize to other executions. This difficulty is mitigated by defining an inferred program based on the trace and original program, analyzing this inferred program, and showing how the inferred program relates to the original. The results of the algorithms can be used by other automated tools such as a data race detector or constraint checker. >