Active learning in introductory programming depends on frequent, high-quality feedback, yet instructors often struggle to deliver consistent support at scale. In this poster, we introduce INSIGHT, an AI-driven classroom assistant designed to promote active learning in introductory programming (CS1) courses through scalable, personalized, and explainable feedback. The assistant combines the generative capabilities of large language models (LLMs) with instructor-in-the-loop authoring and an explainable code analysis engine to ensure pedagogically aligned support. Instructors can co-design problems with LLM assistance, provide exemplar solutions, define common student errors, and author targeted feedback. The AI engine analyzes student code submissions, identifies misconceptions, and maps them to instructor-verified feedback in real time. INSIGHT is designed to ensure that key educational concepts and common misconceptions are explicitly addressed by instructors, while also leveraging LLMs to provide reasonable feedback for novel or edge-case solutions that instructors may not have anticipated. By combining instructor expertise with the flexibility of generative AI, the assistant helps close feedback gaps and ensures more comprehensive coverage of student learning needs, especially in large or diverse classrooms with limited instructional support.

In response to the growing demand for data analysis and computational thinking skills across academic disciplines, universities are increasingly integrating programming courses into the curricula for non-computer science (non-CS) majors. A key challenge for instructors is designing instructional materials that help these students connect programming concepts to authentic disciplinary contexts and build confidence in applying programming skills to real-world tasks. This paper reports our experience designing a data analysis lab within an introductory programming course, in which hands-on data collection is integrated into the entire analytical workflow. Instead of working with predefined datasets, students use a Raspberry Pi and a thermocouple sensor to collect their own data before performing tasks in data extraction, processing, and visualization using Python. Twenty device kits were deployed for student teams in the experimental semester (Spring 2024, n = 76). Post-lab surveys were used to assess students' self-efficacy in performing data-related programming tasks, including data collection, extraction, processing, and visualization. Our findings provide insights into students' perceptions and experiences with hands-on data collection, offering implications for how authentic, end-to-end programming activities can be integrated into introductory courses for non-CS majors.

CUDA is the de facto programming model for GPUs, which is widely used in the domains of HPC and AI. To obtain bare-metal performance, vendors and academia develop various profiling tools to guide optimization. However, most existing tools focus on hotspot analysis with limited capabilities in identifying actionable opportunities. To complement existing tools, we present RedSan, a novel profiling tool that leverages binary instrumentation to identify redundant instructions in fully optimized CUDA programs. Guided by RedSan, we are able to optimize programs such as PolybenchGPU, Rodinia, PASTA, DARKNET, and LULESH, yielding up to a 6.27 × speedup and 3.00 × reduction in memory instructions.

GPU programming is a critical component in AI system courses, which is notoriously difficult to learn and teach, given its unique features such as massive parallelism and data movement across memory hierarchies. This paper presents Triton-Viz, an innovative visualization toolkit that helps students learn GPU programming using Triton, one of the most widely used programming languages to develop AI applications. Triton-Viz offers an intuitive interface with interactive visualizations of GPU operations from multiple perspectives, including parallelism, memory access, and performance metrics. By integrating into educational materials, Triton-Viz enhances hands-on learning and improves comprehension of GPU programming concepts and AI algorithms in real applications, as demonstrated in a study conducted with Computer Science students. The positive feedback from this study highlights the utility of Triton-Viz in educational settings and its potential to bridge the gap between the theoretical algorithm and practical implementations in AI courses.

Prolonged screen time while working on programming assignments can often lead to student fatigue, boredom, and stress. In response to these issues and to enhance the overall programming environment for students, we introduce ThemeRec, a Visual Studio Code extension. ThemeRec provides students with personalized recommendations for code themes, with a particular focus on semantic coloring combinations. It boasts an extensive collection of over 150 code themes, each offering unique combinations of background colors, font styles, and semantic color arrangements. Using an integrated collaborative filtering recommendation system, ThemeRec automatically suggests and installs various themes based on the preferences of similar users whenever they want to change a theme. To assess the effectiveness of ThemeRec, we conducted an evaluation within an introductory-level programming course. The feedback from students has been positive and encouraging. This underscores the potential value that ThemeRec brings to programming courses.

Java is the “go-to” programming language choice for developing scalable enterprise cloud applications. In such systems, even a few percent CPU time savings can offer a significant competitive advantage and cost savings. Although performance tools abound for Java, those that focus on the data locality in the memory hierarchy are rare.

Optimizing performance inefficiencies in memory hierarchies is well-known for native languages, such as C and C++. There are few studies, however, on exploring memory inefficiencies in Android Runtime (ART). Running in ART, managed languages, such as Java and Kotlin, employ various abstractions, such as runtime support, ahead-of-time (AOT) compilation, and garbage collection (GC), which hide important execution details from the plain source code.

Memory bloat is an important source of inefficiency in complex production software, especially in software written in managed languages such as Java. Prior approaches to this problem have focused on identifying objects that outlive their life span. Few studies have, however, looked into whether and to what extent myriad objects of the same type are identical. A quantitative assessment of identical objects with code-level attribution can assist developers in refactoring code to eliminate object bloat, and favor reuse of existing object(s). The result is reduced memory pressure, reduced allocation and garbage collection, enhanced data locality, and reduced re-computation, all of which result in superior performance.

Block-based programming environments, such as Scratch and Snap!, engage users to create programming artifacts such as games and stories, and share them in an online community. Many Snap! users start programming by reusing and modifying an example project, but encounter many barriers when searching and identifying the relevant parts of the program to learn and reuse. We present Pinpoint, a system that helps Snap! programmers understand and reuse an existing program by isolating the code responsible for specific events during program execution. Specifically, a user can record an execution of the program (including user inputs and graphical output), replay the output, and select a specific time interval where the event of interest occurred, to view code that is relevant to this event. We conducted a small-scale user study to compare users’ program comprehension experience with and without Pinpoint, and found suggestive evidence that Pinpoint helps users understand and reuse a complex program more efficiently.

Compilers are an indispensable component in the software stack. Besides generating machine code, compilers perform multiple optimizations to improve code performance. Typically, scientific programmers treat compilers as a blackbox and expect them to optimize code thoroughly. However, optimizing compilers are not performance panacea. They can miss optimization opportunities or even introduce inefficiencies that are not in the source code. There is a lack of tool infrastructures and datasets that can provide such a study to help understand compiler optimizations.

Execution variance among different invocation instances of the same procedure is often an indicator of performance losses. On the one hand, instrumentation-based tools can insert calipers around procedures and identify execution variance; however, they can introduce high overheads. On the other hand, sampling-based tools insert no instrumentation and have low overheads; however, they cannot synchronize samples with procedure entry and exit.