Renée McCauley

Debugging: a review of the literature from an educational perspective

This paper reviews the literature related to the learning and teaching of debugging computer programs. Debugging is an important skill that continues to be both difficult for novice programmers to learn and challenging for computer science educators to teach. These challenges persist despite a wealth of important research on the subject dating back as far as the mid 1970s. Although the tools and languages novices use for writing programs today are notably different from those employed decades earlier, the basic problem-solving and pragmatic skills necessary to debug them effectively are largely similar. Hence, an understanding of the previous work on debugging can offer computer science educators insights into how to improve contemporary learning and teaching of debugging and may suggest directions for future research into this important area. This overview of the debugging literature is organized around four questions relevant to computer science educators and education researchers: What causes bugs to occur? What types of bugs occur? What is the debugging process? How can we improve the learning and teaching of debugging? We conclude with suggestions on using the existing literature both to facilitate pedagogical improvements to debugging education and to offer guidance for future research.

Debugging: finding, fixing and flailing, a multi-institutional study of novice debuggers

Debugging is often difficult and frustrating for novices. Yet because students typically debug outside the classroom and often in isolation, instructors rarely have the opportunity to closely observe students while they debug. This paper describes the details of an exploratory study of the debugging skills and behaviors of contemporary novice Java programmers. Based on a modified replication of Katz and Andersons study of novices, we sought to broadly survey the modern landscape of novice debugging abilities. As such, this study reports general quantitative results and fills in the picture with qualitative detail from a relatively small, but varied sample. Comprehensive interviews involving both a programming and a debugging task, followed by a semi-structured interview and a questionnaire, were conducted with 21 CS2 students at seven colleges and universities. While many subjects successfully debugged a representative set of typical CS1 bugs, there was a great deal of variation in their success at the programming and debugging tasks. Most of the students who were good debuggers were good novice programmers, although not all of the good programmers were successful at debugging. Students employed a variety of strategies to find 70% of all bugs and of the bugs they found they were able to fix 97% of them. They had the most difficulty with malformed statements, such as arithmetic errors and incorrect loop conditions. Our results confirm many findings from previous studies (some quite old) – most notably that once students find bugs, they can fix them. However, the results also suggest that some changes have occurred in the student population, particularly an increased use of debugging tools and online resources, as well as the use of pattern matching, which has not previously been reported.

An undergraduate degree in data science: curriculum and a decade of implementation experience

We describe Data Science, a four-year undergraduate program in predictive analytics, machine learning, and data mining implemented at the College of Charleston, Charleston, South Carolina, USA. We present a ten-year status report detailing the programs origins, successes, and challenges. Our experience demonstrates that education and training for big data concepts are possible and practical at the undergraduate level. The development of this program parallels the growing demand for finding utility in data sets and streaming data. The curriculum is a seventy-seven credit-hour program that has been successfully implemented in a liberal arts and sciences institution by the faculties of computer science and mathematics.

Pair programming in education: a literature review

This article provides a review of educational research literature focused on pair programming in the undergraduate computer science curriculum. Research suggests that the benefits of pair programming include increased success rates in introductory courses, increased retention in the major, higher quality software, higher student confidence in solutions, and improvement in learning outcomes. Moreover, there is some evidence that women, in particular, benefit from pair programming. The literature also provides evidence that the transition from paired to solo programming is easy for students. The greatest challenges for paired students appear to concern scheduling and partner compatibility. This review also considers practical issues such as assigning partners, teaching students to work in pairs, and assessing individual contributions, and concludes with a discussion of open research questions.

Strategies for effective integration of software engineering concepts and techniques into the undergraduate computer science curriculum

This paper discusses various strategies for introducing and reinforcing software engineering principles in the undergraduate Computer Science curriculum. These strategies are based on a set of standards for internal/external documentation and organization of software which may be implemented quickly and inexpensively without a complete overhaul of courses. This provides a flexible framework for the development of a wide variety of carefully-planned programming assignments/projects.

Debugging From the Student Perspective

Learning to debug is a difficult, yet essential, aspect of learning to program. Students in this multi-institutional study report that finding bugs is harder than fixing them. They use a wide variety of debugging strategies, some of them unexpected. Time spent on understanding the problem can be effective. Pattern matching, particularly at the syntactic level, is an important technique for beginners. The Web has emerged as an obvious first place to look for similar examples. Lack of Web materials at an appropriate beginner level leads to flailing. Hypothesizing about the cause of bugs is an underdeveloped skill.

Studying the Use of Peer Learning in the Introductory Computer Science Curriculum

This paper reports the results of studying the use of peer learning in the introductory computer science curriculum. The project involves educators from a variety of institutions who participated in two summer workshops and either introduced or continued their use of peer learning at their institutions as part of this project. The results of the collective work include much experience with different types of peer learning in different settings. Overall, the results indicate that peer learning is a valuable technique that should be used as one pedagogical approach in teaching the introductory computer science curriculum.

'explain in plain english' questions revisited: data structures problems

Recent studies have linked the ability of novice (CS1) programmers to read and explain code with their ability to write code. This study extends earlier work by asking CS2 students to explain object-oriented data structures problems that involve recursion. Results show a strong correlation between ability to explain code at an abstract level and performance on code writing and code reading test problems for these object-oriented data structures problems. The authors postulate that there is a common set of skills concerned with reasoning about programs that explains the correlation between writing code and explaining code. The authors suggest that an overly exclusive emphasis on code writing may be detrimental to learning to program. Non-code writing learning activities (e.g., reading and explaining code) are likely to improve student ability to reason about code and, by extension, improve student ability to write code. A judicious mix of code-writing and code-reading activities is recommended.

Teaching and Learning Recursive Programming: A Review of the Research Literature.

Hundreds of articles have been published on the topics of teaching and learning recursion, yet fewer than 50 of them have published research results. This article surveys the computing education research literature and presents findings on challenges students encounter in learning recursion, mental models students develop as they learn recursion, and best practices in introducing recursion. Effective strategies for introducing the topic include using different contexts such as recurrence relations, programming examples, fractal images, and a description of how recursive methods are processed using a call stack. Several studies compared the efficacy of introducing iteration before recursion and vice versa. The paper concludes with suggestions for future research into how students learn and understand recursion, including a look at the possible impact of instructor attitude and newer pedagogies.

Teaching software engineering early: experiences and results

In the fall of 1994 we reorganized the content of our three-course computer science introductory sequence in order to introduce software engineering concepts early and provide a consistent software engineering focus from one course to the next. We also established documentation and design standards that would serve as a framework for teaching the software engineering principles and techniques that we considered appropriate and essential to novice software developers. In an attempt to assess the impact of this new teaching process, we compared the performances in upper-level project-oriented courses of students who had been exposed to the new introductory sequence to those of students who had not. This paper describes the documentation and design standards established in 1994, their evolution over the past four years, and how these standards can be used as a framework for teaching software engineering concepts early in the curriculum. It also reports on what we have learned through tracking our students. We found that, in three upper-level courses, project grades for students exposed to software engineering concepts early averaged as much as half a letter grade higher than those of other students.