Amjad Altadmri

37 Million Compilations: Investigating Novice Programming Mistakes in Large-Scale Student Data

Previous investigations of student errors have typically focused on samples of hundreds of students at individual institutions. This work uses a years worth of compilation events from over 250,000 students all over the world, taken from the large Blackbox data set. We analyze the frequency, time-to-fix, and spread of errors among users, showing how these factors inter-relate, in addition to their development over the course of the year. These results can inform the design of courses, textbooks and also tools to target the most frequent (or hardest to fix) errors.

Frame-Based Editing: Easing the Transition from Blocks to Text-Based Programming

Block-based programming systems, such as Scratch or Alice, are the most popular environments for introducing young children to programming. However, mastery of text-based programming continues to be the educational goal for students who continue to program into their teenage years and beyond. Transitioning across the significant gap between the two editing styles presents a difficult challenge in school-level teaching of programming. We propose a new style of program manipulation to bridge the gap: frame-based editing. Frame-based editing has the resistance to errors and approachability of block-based programming while retaining the flexibility and more conventional programming semantics of text-based programming languages. In this paper, we analyse the issues involved in the transition from blocks to text and argue that they can be overcome by using frame-based editing as an intermediate step. A design and implementation of a frame-based editor is provided.

Frame-Based Editing: Combining the Best of Blocks and Text Programming

Editing program code as text has several major weaknesses: syntax errors (such as mismatched braces) interrupt programmer flow and make automated tool support harder, boilerplate code templates have to be typed out, and programmers are responsible for layout. These issues have been known about for decades, but early attempts to address these issues, in the form of structured editors, produced unwieldy, hard-to-use tools which failed to catch on. Recently, however, block-based editors in education like Scratch and Snap! have demonstrated that modern graphical structured editors can provide great benefits for programming novices, including very young age groups. These editors become cumbersome for more advanced users, due to their unbending focus on mouse input for block creation and manipulation, and poor scaling of navigation and manipulation facilities to larger programs. Thus, after a few years, learners tend to move from Scratch to text-based editing. In this paper, we present the design and implementation of a novel way to edit programs: frame-based editing. Frame-based editing improves text-based editing by incorporating techniques from block-based editing, and thus provides a suitable follow-on from tools like Scratch. Frame-based editing retains the easy navigation and clearer display of textual code to support manipulation of complex programs, but fuses this with some of the structured editing capabilities that block programming has shown to be viable. The resulting system combines the advantages of text and structured blocks. Preliminary experiments suggest that frame-based editing enables faster program entry than blocks or text, while resulting in fewer syntax errors. We believe it provides an interesting future direction for program editing for learners at all levels of proficiency.

Novice Java Programming Mistakes: Large-Scale Data vs. Educator Beliefs

Teaching is the process of conveying knowledge and skills to learners. It involves preventing misunderstandings or correcting misconceptions that learners have acquired. Thus, effective teaching relies on solid knowledge of the discipline, but also a good grasp of where learners are likely to trip up or misunderstand. In programming, there is much opportunity for misunderstanding, and the penalties are harsh: failing to produce the correct syntax for a program, for example, can completely prevent any progress in learning how to program. Because programming is inherently computer-based, we have an opportunity to automatically observe programming behaviour -- more closely even than an educator in the room at the time. By observing students’ programming behaviour, and surveying educators, we can ask: do educators have an accurate understanding of the mistakes that students are likely to make? In this study, we combined two years of the Blackbox dataset (with more than 900 thousand users and almost 100 million compilation events) with a survey of 76 educators to investigate which mistakes students make while learning to program Java, and whether the educators could make an accurate estimate of which mistakes were most common. We find that educators’ estimates do not agree with one another or the student data, and discuss the implications of these results.

Frame-Based Editing

In introductory programming teaching, block-based editors have become very popular because they offer a number of strong advantages for beginning programmers: They avoid many syntax errors, can display all available instructions for visual selection and encourage experimentation with little requirement for recall. Among proficient programmers, however, text-based systems are strongly preferred due to several usability and productivity advantages for expert users. In this paper, we provide a comprehensive introduction to a novel editing paradigm, frame-based editing – including design, implementation, experimentation and analysis. We describe how the design of this paradigm combines many advantages of block-based and text-based systems, then we present and discuss an implementation of such a system for a new Java-like language called Stride, including the results of several evaluation studies. The resulting editing system has clear advantages for both novices and expert programmers: It improves program representation and error avoidance for beginners and can speed up program manipulation for experts. Stride can also serve as an ideal stepping stone from block-based to text-based languages in an educational context.

The Cost of Syntax and How to Avoid It: Text versus Frame-Based Editing

Plain text has always been the predominant medium for writing and editing programs for expert users. Text is powerful and flexible, but requires more careful manipulation than structural editors, such as those found in block-based environments. In addition, in textual editors programmers are responsible for managing detailed orthography and layout - when beginners work with text, significant time is spent managing syntax problems, indentation and spacing. Frame-based editing is a new editing paradigm that combines the structural editing of block-based systems with the flexibility and keyboard-focus of text editing. In this paper, we empirically examine how much time and effort is spent by beginners on managing syntax errors and indentation, which can be automatically saved by switching to frame-based editing. The data is obtained using the Blackbox dataset, the results predict a clear advantage of frame-based editing over traditional text editors.

Compressed video matching: Frame-to-frame revisited

This paper presents an improved frame-to-frame (F-2-F) compressed video matching technique based on local features extracted from reduced size images, in contrast with previous F-2-F techniques that utilized global features extracted from full size frames. The revised technique addresses both accuracy and computational cost issues of the traditional F-2-F approach. Accuracy is improved through using local features, while computational cost issue is addressed through extracting those local features from reduced size images. For compressed videos, the DC-image sequence, without full decompression, is used. Utilizing such small size images (DC-images) as a base for the proposed work is important, as it pushes the traditional F-2-F from off-line to real-time operational mode. The proposed technique involves addressing an important problem: namely the extraction of enough local features from such a small size images to achieve robust matching. The relevant arguments and supporting evidences for the proposed technique are presented. Experimental results and evaluation, on multiple challenging datasets, show considerable computational time improvements for the proposed technique accompanied by a comparable or higher accuracy than state-of-the-art related techniques.

Blackbox, Five Years On: An Evaluation of a Large-scale Programming Data Collection Project

The Blackbox project has been collecting programming activity data from users of BlueJ (a novice-targeted Java development environment) for nearly five years. The resulting dataset of more than two terabytes of data has been made available to interested researchers from the outset. In this paper, we assess the impact of the Blackbox project: we perform a mapping study to assess eighteen publications which have made use of the Blackbox data, and we report on the advantages and difficulties experienced by researchers working with this data, collected via a survey. We find that Blackbox has enabled pieces of research which otherwise would not have been possible, but there remain technical challenges in the analysis. Some of these -- but not all -- relate to the scale of the data. We provide suggestions for the future use of Blackbox, and reflections on the role of such data collection projects in programming research.

Building on Blocks: Getting Started With Frames in Greenfoot 3 (Abstract Only)

Blocks-based programming has become a very popular technology for teaching introductory programming in schools, but it still faces some issues as learners progress. The large transition gap between blocks-based and text-based programming is a source of worry for many educators. However, the difficulties learners have with developing and maintaining progressively larger and more complex programs in block-based systems force teachers to move students on to text-based systems rather than remain with blocks. Greenfoot 3 introduces frame-based programming, a hybrid of blocks-based and text-based programming. Frame-based programming adds comprehensive keyboard support, along with several other usability improvements aimed at removing frustrations for intermediate and experienced programmers, while also providing a way to fill the gap in the transition process. This workshop will show how to teach introductory programming using the new frame-based editor from Greenfoot 3. We will help the participants to explore the new editor in a hands-on session, accompanied by explanations of its distinctive features and how they have been designed to overcome the friction and niggles present in current blocks-based editors, while also providing pedagogical guidance for learners. Participants should bring their own laptop with the latest version of Greenfoot installed, available from www.greenfoot.org