Publisher Copyright: © 2025 Copyright held by the owner/author(s).

Teachers who are aware of potential student misconceptions teach better than teachers who do not. In this article, we focus on misconceptions in the context of teaching and learning graph algorithms: we seek to discover student misconceptions about Dijkstra’s shortest-path algorithm and related concepts. We observed and interviewed fourteen students who worked on a visual simulation task involving the algorithm; we qualitatively analyzed these data to explore the students’ mistakes and their underlying reasons. We find, among other things, that students conflate concepts such as spanning tree, fringe, and priority queue and that students may neglect the greedy and dynamic-programming aspects of the algorithm; we also identify usability issues in the visualization tool we employed. These findings suggest that teachers and tool designers need to take great care to help students tease apart the key concepts in graph algorithms.

Students are able to produce correctly functioning program code even though they have a fragile understanding of how it actually works. Questions derived automatically from individual exercise submissions (QLC) can probe if and how well the students understand the structure and logic of the code they just created. Prior research studied this approach in the context of the first programming course. We replicate the study on a follow-up programming course for engineering students which contains a recap of general concepts in CS1. The task was the classic rainfall problem which was solved by 90% of the students. The QLCs generated from each passing submission were kept intentionally simple, yet 27% of the students failed in at least one of them. Students who struggled with questions about their own program logic had a lower median for overall course points than students who answered correctly.

The modality effect in multimedia learning suggests that pictures are best accompanied by audio explanations rather than text, but this finding has not been replicated in computing education. We investigate which instructional modality works best as an accompaniment for algorithm visualizations. In a randomized controlled trial, learners were split into three conditions who viewed an instructional video on Dijkstra’s algorithm, with diagrams accompanied by audio, text, or both. We find neither a modality effect in favor of the audio condition nor a verbal redundancy effect in favor of using only a single modality rather than both. Taken together with earlier research, our findings suggest that the modality effect is difficult to apply reliably and computing educators should not rush to integrate audio into visualizations in expectation of the effect. We discuss theoretical viewpoints that future research should attend to; these include alternative part-explanations of the modality effect and attention-based models of working memory, among others.

Visual algorithm simulation (VAS) is a method used in teaching data structures and algorithms. In a VAS exercise a learner simulates the steps of an algorithm by interacting with data structure visualisations and receives feedback on the correctness of steps taken. A data format for storing VAS simulation traces would allow for later inspection of the process by instructors and researchers. In this study we describe the development of a prototype language for this purpose. The initial version was tested in a research project where the language was used for recording traces, which were later analyzed. The results were positive but also instructed some revisions in the data format and the requirements. We describe an iterative development process for extending and improving the language and the tooling. This is a work in progress: we will proceed with the data format specification, as well as further develop the technologies needed to use the data format in conjunction with VAS exercises.

Students often struggle with advanced computing courses, and comparatively few studies have looked into the reasons for this. It seems that learners do not master the most basic concepts, or forget them between courses. If so, remedial practice could improve learning, but instructors rightly will not use scarce time for this without strong evidence. Based on personal observation, program tracing seems to be an important pre-requisite skill, but there is yet little research that provides evidence for this observation. To investigate this, our group will create theory-based assessments on how tracing knowledge affects learning of advanced topics, such as data structures, algorithms, and concurrency. This working group will identify relevant concepts in advanced courses, then conceptually analyze their pre-requisites and where an imagined student with some tracing difficulties would encounter barriers. The group will use this theory to create instructor-usable assessments for advanced topics that also identify issues caused by poor pre-requisite knowledge. These assessments may then be used at the start and end of advanced courses to evaluate to what extent students' difficulties with the advanced course originate from poor pre-requisite knowledge.

This study discusses the integration of digital storytelling and the narrative approach into a University level Computer Science course. The pedagogical intervention took place on a project basis. The plan involved student work in groups for the production of digital stories in three phases, including an abstract, a manuscript and a final story. The overall instructional design included workshops and lectures, online tutorials, and group work. The students were assigned to explore the topic of recursion. Face-to-face meetings for the coordination of group work were emphasized during lectures, workshops and project instructions.

No abstract available.

editorial Free Access Share on Unlocking the Potential of Learning Analytics in Computing Education Authors: Shuchi Grover SRI International SRI InternationalView Profile , Ari Korhonen Aalto University Aalto UniversityView Profile Authors Info & Claims ACM Transactions on Computing EducationVolume 17Issue 3September 2017 Article No.: 11epp 1–4https://doi.org/10.1145/3122773Published:28 August 2017Publication History 4citation670DownloadsMetricsTotal Citations4Total Downloads670Last 12 Months64Last 6 weeks5 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF

Visual algorithm simulation (VAS) is an activity in which students practice their understanding of algorithms: They simulate the steps of an algorithm by manipulating a bespoke visualization within a supporting software system. Multiple instances of a VAS exercise may be automatically generated for different learners or for repetitive practice by a single learner. In this work-in-progress report, we discuss how misconceptions might be automatically detected in students' solutions to VAS exercises and how misconception-aware feedback might be provided in VAS. We identify two strategies for producing multiple instances of VAS exercises and evaluate them against several criteria. The tradeoffs so identified are also pertinent for similar process-simulation practice beyond VAS and computing education.

We analyze the Computing Education Research (CER) literature to discover what theories, conceptual models and frameworks recent CER builds on. This gives rise to a broad understanding of the theoretical basis of CER that is useful for researchers working in that area, and has the potential to help CER develop its own identity as an independent field of study.

Achievement badges are increasingly used to enhance educational systems and they have been shown to affect student behavior in different ways. However, details on best practices and effective concepts to implement badges from a non-technical point of view are scarce. We implemented badges to our learning management system, used them on a large course and collected feedback from students. Based on our experiences, we present recommendations to other educators that plan on using badges.

Program comprehension (PC) is a research field that has been extensively studied from different points of view, including human program understanding and mental models, automated program understanding, etc. In this paper, we discuss algorithm recognition (AR) as a subfield of PC and explain their relationship. We present a method for automatic AR from Java source code. The method is based on static analysis of program code including various statistics of language constructs, software metrics, as well as analysis of roles of variables in the target program. In the first phase of the method, a number of different implementations of the supported algorithms are analyzed and stored in the knowledge base of the system as learning data, and in the second phase, previously unseen algorithms are recognized using this information. We have developed a prototype and successfully applied the method for recognition of sorting algorithms. This process is explained in the paper along with the experiment we have conducted to evaluate the performance of the method. Although the method, at its current state, is still sensitive to changes made to target algorithms, the encouraging results of the experiment demonstrate that it can be further developed to be used as a PC method in various applications, as an example, in automatic assessment tools to check the algorithms used by students, the functionality that is currently missing from these tools.

This paper presents a preliminary analysis of research papers in computing education. While previous analysis has explored what research is being done in computing education, this project explores how that research is being done. We present our classification system, then the results of applying it to the papers from all five years of ICER. We find that this subset of computing education research has more in common with research in information systems than with that in computer science or software engineering; and that the papers published at ICER generally appear to conform to the specified ICER requirements.

More collaborative use of visualizations is taking place in the classrooms due to the introduction of pair programming and collaborative learning as teaching and learning methods. This introduces new challenges to the visualization tools, and thus, research and theory to support the development of collaborative visualization tools is needed. We present an empirical study in which the learning outcomes of students were compared when students were learning in collaboration and using materials which contained visualizations on different engagement levels. Results indicate that the level of engagement has an effect on students' learning results although the difference is not statistically significant. Especially, students without previous knowledge seem to gain more from using visualizations on higher engagement level.

This paper introduces SEEQ - a System for Enhanced Exploration and Querying. It is a visual query system for databases that uses a diagrammatic visualization for most user interaction. The database schema is displayed as a graph of the data model including classes, associations and attributes. The user formulates the query in terms of direct manipulation as a graph of the schema objects, additional operators and constants. The output of the query is visualized as a graph of instances and constants or in some other format that is appropriate for the data. SEEQ can operate on arbitrary relational data base provided that the schema is in XML format.

The idea of using visualization technology to enhance the understanding of abstract concepts, like data structures and algorithms, has become widely accepted. Several attempts have been made to introduce a system that levels out the burden of creating new visualizations. However, one of the main obstacles to fully taking advantage of algorithm visualization seems to be the time and effort required to design, integrate and maintain the visualizations.Effortlessness in the context of algorithm visualization is a highly subjective matter including many factors. Thus, we first introduce a taxonomy to characterize effortlessness in algorithm visualization systems. We have identified three main categories based on a survey conducted among CS educators: i) scope, i.e. how wide is the context one can apply the system to ii) integrability, i.e., how easy it is to take in use by a third party, and iii) interaction techniques, i.e., how well does the system support different use cases regularly applied by educators. We will conclude that generic and effortless visualization systems are needed. Such a system, however, needs to combine a range of characteristics implemented in many current AV systems.

In this paper, we present our experiences in using two automatic assessment tools, TRAKLA and TRAKLA2, in a second course of programming. In this course, 500--700 students have been enrolled annually during the period 1993--2004. The tools are specifically designed for assessing algorithm simulation exercises in which students simulate the working of algorithms at a conceptual level. Both of these tools allow students to resubmit their solutions after getting feedback. However, the resubmission policy has changed considerably during the period. Those changes reflect the students performance in the exercises. We conclude that an encouraging grading policy, i.e., the more exercises they solve the better grades they achive, combined with an option to resubmit the solution is a very important factor promoting students' learning. However, in order to prevent aimless trial-and-error problem solving method, the number of resubmissions allowed per assignment should be carefully controlled.

Software development is prone to time-consuming and expensive errors. Finding and correcting errors in a program (debugging) is usually done by executing the program with different inputs and examining its intermediate and/or final results (testing). The tools that are currently available for debugging (debuggers) do not fully make use of several potentially useful visualisation and interaction techniques.This article presents a prototype debugging tool (MVT--Matrix Visual Tester) based on a new interactive graphical software testing methodology called visual testing. A programmer can use a visual testing tool to examine and manipulate a running program and its data structures. The tool combines aspects of visual algorithm simulation, high-level data visualisation and visual debugging, and allows easier testing, debugging and understanding of software.

Algorithm animation has been researched since early 1980's and many different visualization systems have been developed. However, most of them have remained as research prototypes and almost none have gained wide acceptance by teachers as classroom demonstration tools. One of the key reasons for this has been that preparing animations has been too laborious. In this paper, we demonstrate a new tool, MatrixPro, in which animations are generated in terms of visual algorithm simulation. The user can graphically invoke ready-made operations available in the library to simulate the working of real algorithms. Since the system understands the semantics of the operations, the teacher can ex tempore demonstrate the execution of algorithms with different input sets, or work with "what-if" questions students ask in lectures. Such an approach lowers considerably the step for adopting algorithm visualization as a regular lecture tool.

Feedback based on automatic assessment of students' solutions is an important aid for students' learning process in self-study and distance learning. Most automatic assessment systems allow students to revise their solutions after getting the feedback and resubmit their work to be able to complete the exercise. In this paper, we analyze the effect of re submission in detail in the context of automatically assessed algorithm simulation exercises. In the target system TRAKLA2, students can revise their answers as many times as they wish, but each trial requires to restart the exercise with new random data. We present statistical results from a course with 600 students and show that our method that combines resubmissions and exercises with randomized initial data has a positive effect on learning results.

Data structures and algorithms include abstract concepts and processes, which people often find difficult to understand. Examples of these are complex data types and procedural encoding of algorithms. Software visualization can significantly help in solving the problem.

Several Web-based learning environments which can automatically give immediate feedback to the students have been reported within the past few years. The quality of feedback can be relatively high in these systems, but it does not achieve the level a trained teacher can provide. However, the lack of the best possible feedback can be compensated for, to some extent, by providing immediate and individualised feedback at any place or time. The question is whether the systems providing automatic feedback are good enough to compete with humans. This paper reports on a randomised large scale intervention study. We found that there was no significant difference in the final examination results between students doing instructed simulation exercises in a classroom session and students using a web-based learning environment, if the exercises were the same. However, with more challenging exercises, there was a significant difference in the examination results, while the drop out rate was higher. Thus, the chosen teaching method and medium did not effect the level of learning, but the quality of the exercises did.

In this paper, we present some experiences on using automatic assessment in large scale courses of introductory programming, data structures, and algorithms over a period of 10 years. Automatic assessment provides an effective method for giving immediate 24/7 feedback service for students of mass courses. A very important factor in the promoting of learning is the possibility to resubmit answers after receiving the feedback. However, our experience shows that the resubmission option is not the only key motivation factor. More important factors include the challenge of exercises and the grading scale or the course assignments. A successful combination of all of these can produce good learning results.

No abstract available.

Automatic assessment of programming exercises has become an important method for grading students' exercises and giving feedback for them in mass courses. We describe a system called Scheme-robo, which has been designed for assessing programming exercises written in the functional programming language Scheme. The system assesses individual procedures instead of complete programs. In addition to checking the correctness of students' solutions the system provides many different tools for analysing other things in the program like its structure and running time, and possible plagiarism. The system has been in production use on our introductory programming course with some 300 students for two years with good results.

Visualization is a useful aid for understanding the working of algorithms. Therefore many interactive algorithm animation tools have been developed. However, students may misinterpret the visualization and therefore the correctness of their interpretation should be confirmed by tests supplemented with feedback.In this paper, a learning environment for data structures and algorithms is presented. The combination of algorithm animation and simulation with automatic assessment provides a way to give meaningful feedback to the students. Our experience shows that this combination is of great value for the students studying algorithms.