Sue Fitzgerald

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.

Computer forensics programs in higher education: a preliminary study

This paper presents a preliminary survey of computer forensics programs in North America. It summarizes existing requirements for associate, bachelors, and masters degree programs as well as certificate programs. It briefly discusses factors which must be considered when introducing a new program (curriculum design, faculty, students, facilities, and budget).

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.

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.

Computer science and IT teachers' conceptions of successful and unsuccessful teaching: A phenomenographic study

In this paper we present the results of a phenomenographic study revealing the conceptions of successful and unsuccessful teaching among information and communication technology, information technology (IT), and computer science academics. We examine ways in which the understandings of IT teachers are similar to or differ from other teachers in domain-specific ways. Our categorizations of successful teaching (feeling successful, good delivery, developing student thinking) correspond to similar findings in the literature. However, our categorizations of unsuccessful teaching are more revealing. Undergraduate IT teachers understand unsuccessful teaching in five ways: teacher lacks skills, teacher lacks organizational support, students do not take responsibility, domain complexity, and students do not demonstrate understanding. These conceptualizations do not directly correspond to the ways in which teachers perceive successful teaching, revealing a gap between idealized notions of teaching and actual teaching in practice. Of specific interest, lack of administrative support in the form of insufficient funding, overloaded lecture hours, and inexperienced teaching assistants emerged as barriers to effective teaching. Equally important, difficulties in dealing with abstraction and complexity specific to IT disciplines have consequences for the way in which IT should be taught. These phenomenographic categories of description are intended to serve as a framework for IT teachers to engage in a process of self-reflection leading to improved teaching practices. We present ways in which the understandings of successful and unsuccessful teaching can aid in this process.

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

The computer science fair: an alternative to the computer programming contest

Dissatisfaction with the results of programming contest events has led to the development of a new type of competitive event, a computer science fair. The computer science fair, a combination art show/science fair, is designed to attract a wider diversity of participants, to encourage creativity, and to reinforce good project development practices. Students are asked to creatively use technology to express themselves, to design new inventions, and to solve problems by submitting projects in the following categories: 1) computers and the arts and humanities --- computer music, computer art, multimedia projects; 2) computer programs --- entertainment, education, scientific, business, modeling and simulation; and 3) computer or electronically controlled inventions. This paper outlines the rules for submissions and judging of projects and the results of the First Annual Kansas City Computer Science Fair. Results based on gender and age category are reported.

Debugging assistance for novices: a video repository

This paper reports on the efforts of an ITiCSE 2007 working group with the aim of producing a publicly available, searchable, tagable, Web 2.0-style repository of short debugging videos. This repository may be accessed from http://debug.csi.muohio.edu/. The videos are aimed at novice Java programmers who may need help debugging when none is available (e.g. in the middle of the night before the homework is due). However, it could also be used by instructors of introductory programming. Here we discuss our motivation in creating this repository and detail the process we followed and the products we produced.