There is growing interest in how we can use computer logging data to improve computational tools and pedagogies to engage children in complex thinking and self-expression, but our techniques lag far behind our theories. Only recently have learning scientists begun to measure, collect, analyze, and report how data informs the science of children's learning. In this paper, we describe our initial efforts towards developing tools to mine computer logging data for information on how to enhance learning opportunities. The data were collected as part of an NSF-funded project, and include logs from 320 middle school students using Alice to program computer games in semester-long courses. We describe some lessons learned and decisions made in the process of reconstructing high-level user actions in Alice from low-level Alice logs.

This paper describes an exploratory study to identify which environmental and student factors best predict intention to persist in the computer science major. The findings can be used to make decisions about initiatives for increasing retention. Eight indices of student characteristics and perceptions were developed using the research-based Student Experience of the Major Survey: student-student interaction; student-faculty interaction; collaborative learning opportunities; pace/workload/prior experience with programming; teaching assistants; classroom climate/pedagogy; meaningful assignments; and racism/sexism. A linear regression revealed that student-student interaction was the most powerful predictor of students' intention to persist in the major beyond the introductory course. Other factors predicting intention to persist were pace/workload/prior experience and male gender. The findings suggest that computer science departments interested in increasing retention of students set structured expectations for student-student interaction in ways that integrate peer involvement as a mainstream activity rather than making it optional or extracurricular. They also suggest departments find ways to manage programming experience gaps 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.

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 women's 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.

This study examined the effectiveness of pair programming in four lecture sections of a large introductory programming course. We were particularly interested in assessing how the use of pair programming affects student performance and decisions to pursue computer science related majors. We found that students who used pair programming produced better programs, were more confident in their solutions, and enjoyed completing the assignments more than students who programmed alone. Moreover, pairing students were significantly more likely than non-pairing students to complete the course, and consequently to pass it. Among those who completed the course, pairers performed as well on the final exam as non-pairers, were significantly more likely to be registered as computer science related majors one year later, and to have taken subsequent programming courses. Our findings suggest that not only does pairing not compromise students' learning, but that it may enhance the quality of their programs and encourage them to pursue computer science degrees.

Undergraduate freshman programming classes are conventionally organized such that individual students complete a set of concept-specific and unrelated programming assignments. This structure does not prepare students for future collaborative efforts or for the future use of software engineering practices. The addition of pair programming into a freshman programming class at the University of California at Santa Cruz (UCSC) showed similar benefits to similar studies on upper-division software classes, and is expected to show an improvement in students' willingness and ability to participate in complex, collaborative software engineering assignments in later classes. This paper describes the implementation of the pair programming experiment at UCSC, discusses some of the issues that compromised the effectiveness of certain pairs, and provides implementation guidelines for avoiding such issues in other classes.

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.

Synchronous languages are intended for programming reactive systems. Reactive systems, which include real-time systems and key operating system components, interact continually with their environment. This paper considers the applicability of imperative synchronous/reactive languages to the development of general system software, that is, to the implementation of operating system kernels, file systems, databases, networks, server architectures, device drivers, etc. The languages Esterel and Reactive C (RC) receive special attention as Esterel is the oldest and most developed such language and RC is specifically designed for compatibility with C systems programming. An alternative soft-instruction software architecture is described, which is well suited to real-world system programming. © 1997 by John Wiley & Sons, Ltd.

When attempting to debug optimized programs, most debuggers may give misleading information about the value of variables at breakpoints.Hennessy proposed a set of algorithms for generating optimized code and determining when, in the generated code, the reported values would be misleading-and under certain circumstances actually recovering the "expected" value of the variable (i.e., one that would not be misleading).We point out where the assumptions made by Hennessy need to be revised due to advances in compiler and debugger technology, and give references for current work on this revised problem.

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.>

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.>

A low-level parallel processor (LLPP) is one in which two or more machine-level operations are executed in parallel. This paper analyzes the use of linearly connected LLPP's for parallel evaluation of program fragments. A graph-theoretic model is presented which describes the communication constraints of linearly connected parallel processors. A tight, necessary condition for finding assignments of program fragments to linearly connected LLPP's that require no communication delays is presented. Also, several weak sufficient conditions have been found and efficient heuristics for determining optimal assignments have been developed.