As large language models (LLMs) become widespread, students increasingly turn to systems like ChatGPT for writing tasks. Educators worry that this reliance may reduce critical engagement with writing and hinder students’ learning processes. Although datasets exist on students’ use of LLMs for writing, how they functionally use ChatGPT in detail—and how this usage shapes their writing and perceptions—remains underexplored. We conducted an online study (n=77) in which students wrote an essay using an in-house ChatGPT we developed to capture their queries. Through qualitative analysis, we identified the types of assistance students sought and presented patterns of use, ranging from asking for opinions on a topic to delegating the entire writing task to ChatGPT. We also found that students’ writing self-efficacy influenced their querying patterns and that levels of ownership and creativity varied depending on how they used ChatGPT. This study contributes empirical data to ongoing discussions about how writing education should incorporate or regulate LLM-powered tools.

Background and Context. Live coding is a pedagogical technique where an instructor writes code in front of their class. The literature on live coding consists primarily of experiments and case studies, and few researchers have sought to understand how instructors actually employ live coding in their classrooms.

Background and Motivation. Live coding is a common pedagogical technique where instructors write code in real time during lectures. For students, the main drawbacks of live coding are that it can feel too fast and it can be difficult to take notes. Objectives. Our work seeks to improve the student experience in live coding lectures by: (1) understanding how instructors expect students to take notes and what challenges students face in doing so; and (2) investigating whether a specialized note-taking tool can help students keep up with the pace of the lecture and take better notes. Methods. Based on interviews with instructors who use live coding (n=10), we designed a simple note-taking interface consisting of a rich text editor which allows students to take snapshots of the instructor’s code. We conducted a within-subjects lab experiment (n=57) comparing our interface with a traditional code editor during two 15-minute live coding lectures. We used quizzes and surveys to assess learning, mental workload, and student perceptions, and analyzed students’ notes to determine how much information was captured from the lecture. Findings. In the experimental condition, NASA-TLX surveys indicated a significantly lower mentalworkload and students reported that they could more easily keep up with the lecture. Additionally, students perceived their notes to be more useful and our analysis revealed that the notes had significantly more information from the lecture and provided more context for copied code. Despite these benefits, we did not see a significant difference in learning between the two conditions. Implications. Our results show that during live coding lectures, we can decrease student mental workload and increase the quality of notes by providing an interface which (1) allows capturing the instructor’s code without having to type it out; and (2) maintains a clear visual distinction between code snippets and other text. Future work may examine if such an interface can lead to learning gains over long-term use in the classroom.

This poster presents the development and implementation of a 10-day remix-based summer camp curriculum designed to introduce high school students, particularly a multinational cohort of young women, to programming through creative coding. The curriculum integrates music composition using EarSketch and web development with HTML and CSS. The camp aims to inspire participants to gain self-efficacy in programming and motivate them to explore STEM/computing careers. Preliminary results from surveys and interviews indicate increased confidence in programming skills. This ongoing research explores the impact of remixing as a gateway for transitioning into more general-purpose computing domains such as web development.

One challenge in technical interviews is the thinkaloud process, where candidates verbalize their thought processes while solving coding tasks. Despite its importance, opportunities for structured practice remain limited. Conversational AI offers potential assistance, but limited research explores user perceptions of its role in think-aloud practice. To address this gap, we conducted a study with 17 participants using an LLM-based technical interview practice tool. Participants valued AI’s role in simulation, feedback, and learning from generated examples. Key design recommendations include promoting social presence in conversational AI for technical interview simulation, providing feedback beyond verbal content analysis, and enabling crowdsourced think-aloud examples through humanAI collaboration. Beyond feature design, we examined broader considerations, including intersectional challenges and potential strategies to address them, how AI-driven interview preparation could promote equitable learning in computing careers, and the need to rethink AI’s role in interview practice by suggesting a research direction that integrates human-AI collaboration.

Facilitating class-wide debriefings after small-group discussions is a common strategy in ethics education. Instructor interviews revealed that effective debriefings should highlight frequently discussed themes and surface underrepresented viewpoints, making accurate representations of insight occurrence essential. Yet authoring presentations in real time is cognitively overwhelming due to the volume of data and tight time constraints. We present Dynamite, an AI-assisted system that enables semantic updates to instructor-authored slides during live classroom discussions. These updates are powered by semantic data binding, which links slide content to evolving discussion data, and semantic suggestions, which offer revision options aligned with pedagogical goals. In a within-subject in-lab study with 12 participants, Dynamite outperformed a text-based AI baseline in content accuracy and quality. Participants used voice and sketch input to quickly organize semantic blocks, then applied suggestions to accelerate refinement as data stabilized.

The term live coding can refer either to a performative musical practice or to a lecture technique in the CS classroom. These two disparate practices are united in that they can be thought of as code performances, where a performer writes, edits, and runs code live in front of an audience. In my research, I aim to better understand code performances and how we can support them. In a recent project, I explored how a version control system could benefit live coding music. I found that backtracking affordances could facilitate incorporating musical form on the fly and that version trees could act as a visual aid for both the performer and the audience. In another ongoing project, I am exploring how to support live coding in the CS classroom, focusing on increasing audience learning and engagement. In the future, I plan to explore how to best represent code performances so performers can iterate on their own ideas more easily, as well as share and collaborate with others.

Version control systems, which have proven essential for software engineering, can also provide value to creative and artistic practices. In this paper, we explore version control in the creative domain of live coding music, a generative performance practice where programmers edit and run code live to generate audiovisual artifacts. To that end, we developed SHARP, a lightweight version control system that live coders can use during performances as well as in preparation or practice sessions. We conducted a user study where live coders used SHARP for several weeks, wrote diary entries reflecting on their sessions, recorded a performance using SHARP, and participated in exit interviews. We found that SHARP enabled participants to engage with musical form on the fly in novel ways. In addition, the study revealed multifaceted perspectives on how and when versioning can be useful in the context of live coding. Our results inform the design of versioning systems for live coding and more generally for performance and generative arts practices.

For my dissertation, I am interested in what I call code performances, where a performer (broadly construed) writes, modifies, and runs code live for an audience. While code is often presented as a static, pre-written artifact, watching code being written live allows the audience to observe the evolution of the code over time, gaining insight into the performer’s thought process. My work focuses on three practices which can be considered code performances:

Trigger-Action Programming (TAP) allows endusers to automate IoT devices, social media, and other services. TAP systems typically offer 1) user-friendly, GUI-mediated access to service APIs through “triggers” and “actions” and 2) a simplified if-this-then-that programming model. While simple, TAP’s programming model lacks power and limits what its users can create. We introduce Legato, an automation platform which keeps the convenient trigger and action abstractions from TAP, but allows programmers to connect these triggers and actions with complex logic via JavaScript. Legato piggybacks on IFTTT, taking advantage of IFTTT’s mature ecosystem of integrations. Additionally, Legato allows programmers to store and retrieve persistent state, schedule future events, and safely test their programs. Through a two-stage usability study, we found student programmers easily learned Legato and came up with several scenarios requiring Legato’s power. Based on feedback and observation, we derive design recommendations for future highly-expressive automation systems and reflect on the role of textual programming for end-user automation.

The act of computer programming can take many different forms. For example, a software engineer might rewrite C++ code to speed up some process; an analyst might use a spreadsheet program to gain insights into their data; or a creative coder might write a program to create an abstract visualization that is synchronized with music. While each of these tasks is a complex activity involving creative problem-solving, the first example has a well-defined goal, while the second and third examples are more open-ended. Generally, programming activities involving data analysis or artistic creative practice can be seen as exploratory programming, characterized by rapid experimentation and an evolving set of goals [1]. In the creative coding example, the coder might explore several options using different combinations of colors, shapes, textures, and animation speeds. There is no “correct” answer for what the final product should look like, and in fact, what they envision at the outset might be completely different from what they ultimately create.

The construction industry is a new avenue for big data and data science with sensors and cyber-physical systems deployed in the field. Construction students need to develop computational thinking skills to help make sense of this data, but existing data science environments designed with textual programming languages create a significant barrier to entry. To bridge this gap, we introduce Octave, an end-user programming environment designed to help non-expert programmers analyze spatiotemporal data (e.g., as gathered by a GPS sensor) in an interactive graphical user interface. To aid exploration and understanding, Octave's design incorporates a high degree of liveness, highlighting the interconnection between data, computation, and visualization. We share the underlying design principles behind Octave and details about the system design and implementation. To evaluate Octave, we conducted a usability study with students studying construction. The results show that non-programmer construction students were able to learn Octave easily and were able to effectively use it to solve domain-specific problems from construction education. The participants appreciated Octave's liveness and felt they could easily connect it to real-life problems in their field. Our work informs the design of future accessible end-user programming environments for data analysis targeting non-experts.