Decomposition and abstraction is an essential component of computational thinking, yet it is not always emphasized in introductory programming courses. In addition, as generative AI further reduces the focus on syntax and increases the importance of higher-level code reasoning, there is renewed opportunity to teach DA explicitly. In this paper, we introduce a framework for systematically assessing the complexity of code structuring tasks, where students must identify and separate meaningful abstractions within existing, unstructured code. The framework defines three dimensions of task complexity, each with multiple levels: repetition, code pattern, and data dependency. To support practical use, we provide example tasks mapped to these levels and offer an interactive tool for generating and exploring DA problems. The framework is designed to support the development of educational tasks that build students' skills with DA in the procedural paradigm.

A variety of factors, accelerated by rapid advances in generative AI, have prompted CS educators to reconsider traditional assessment methods. This year, our BoF expands beyond just oral assessment to consider broader alternative approaches such as oral exams, mastery assessment, assignment-specific evaluation, etc., and has expanded as the focus shifts toward measuring authentic proficiency while upholding academic integrity. This Birds of a Feather (BoF) session brings the CS education community together to share experiences, strategies, and concerns surrounding the evolution of assessment. Participation is encouraged from all experience levels, from those who have previously piloted novel alternative assessment methods, to those who are currently experimenting with the feasibility of non-traditional assessment, and especially those who are looking to engage in a conversation about the benefits and challenges of emerging practices. The BoF session will feature multiple ways for attendees to engage, including small-group discussion on topics such as scalability, academic integrity, oral assessment, and others. The goal of this BoF is to inspire future research (and connect active researchers) on alternative assessment methods, and create a community of practice around assessment in the age of AI. Results of the session will be compiled and shared with the community.

We developed an interactive software tool tailored for introductory computer science education, specifically for courses taught in Python. The software is designed to engage students in ethical decision-making through the simulation of emergency scenarios involving self-driving vehicles. In these scenarios, where the vehicle's brakes fail, students must refine the car's "ethics engine" to determine the best course of action: continuing straight, swerving into another lane, or crashing into a barrier. Students develop algorithms that consider various factors such as age, gender, race, and physical ability, emphasizing that algorithms are not neutral but reflect embedded societal values. This hands-on, iterative process encourages students to critically evaluate their decisions and understand the broader ethical implications of programming choices. By providing real-time feedback on the consequences of their algorithms, the software fosters critical thinking and ethical awareness, helping students to see how technology and societal values intersect in real-world applications. This project highlights the essential role of ethics in CS education, preparing students to navigate complex moral landscapes in technology.

Oral exams provide a compelling alternative to traditional evaluation methods, expanding or replacing traditional written work. Interest in oral exams is growing rapidly in computer science (CS) education due to shifts to remote learning and concerns around AI-supported programming. This Birds of a Feather (BoF) session is broadly applicable to many in the CS education community, whether they have previously tried oral exams, have concerns about the use of oral exams in CS education, or are curious to hear more about how oral exams might work. The BoF session will provide a forum to discover and discuss previous approaches to oral exams, dive into common themes of interest in small groups, and collectively identify promising future directions for oral exams in CS courses.

Oral exams are an inviting alternative to traditional paper-and-pencil exams. However, they are largely under-utilized in computer science education. In this report, we describe our design for comprehensive final oral exams in five software engineering class sections, across two different small institutions. We present our exam format and our subjective assessment of the exam format in assessing student knowledge as instructors. We also gather quantitative and qualitative data from student surveys. We surveyed students before and after the oral exam to assess their perceptions of it, including their predicted grade and their subjective opinions and experiences. Our work shows evidence that oral exams are effective and practical mechanisms for software engineering classes of a smaller size (approximately 20 students). Student survey responses indicated favorable feedback for our oral exam format; students viewed oral exams as a good assessment of their knowledge and useful beyond that individual class.

This poster presents SynpleTest, a teaching tool created for introductory computer science courses. SynpleTest uses program synthesis to generate code based on test cases given by the user. Students must continue to add test cases until SynpleTest generates the program they desire. By doing this, our program teaches the student the importance of producing thoughtful and diverse test cases to improve fundamental understanding of testing programs. Preliminary experimentation in classrooms is underway and initial results of usability and effectiveness are being analyzed.

An oral exam is an assessment approach involving verbal explanations of key concepts or thought process to achieve a solution to a problem, sometimes accompanied by written or typed work. As a complement or refreshing alternative to standard written assessments, oral exams are being implemented in CS courses in a variety of formats. This Birds of a Feather (BoF) session will bring together the growing community of CS educators who have previously used oral exams and those interested in alternative assessment approaches to share ideas and discuss best practices. The discussion leaders represent a wide range of institutions and have varied previous expertise in the design, implementation, and study of oral exams in CS courses. The BoF session will involve (1) introduction to oral exams and previous approaches led by the discussion leaders, (2) small group discussions based on shared interests or concerns with oral exams, and (3) discussion of best practices for oral exams in CS courses.

Assessment of student knowledge is a crucial and challenging part of course design. Especially in computer science courses in the United States, written examinations are very common. While written exams offer a number of advantages in convenience and familiarity, they are also inflexible and prone to question misinterpretation. In contrast to written tests, oral exams offer the prospect of an interactive conversation where students can express their knowledge in a variety of ways while asking clarifying questions. In this paper, we present and assess our implementation of oral exams in an introductory computer science course. We describe the motivation for and resulting features of our design, including a simplified rubric style for equitable, on-the-fly grading. We also perform an assessment relative to more traditional written exams. We find the time commitment for instructors to be manageable and comparable to traditional exams. Through post-semester surveys, students self-report spending slightly more time studying for oral exams, but rate the difficulty as similar to written exams. Both qualitative and quantitative student feedback indicates that oral exams can be effective and well-received.

Debugging is difficult. When software fails in production, debugging is even harder, as failure reports usually provide only an incomplete picture of the failing execution. We present a system that answers control-flow queries posed by developers as formal languages, indicating whether the query expresses control flow that is possible or impossible for a given failure report. We consider three separate approaches that trade off precision, expressiveness for failure constraints, and scalability. We also introduce a new subclass of regular languages, the unreliable trace languages, which are particularly suited to answering control-flow queries in polynomial time. Our system answers queries remarkably efficiently when we encode failure constraints and user queries entirely as unreliable trace languages.

Program coverage is used across many stages of software development. While common during testing, program coverage has also found use outside the test lab, in production software. However, production software has stricter requirements on run-time overheads, and may limit possible program instrumentation. Thus, optimizing the placement of probes to gather program coverage is important.

Debugging is difficult and costly. Developers greatly value full traces and complete, reproducible crash recordings, but these are impractical for deployed software. Fortunately, failing applications can leave behind a snapshot of their crashing state in the form of a core dump. Unfortunately, crash data alone often leaves substantial ambiguity in the program's execution. My thesis work aims both to improve the quality of information extracted from core dumps and enhance this readily-available information. My prior work showed that automated postmortem analysis results can be significantly improved by targeted, lightweight, and tunable instrumentation (0-5% run-time overhead). My thesis aims to expand this work in three directions: improved tracing and dump data recovery, expanded postmortem analyses, and improved tracing efficiency based on previously-observed failures.

Debugging is difficult and costly. As a human programmer looks for a bug, it would be helpful to see a complete trace of events leading to the point of failure. Unfortunately, full tracing is simply too slow to use in deployment, and may even be impractical during testing. We aid post-deployment debugging by giving programmers additional information about program activity shortly before failure. We use latent information in post-failure memory dumps, augmented by low-overhead, tunable run-time tracing. Our results with a realistically-tuned tracing scheme show low enough overhead (0-5%) to be used in production runs. We demonstrate several potential uses of this enhanced information, including a novel postmortem static slice restriction technique and a reduced view of potentially-executed code. Experimental evaluation shows our approach to be very effective, such as shrinking stack-sensitive interprocedural static slices by 49-78% in larger applications.