Debugging is a core skill required by programmers, yet we know little about how to effectively teach the process of debugging. The challenges of learning debugging are compounded for novices who lack experience and are still learning the tools they need to program effectively. In this work, we report a case study in which we used a think-aloud protocol to gain insight into the behaviour of three students engaged in debugging tasks. Our qualitative analysis reveals a variety of helpful practices and barriers that limit the effectiveness of debugging. We observe that comprehension, evidence-based activities, and workflow practices all contribute to novice debugging success. Lack of sustained effort, precision, and methodical processes negatively impact debugging effectiveness. We anticipate that understanding how students engage in debugging tasks will aid future work to address ineffective behaviours and promote effective debugging activities.

Background and Context. Metacognitive skills are important for all students learning to program and interest in applying pedagogical approaches in early programming courses that focus on metacognitive aspects is growing. However, most studies of such approaches are not rigorously based in theory, and when they are, almost always utilize foundational education and psychology theories from as far back as the 1970s. More recent theory is less tested, and not all relevant metacognitive theories have been explored in the computing education research literature.

How students are assessed has a powerful effect on their strategies for studying and their learning. When designing assessments, instructors should consider how different approaches for providing feedback to students could encourage positive learning behaviours. One such design is the use of interim deadlines that enable students to receive and respond to feedback. This is used to encourage students to start early and thus reduce the negative effects of procrastination. If multiple submissions are allowed, penalty schemes can be included to encourage students to reflect deeply on the feedback they receive, rather than developing an over-reliance on autograders. In this work we describe two approaches to feedback used over two consecutive semesters for a final project in a large introductory programming course. In both semesters, the complexity and structure of the final project was similar and students received identical instruction. In the first instance of the course students could submit their work prior to two scheduled interim deadlines, after which they would receive automated feedback, before meeting a final third deadline. In the second instance, students received automated feedback immediately upon submission but with increasing penalties to discourage excessive submissions. In both cases, the ability to receive automated feedback -- both scheduled and immediate -- was designed to encourage early participation with the project. Under the two feedback schemes, we observed different patterns of behaviour -- particularly for the lower performing students. We explore the benefits and drawbacks of the two schemes and consider implications for future project grading.

As computing students progress through their studies they become proficient with multiple programming languages. Prior work investigating language transitions for novices has tended to analyze program artifacts rather than explore the benefits and difficulties as perceived by students in their own words, and has often overlooked problems that may arise in switching paradigms or where familiar syntax has a different meaning in the new language. In this paper, we ask students to reflect on the transition from an interpreted language and environment (MATLAB) to a compiled language (C), prompting comments on the aspects of learning the new language that they found both easier and harder. Analysis of over 70,000 words written by 771 students revealed that the highest-performing students expressed more negative sentiments towards the language transition -- a surprising result that we hypothesize is explained by their generally stronger metacognitive skills. We also report the most common difficulties described by students, which include challenges with syntax, error messages, and the process of compilation, and suggest teaching practices that might help students as they transition to a new programming language.

The computing education community is growing, but there is little information about the geographic distribution of the community or collaboration between members. Our research investigates three computer science education conferences (SIGCSE Technical Symposium, ITiCSE and ICER) by analysing authorship and affiliation details for publications in the proceedings over the lifetime of the respective conferences, totalling over 4500 publications. We examine the geographic location of authors and model the scientific collaboration network of each conference. We conclude that the community is open to newcomers, and both the number of authors, and the overall level of collaboration is growing.

Despite decades of literature calling for research on teaching debugging, we still lack clear guidelines on how to teach debugging processes effectively. This is a significant problem as debugging is an activity that is a key component of software development and a frustrating and time-consuming barrier to students who are learning to program. In this paper we reflect on teaching and learning debugging through the lens of student beliefs about their own debugging practice. We find that few students use systematic approaches such as the scientific method of hypothesis generation and testing that is informally adopted by many software developers. Some students appeared to be satisfied with their ad hoc approaches while others expressed a desire to develop more thorough approaches.

Current CS1 learning outcomes are relatively general, specifying tasks such as designing, implementing, testing and debugging programs that use some fundamental programming constructs. These outcomes impact what we teach, our expectations, and our assessments. Although prior work has demonstrated the utility of single concept assessments, most assessments used in formal examinations combine numerous heterogeneous concepts, resulting in complex and difficult tasks.

This paper presents part of a larger long term study into the cognitive aspects of the early stages of learning to write computer programs Tasks designed to trigger learning events were used to provide the opportunity to observe student learning, in terms of the development and modification of cognitive structures or schemata, during think aloud sessions. A narrative analysis of six students' attempts to solve these tasks is presented. The students' progression in learning and attitudinal approaches to learning is examined and provides some insight into the cognitive processes involved in learning computer programming.

This paper presents an audio classification system that provides improved accuracy, robustness and flexibility over reported content-based audio classification methods. The system reads an input audio file, performs segmentation and classification of the composite sounds contained within the file and, for each sound clip, determines the most plausible matching class of audio in the database. Improvements in the accuracy of audio classification are largely due to the partitioning of the input audio file into homogeneous segments while the incorporation of new class detection offers greater flexibility of use.

This paper presents a model-free and training-free two-phase method for audio segmentation that separates monophonic heterogeneous audio files into acoustically homogeneous regions where each region contains a single sound. A rough segmentation separates audio input into audio clips based on silence detection in the time domain. Then a self-similarity matrix, based on selected audio features in the frequency domain to discover the level of similarity between frames in the audio clip, is calculated. Subsequently an edge detection method is used to find regions in the similarity image that determine plausible sounds in the audio clip. The results of the two phases are combined to form the final boundaries for the input audio. This two-phase method is evaluated using established methods and a standard non-musical database. The method reported here offers more accurate segmentation results than existing methods for audio segmentation. We propose that this approach could be adapted as an efficient preprocessing stage in other audio processing systems such as audio retrieval, classification, music analysis and summarization.

This paper extends the work of the BRACElet project [17] by assessing the program comprehension skills of intermediate level students. Student performance on a pathfinder algorithm simulation task is reviewed to assess the students' comprehension levels, as categorized according to the SOLO educational taxonomy. The paper describes the nature of student responses, and the variety of representations provided, illustrating the role of discovery in effective student learning.

SUMMARY: A phenotypic character has a convex mapping to a given phylogenetic tree if each character state can be assigned a single point of origin in the tree. However, phenomena such as convergent evolution and lateral genetic transfer can lead to intermingling of character states and a consequent non-convex mapping. The phylogenetic heterogeneity of different characters can identify subsets of states that are non-randomly associated or which may have been transferred from one lineage to another. We have developed Radié, an interactive 3D Java application for mapping character states to the leaves and internal edges of a radial phylogenetic tree. In Radié each state of a given character is associated with a unique color, and internal edges with many descendant character states can be represented in a number of different ways to illustrate the diversity within each group. AVAILABILITY: Radié is freely available for download at http://kiwi.cs.dal.ca/~beiko/software-and-data/radie; source code is available upon request from the authors.

This study analyzed student responses to an examination, after the students had completed one semester of instruction in programming. The performance of students on code tracing tasks correlated with their performance on code writing tasks. A correlation was also found between performance on "explain in plain English" tasks and code writing. A stepwise regression, with performance on code writing as the dependent variable, was used to construct a path diagram. The diagram suggests the possibility of a hierarchy of programming related tasks. Knowledge of programming constructs forms the bottom of the hierarchy, with "explain in English", Parson's puzzles, and the tracing of iterative code forming one or more intermediate levels in the hierarchy.

This paper explores the programming knowledge of novices using Biggs' SOLO taxonomy. It builds on previous work of Lister et al. (2006) and addresses some of the criticisms of that work. The research was conducted by studying the exam scripts for 120 introductory programming students, in which three specific questions were analyzed using the SOLO taxonomy. The study reports the following four findings: when the instruction to students used by Lister et al. - "In plain English, explain what the following segment of Java code does" - is replaced with a less ambiguous instruction, many students still provide multistructural responses; students are relatively consistent in the SOLO level of their answers; student responses on SOLO reading tasks correlate positively with performance on writing tasks; postgraduates students manifest a higher level of thinking than undergraduates.

This paper reports on the authors use of the SOLO taxonomy to describe differences in the way students and educators solve small code reading exercises. SOLO is a general educational taxonomy, and has not previously been applied to the study of how novice programmers manifest their understanding of code. Data was collected in the form of written and think-aloud responses from students (novices) and educators (experts), using exam questions. During analysis, the responses were mapped to the different levels of the SOLO taxonomy. From think-aloud responses, the authors found that educators tended to manifest a SOLO relational response on small reading problems, whereas students tended to manifest a multistructural response. These results are consistent with the literature on the psychology of programming, but the work in this paper extends on these findings by analyzing the design of exam questions.