Git is widely used for collaborative software development, but it can be challenging for newcomers. While most learning tools focus on individual workflows, Git is inherently collaborative. We present GitAcademy, a browser-based learning platform that embeds a full Git environment with a split-view collaborative mode: learners work on their own local repositories connected to a shared remote repository, while simultaneously seeing their partner’s actions mirrored in real time. This design is not intended for everyday software development, but rather as a training simulator to build awareness of distributed states, coordination, and collaborative troubleshooting. In a within-subjects study with 13 pairs of learners, we found that the split-view interface enhanced social presence, supported peer teaching, and was consistently preferred over a single-view baseline, even though performance gains were mixed. We further discuss how split-view awareness can serve as a training-only scaffold for collaborative learning of Git and other distributed technical systems.

Many software development platforms now support LLM-driven programming, or “vibe coding”, a technique that allows one to specify programs in natural language and iterate from observed behavior, all without directly editing source code. While its adoption is accelerating, little is known about which skills best predict success in this workflow. We report a preregistered cross-sectional study with tertiary-level students (N = 100) who completed measures of computer-science achievement, domain-general cognitive skills, written-communication proficiency, and a vibe-coding assessment. Tasks were curated via an eight-expert consensus process and executed in a purpose-built, vibe-coding environment that mirrors commercial tools while enabling controlled evaluation. We find that both writing skill and CS achievement are significant predictors of vibe-coding performance, and that CS achievement remains a significant predictor after controlling for domain-general cognitive skills. The results may inform tool and curriculum design, including when to emphasize prompt-writing versus CS fundamentals to support future software creators.

Syntax remains a major barrier for novices. Although block-based systems reduce or eliminate syntax errors, conditionals still challenge learners, likely because their semantics remain implicit. In this paper, we address this problem by introducing a semantics-first, state-visible programming approach inspired by the classic visual language Stagecast Creator. To demonstrate its usefulness, we designed Elephant, a unified, Karel-like research platform that supports three equally expressive programming paradigms: (i) semantics-first programming, (ii) block-based programming with the Blockly library, and (iii) text-based programming in JavaScript with domain-specific libraries. We then deployed Elephant in two within-subjects studies with secondary-school students (N = 39) to compare semantics-first programming to textual and block-based baselines, keeping the program semantics constant across modes and reducing cross-tool confounds. Results indicate, among other things, that semantics-first programming yields significantly higher task performance, suggesting that increasing the visibility of the program state during program composition could support greater outcomes in secondary computing education.

Background. Large language models are increasingly deployed as tutors in introductory programming courses, yet evidence that they actually improve learning remains thin, and their tendency to shortcut productive struggle raises concerns about pedagogical harm. Self-regulated learning (SRL) and cognitive engagement (CE) frameworks offer a principled way to address this, but whether embedding them in system prompts actually changes how students learn is an open question.

Background and Context. Code complexity measures have been used to guide the design of various activities within computing education, such as instructional sequencing and assessment. However, empirical evidence for the link of these measures to actual cognitive difficulties remains mixed, with studies suffering from small sample sizes and non-controlled experimental design.

Balancing conceptual depth with practical skill development is a persistent challenge in advanced machine learning (ML) education, where powerful frameworks can obscure underlying mathematical and computational principles. To address this, we define a new principled approach that we call full-stack machine learning (FSML), which emphasizes the construction of large language models and diffusion models from scratch. To evaluate the effectiveness of FSML, we conducted a classroom-based randomized controlled trial (N=208) in which FSML-based instruction was compared against a popular library-based instructional approach. We measured students' conceptual understanding through a specialized assessment and administered a survey capturing knowledge-gap awareness, curiosity, and cognitive load. We found that students who received FSML instruction performed approximately 10% better than control participants in a quiz on transformers and stable diffusion (p=0.006). They also showed increased curiosity and more positive affective responses, suggesting deeper engagement with ML fundamentals. Our findings indicate that our full-stack approach to ML education can improve student learning outcomes, potentially reshaping curricula for ML and other advanced computing topics.

Boolean algebra is foundational to programming, yet the terse textual syntax of boolean expressions does not map clearly onto the way that students reason about logical conditions. To help bridge this gap, we introduce Boolean Canvas, a direct-manipulation interface that lets learners construct visual boolean diagrams while the corresponding Python code is generated in real time. We report on a within-subjects study with 29 tertiary-level students who solved boolean-logic tasks in Python with and without Boolean Canvas. Task success, cognitive load, system enjoyment, and perceived usability were recorded. Results show that Boolean Canvas performs similarly to a traditional code editor across objective and self-reported measures. We reflect on the design and study outcomes, identifying which features supported learning, which did not, and why, and offer evidence-based recommendations for instructors and tool builders.

Higher-order functions are increasingly common in modern programming languages, yet there is a shortage of evidence-based tools and teaching strategies to help students learn them effectively. We introduce a visual tool that lets learners construct, view, and execute higher-order functions using direct manipulation and programming by demonstration. To evaluate its effectiveness, we conducted a randomized, within-subjects study with 27 university students, comparing our tool against Python as a control. The results show that students performed significantly better and reported lower cognitive load when solving simple problems with our tool. However, both groups showed similar performance on tasks that involved mapping input-output pairs to the correct higher-order function. Our findings suggest that visual, direct-manipulation tools can help students develop stronger procedural knowledge of higher-order functions, although additional scaffolding may be needed to foster deeper conceptual understanding.

While educational researchers in various disciplines are grappling with how to develop policies and pedagogical approaches that address the use of generative artificial intelligence, the challenge is particularly complex in computer science education where the new technology is changing the core of the field. In this paper, we take a look at the pedagogy of other subjects with a longer history than computer science and a more extensive body of educational research to collect insights on how this challenge can be met. We begin by drawing from recent neurological research to find domains that share cognitive commonalities with computer programming and then build upon comparisons that others have made to literacy and mathematics education. We then consider how the "reading wars" and "math wars" have shaped these fields, which we see as conflicts between less effective top-down pedagogy and more effective bottom-up pedagogy, and reflect on what would be comparable approaches in teaching computing. We find that approaches that make heavy use of large language models without teaching fundamentals can be compared to the top-down pedagogy of reading and mathematics and are likely to be ineffective on their own. Therefore, we advise against the exclusive use of such approaches with novices. However, we also acknowledge that the social science surrounding computer science education is complex and that effectiveness only tells a part of the story, with other factors such as engagement, motivation and social dynamics also being important.

This paper presents a comparative study of Algot, a visual programming language designed to bridge the syntax-semantics gap via liveness and programming by demonstration, and the textual programming language Python. We conducted an experimental, within-subjects study with 24 undergraduate computer science students who performed recursion-based tasks in each language while their cognitive load was measured using an electroencephalogram and a validated survey instrument. The students received a brief introduction to Algot, but were all familiar with Python. The students performed significantly better when programming in Algot, but the cognitive load levels were similar according to both instruments. Our results provide evidence that within the domain that was tested, Algot can be quickly learned, and that students do not find it more cognitively demanding than working in a familiar language.

Abstraction is a fundamental skill and concept in computer science and it is also a difficult skill to teach. The purpose of the working group is to analyse different perspectives of abstraction's conceptualisation and ways of teaching the skill. Therefore as a result of the working group we will be first identifying how abstraction is discussed and defined in key literature. As a team we will agree on the perspectives and models we will like to explore in teaching context. Finally we will work with computing educators and computing education researchers to design a pedagogical framework that will enable the development of the abstraction skills.

Previous research on the effects of live program composition in computer science education has shown mixed results; while live programming is well-received by students and can improve the program composition process in some contexts, the resulting programs may be hard to understand, potentially making the paradigm unfeasible for collaborative and general-purpose programming. In this paper, we explore to what extent programs created in Algot, a live programming language, can be understood by tertiary-level students. We conducted an experimental, within-subjects study (n=41) measuring how well students at this level could comprehend programs composed in Algot and Python. We asked our participants to explain the programs and answer questions on them related to tracing, reverse tracing, conceptual extrapolations, and (optionally) time complexity. Despite the participants' lack of familiarity with Algot, students performed better after viewing most programs in Algot than Python, but primarily for problems involving trees and matrices. Our results contribute to the body of research on live programming in computer science (CS) education and complement recent research on the benefits of Algot for program composition, suggesting that Algot can be useful as a more general learning resource in CS tertiary education.

Algot is a visual, live programming language for computer science education that uses a novel implementation of programming by demonstration. Recent experimental studies indicate that Algot is effective for teaching foundational computer science concepts in secondary and tertiary education. In this proposed ITiCSE session, we will give a brief demonstration of how Algot works and how it can be used to implement algorithms that are typically taught in CS1, such as sorting and searching. Our primary intention is to help practitioners in the ITiCSE audience determine if Algot could be appropriate for their own classrooms.

While visual scaffolding, live programming, and direct manipulation of the program state are considered useful programming paradigms for novices, they might not always offer the same benefits to experienced software developers. In this essay, we will use chess as a proxy for exploring how these paradigms can also support those who have an intuitive understanding of the program state and its connection with textual code. We will consider the visual programming language Algot and recent user studies conducted on the language to uncover insights into how direct manipulation and programming by demonstration can benefit everyone.

While recursion is a fundamental technique in computer programming, it is challenging for novices, for example since it requires tracing non-linear and hierarchical sequences of execution. Though algorithm visualizations and visual programming may be helpful, such tools need to offer sufficiently expressive environments that support active, constructivist learning via exploration and experimentation. In this study, we investigated whether Algot, a visual programming language that relies on a novel programming-by-demonstration paradigm, is effective for teaching recursion to 14-17 year old students, and whether it compares favorably to the popular visual programming language Scratch. We conducted an experimental study with 23 participants where they learned recursion in a video tutorial using Algot and Scratch, worked out code exercises in each respective language, and then solved a post-test on recursion. Despite the participants being more familiar with Scratch than Algot, our results indicated that students instructed with Algot demonstrated a significantly better understanding of recursion (Bayes Factor = 14.09, p = 0.005, Cohen's d = 1.30). We also found that students reported a similar level of enjoyment of each language. These findings provide preliminary evidence about the effectiveness of the programming-by-demonstration paradigm, as implemented in Algot, in aiding the comprehension of complex programming concepts like recursion.

Algot is a newly developed visual programming language that seeks to bridge the syntax-semantics gap in programming via a novel implementation of programming by demonstration. Preliminary research, which will be presented separately at SIGCSE this year, suggests that Algot may be useful for teaching foundational computer science concepts at both secondary and tertiary levels. In this proposed SIGCSE demo session, attendees will have a chance to interact with Algot and learn about its potential benefits in their own classrooms.

This paper examines whether undergraduate students perform better and experience lower cognitive load when programming in Algot, a visual programming language that supports programming by demonstration, than in the textual programming language Python. We recruited 38 first-semester computer science university students who had received prior instruction in the programming language Python but were unfamiliar with Algot. Participants reviewed a 12-minute video tutorial about Algot and performed the same programming tasks in Python and Algot. We graded student submissions, estimated cognitive load through physiological measures and a validated post-test survey, and evaluated free-form feedback. Our results indicated that students experienced lower negative (extraneous and intrinsic) and higher positive (germane) cognitive load when programming in Algot. Additionally, students programming in Algot scored an average grade of 5.8 out of 10, compared to an average grade of 3.4 when using Python for the same tasks, and according to the free-form feedback, Algot is perceived as well-designed and easy to learn.

Computer programming typically requires people to describe operations in a formally specified textual language. Unfortunately, working with syntax is a significant cognitive load, making programming difficult for beginners and time-consuming for professional developers. In response to this, contemporary research often focuses on abstracting or improving the process of composing code. We believe, however, that one fundamental reason why programming is difficult is the disconnect between the symbols and metaphors used in code and the mechanics they represent. Programming languages use abstractions whose superficial similarities to natural language neither effectively help users understand programs nor enable them to work creatively. To tackle this fundamental limitation, this paper introduces a new language based on a novel programming-by-demonstration paradigm that (i) enables users to experiment and test their programs, (ii) allows describing complex operations without the need to learn any syntax, and (iii) always displays an approximation of the program state while programming a new operation. We explain the rationales behind our new approach and present our design and implementation using illustrative examples and a supplemental video recording.

Empirical research suggests that programming language syntax is a common impediment for beginners, a concern that is mitigated to a varying degree by visual programming. In this paper, we introduce a novel visual programming language that is founded on program synthesis and the programming-by-demonstration paradigm. By using an intuitive visual syntax, we show how we can meet our primary goal of providing support to computer programming novices in exploring foundational programming concepts. We present the language's current and planned use in computer science education, provide preliminary evidence for its effectiveness, and discuss its future possibilities.