ILDBug is a novel debugging approach inspired by the pedagogical technique Interactive Lecture Demonstrations (ILDs). During ILDs, students predict a demonstration's result, experience the demonstration, and then reflect on their experience. We adapted this process to teach debugging (ILDBug) by having students engage in detecting the bug for prediction, then locating and correcting the bug for experience, and then reflecting on the debugging process. The ILDBug approach is designed to be a lightweight technique to create a debugging exercise that is adaptable to many contexts. This demo will cover the high-level pieces the audience needs to create their own ILDBug using our approach, an example ILDBug in an introductory programming context so they can see it in action, and finally tips on how to adapt our technique to fit their own classroom context.

Novice programmers often struggle to develop computational thinking (CT) skills in introductory programming courses. This study investigates the use of Large Language Models (LLMs) to provide scalable, strategy-driven feedback to teach CT. Through think-aloud interviews with 17 students solving code comprehension and writing tasks, we found that LLMs effectively guided decomposition and program development tool usage. Challenges included students seeking direct answers or pasting feedback without considering suggested strategies. We discuss how instructors should integrate LLMs into assessments to support students' learning of CT.

Background: Previous work has shown that students can understand more complicated pieces of code through the use of common software development tools (code execution, debuggers) than they can without them.

Background and context. “Explain in Plain English” (EiPE) questions ask students to explain the high-level purpose of code, requiring them to understand the macrostructure of the program’s intent. A lot is known about techniques that experts use to comprehend code, but less is known about how we should teach novices to develop this capability.

The ability to reason about the general purpose and behavior of code, rather than simply focusing on specific inputs and outputs, is an essential skill to teach to novice programmers. However, effectively teaching this skill can be a challenging task. In light of recent research on using concreteness fading and comics for teaching programming, we aim to develop a tool that employs a gradual transition from concrete to abstract code representations and investigate whether it enhances students’ ability to recognize patterns and foster the development of associated programming skills, such as code tracing and writing.

Explain in Plain English (EiPE) questions evaluate whether students can understand and explain the high-level purpose of code. We conducted a qualitative think-aloud study of introductory programming students solving EiPE questions. In this paper, we focus on how students use tracing (mental execution) to understand code in order to explain it.

For students to write code, they should be able to understand the purpose of code written by others. How students learn to read code at a higher-level beyond tracing (mental execution) is not well-understood. The goal of my research is to understand how to teach students to read code at a higher-level.

When students attempt to solve code-tracing problems, sometimes students make mistakes as they read code that get in the way of correctly solving the problem. In this paper, we explore the degree to which students can correct their misunderstandings by executing the provided code on a computer. Specifically, we performed a qualitative between-subjects think-aloud study to compare what kinds of errors students can resolve by just executing the code versus which they can resolve by using a line-by-line debugger.

Recent breakthroughs in computer vision have led to the invention of several intelligent systems in different sectors. In transportation, this advancement led to the possibility of proposing autonomous vehicles. This recent technology relies heavily on wireless sensors and Deep learning. For an autonomous vehicle to navigate safely on highways, the vehicle needs equipment to aid with detecting road anomalies such as potholes ahead of time. The massive improvement in computer vision models such as Deep Convolutional Neural networks (DCNN) or vision transformers (ViT) resulted in many success stories and tremendous breakthroughs in object detection tasks; this enabled the use of such models in different application areas. But many of the reported results are theoretical and unrealistic in real-life. Usually, the nature of these models is extensive; they are trained on High-performance computers or cloud computing environments with GPUs, which challenge their usage on edge devices. However, to come up with a light model that can fit into embedded devices, the model size has to be reduced significantly so that the performance will not be affected. Therefore, this paper proposes a lightweight model of pothole detection for an embedded device. The model achieved a state-of-the-art accuracy of 98%, with the number of parameters reduced to more than 70% compared with a deep CNN model; the model can be trained and deployed on embedded devices such as smartphones efficiently.

In this paper, we perform a comparative analysis using a within-subjects ‘think-aloud’ protocol of introductory programming students solving tracing problems in both paper-based and computer-based formats. We demonstrate that, on computer-based exams with compiler/interpreter access, students can achieve significantly higher scores on tracing problems than they do on similar paper-based questions, through brute-force execution of the provided code. Furthermore, we characterize the students’ usage of machine execution as they solve computer-based tracing problems.

Novice programmers sometimes need to understand code written by others. Unfortunately, most software projects lack comments suitable for novices. The lack of comments have been addressed through automated techniques of generating comments based on program statements. However, these techniques lacked the context of how these statements function since they were aimed toward experienced programmers. In this paper, we present a novel technique towards automatically generating comments for Java statements suitable for novice programmers. Our technique not only goes beyond existing approaches to method summarization to meet the needs of novices, it also leverages API documentation when available. In an experimental study of 30 computer science undergraduate students, we observed explanations based on our technique to be preferred over an existing approach.

In this paper, efficient hardware-software (HW-SW) partitioning technique based on high performance scheduling and mapping algorithms on multiple cores is presented. The scheduling and mapping algorithms produce the optimality of mapping tasks onto cores. The partitioning technique reduces the overall execution time and number of buses among the cores. The viability and potential of the proposed algorithms are demonstrated by extensive experimental results to conclude that the proposed algorithms are efficient scheme to obtain the optimality of scheduling, mapping and partitioning with hard and large task graph problems.