Generative AI (GenAI) is becoming a widely adopted learning support tool for both students and instructors, as it offers benefits such as personalized tutoring and scaffolded learning. However, recent research highlights potential drawbacks such as overreliance and metacognitive issues, especially in novice programmers. Most prior work focuses on introductory programming courses, and important questions remain about the underlying mechanisms behind the negative effects of GenAI and if findings can be generalized when students learn more advanced computer science concepts. To address this gap, we conducted a mixed-methods study comparing student interactions with GenAI to two traditional learning supports in a second-year algorithms course: algorithm visualization (AV) and human live tutoring (LT). Twelve students participated in three 90-minute study sessions focusing on sorting, tree, and graph algorithms. We recorded gaze and interaction data, and each session concluded with a test assessing their conceptual understanding of the topic. Our analysis classifies when during the problem-solving process participants sought help, and compares the interaction patterns across the three learning supports. Although GenAI produced a larger increase in self-efficacy compared to live tutoring, it was associated with noticeably lower results in learning outcomes. We found that participants did not use algorithm visualizations effectively, faced usage barriers when using GenAI to learn advanced topics, and that live tutoring yielded the highest learning outcomes.
In this article, we present of two studies on diagnosing beginning students' misconceptions in tracing tasks: First, we show that tracing tasks can be used to design items that trigger misconceptions known from literature. We conducted a think-aloud study (N = 10), in which participants front two groups of no and minimal prior exposure to programming verbalized their thoughts While taking a test. The results indicate that certain incorrect answers are based on the thinking patterns of known misconceptions. The second study involving novice prognunmers consists of data from university students (N = 651) at five levels of experience who attended introductory computer science courses. Results indicate that errors made by participants vary across experience levels. Some misconceptions appear less frequently with experience, while others are more persistent, even among more advanced students. Taken together, the results of the study advance our understanding of the prevalence of known misconceptions and offer a preliminary insights into the learning processes that occur at the very beginning of programming education.
Background and Context. In many countries, K-12 curricula include programming within existing STEM subjects, in particular mathematics, based on explicit arguments that everyone should learn some programming and that programming may improve students’ mathematical understanding, and implicitly acknowledging the lack of specialized computing teachers and timetable slots. While much research in this area has focused on programming in the context of geometry, an ongoing shift in probability education from classical calculations to simulation-based approaches makes combined programming and probability learning an important area to explore. Objectives. We aim to identify behavioral patterns exhibited by students working on integrated programming and probability tasks and to assess how these patterns support/hinder students in learning programming and probability simultaneously. Method. This paper reports on an in-depth case study of a single ninth-grade student taking part in a two-month intervention where introductory Python programming and basic probabilistic reasoning were taught simultaneously and guided by a revised PRIMM framework. The relevant data material consists of video/screen recordings and observations of and discussions with the student during lessons and was analysed using Schulte’s Structure-Function based Block Model in the context of fine-grained microgenetic analysis. Findings. The analysis revealed three recurring behaviors: (1) Informed Cycle of Adjustments, a cycle of iterative code modifications, which could lead to programming constructs being reinforced through immediate feedback at the expense of superficial engagement with probability concepts, but could also lead to strong conceptual connections between programming and probability; (2) Running Program Fallacy, where a functioning program is taken as a sign that the code is correct, potentially masking underlying errors in the probabilistic reasoning, and hence obstructing probabilistic learning; and (3) Domain-Guided Program Comprehension, where probabilistic understanding is used to understand the program logic and behavior, resulting in an increased capacity to interpret and debug programs effectively. Implications. Our findings suggest that it is difficult for students to learn programming and probability from scratch at the same time and that it might be more efficient if students first learn basic programming before moving on to combining (possibly more advanced) programming when learning probability. Combining programming and probability could be advantageous for the latter in that it encourages active engagement and immediate feedback through simulations, although overall, additional scaffolding may be required to help students achieve the intended learning outcomes in both domains.
Understanding how young learners conceptualize computing terms and programming stnictures is crucial for designing effective computing education. Although previous research has identified misconceptions among older students, little is known about how younger learners develop preconceptions before formal instruction. This study investigates how 34 primary school students (Grades 2-4, age: M = 8.65 years) conceptualize sequences, loops, and conditionals in unplugged, block-based (Scratch and BlockPy), and text -based (Python) programming environments. Using think-aloud interviews and qualitative content analysis, we investigated students' reasoning during code -tracing activities. The findings indicate common preconceptions that can explain the prevalence of certain misconceptions in novice programmers. Furthermore, we identified two preconceptions that were not previously reported as misconceptions. First, students repeated Scratch loops an extra time, likely due to the natural -language interpretation of 'repeat'. Second, some students added numbers in conditions to statements inside conditionals, resembling a misconception previously observed only in loops. Finally, we determined factors influencing the development of preconceptions, such as programming language features and students' mathematical abilities. These findings provide insight into the early development of misconceptions. They emphasize the role of programming language features in shaping young learners' understanding, highlighting the need for appropriate instructional strategies and programming environments that support beginners in building accurate mental models of programming concepts.
Background and Context: Programming assignments and compile-and-run prompts are designed to authentically assess programming ability by providing an integrated development environment for students to write code to solve a problem. Recent literature supports the use of compile-and-run prompts, where programming ability is assessed in a timed and secure exam environment, but a lack of investigation into student programming behaviors during exams raises questions about the validity and alignment of assignments and compile-mid-run prompts. Objectives: Our study evaluates the authenticity, validity, and alignment of programming assignments and compile-and-run prompts in a CS1 course. Specifically, we investigate differences in programming behaviors, how these behaviors relate to performance, and whether assignments effectively prepare students for compile-and-run prompts. Methods: We collect performance and programming process data from students during assignments and exams. By calculating programming behavior metrics derived from keystrokes and compilations, we observe various behaviors, such as students struggling with compiler errors and pasting code from external resources. Findings: We find significant behavioral differences between assignments and exams, with engagement behaviors during assignments correlating with cumulative course performance and behaviors associated with programming ability during exams correlating with performance. By analyzing pasting behaviors, we find that student over-reliance on external resources during assignments is linked to a lack of student preparedness for compile-and-run prompts. Implications: Based on our findings, we recommend compile-and-run prompts on exams as an authentic and secure assessment of individual programming ability and also recommend the tracking of programming process data to monitor student experience and engagement. We discuss the implications of over-reliance on external resources for progranuning assessments and propose strategies for incorporating compile-and-runpromnpts into CS1 to improve student learning and mitigate this over-reliance.
