Faded Parsons Problems (FPPs) are a variant of Parsons Problems in which students reconstruct short pieces of code by filling in blanks (''fades'') and rearranging pre-written scrambled lines of code. We are particularly interested in FPPs' demonstrated superiority over code-writing or code-comprehension exercises for scaffolding the teaching of advanced programming concepts. However, little is known about how the choice of what to fade (i.e. which tokens to blank out in the scrambled code lines) affects an FPP's difficulty and efficacy, and existing Parsons Problems research does not address advanced classrooms. Code for italics .xx. Code for bolTo inform the choice of what to fade, and potentially allow automated fading of a reference solution for formative assessments, we devise a conceptual guide for constructing FPP ''fading strategies'' informed by guidelines from prior work as well as our own experience. Using this guide, we generate three strategies that are variably aware of the context of the program text they fade. We compare the strategies using a between-subjects study in which students solve FPPs around an advanced software engineering topic. We find that the difficulty and efficacy of the problems, as measured by time on task, qualitative surveys, and long-term retention, does not appear to depend on context-awareness, but also find that random choices are, in some senses, ''more obfuscating'' than our other strategies. We conclude that our simplest strategy suffices for the future study of automatic fading of FPPs scaffolding advanced topics.

Requirements Elicitation (RE) is a crucial software engineering skill that involves interviewing a client and then devising a software design based on the interview results. We propose conditioning a large language model to play the role of the client during a chat-based interview. We evaluate our approach in a study (n=120) using both a qualitative survey and quantitative observations about participants' work. Our positive findings suggest a new way to practice critical RE skills in a scalable and realistic manner without the overhead of arranging live interviews.

An application's architecture is frequently refactored after deployment to accommodate its users' evolving needs. However, we currently lack a repeatable, consistent method to teach high-level collaborative design skills. Drawing on the serious play framework, we advance an existing analog exercise for scaffolding collaborative design using a new system: the LLM-managed application overview. From an instructor prompt, the system generates an overview detailing an entire application using CRC cards -- common industry design aids that forego any code or implementation detail. Students individually edit the cards to redesign the application's architecture, while the system simulates the effects of these edits by updating emulated code metrics and estimating redesign cost. Returning to their teams, students discuss the cost and complexity of their designs before selecting and refining a single solution. By the activity's end, the students will have practiced all the design skills necessary for a months-long cycle of development, without the students or the instructor manually managing any implementation details.

Parsons Problems and Faded Parsons Problems have been shown to be effective in helping students in programming courses transition from passive learning, such as lectures or textbooks, to active learning in the form of writing code. We present FPPgen, an authoring system that largely automates the conversion of existing open-ended code-writing exercises to Faded Parsons Problems (FPPs). FPP solutions can be machine-checked using either spec-based autograding, in which student solutions are evaluated against instructor-provided test cases, or mutation-based autograding, in which students produce one or more unit tests that are evaluated using mutation testing. Our system allows creating exercises that rely on complex libraries and helper functions, such as student code intended to be run as part of a complex framework-based application. Our system also gracefully supports cumulative multi-part problems, in which later parts build on earlier parts. Python and Ruby exercises are currently supported, but FPPgen is language-agnostic and adding autograders for other languages is straightforward. In our experience so far, instructors can draft simple questions in less than an hour and mutation-based questions in about two hours as open-ended coding questions, and student helpers can use our tools to convert these to FPPs in less than an hour. FPPgen is in active use in both beginning and advanced large-enrollment programming courses in a CS undergraduate program at a large US university.

Testing and test-writing are key skills for software engineers. Yet most CS curricula spend insufficient time on testing, and some studies have even found that graduating CS students enter developer jobs without these skills. We argue that test writing is a programming pattern that, at least when going beyond simple input/output test cases, is new and unfamiliar to most students, so that teaching test-writing requires not only teaching the strategic concepts of thinking about testing, but also how to instantiate the "arrange--act--assert" pattern of which all tests consist. Teaching how to recognize and instantiate this pattern is complicated by having to learn how to use testing frameworks and libraries---essentially a syntactic obstacle. Faded Parsons Problems (FPPs) have been shown to be a novel and effective type of exercise for exposing students to programming patterns by varying the amount of scaffolding provided. FPPs give similar learning gains to code-writing exercises but are preferred by students, and can be designed to "scaffold away'' some syntactic obstacles that can impede students' ability to become fluent in test-writing. To our knowledge, neither FPPs nor the original Parsons Problems have previously been proposed to teach advanced programming patterns to advanced students. We present our design of a system for creating variably-scaffolded test-writing exercises in the form of FPPs, including autograding tests using existing autograding solutions augmented with techniques from mutation testing.