Preparing university students to build privacy-preserving systems requires preparing them to design around societal contexts and stakeholders. While legislation such as GDPR and CCPA provide regulatory frameworks for such design, discussions of privacy and stakeholder values can be fairly abstract for students. From an educational perspective, teaching abstract concepts such as the "right to be forgotten" in the concrete context of technical implementation can help students grapple with what these concepts mean in practice. This paper proposes a framework for designing technical assignments that ask students to resolve tensions between conflicting stakeholders while implementing a specific technical feature. We describe a privacy-facing assignment for a second-year introductory computer systems course, and explore its efficacy. We find that students make different design choices and implement for different values based on the specific stakeholder conflict with which they work. We also find that the assignment design engages students in thinking about how abstract values affect technical design decisions in the context of privacy.

Users often struggle with cloud file-sharing applications. Problems appear to arise not only from interface flaws, but also from misunderstanding the underlying semantics of operations like linking, attaching, downloading, and editing. We argue that these difficulties echo long-standing challenges in understanding concepts in programming languages like aliasing, copying, and mutation. We begin to examine this connection through a formative user study investigating general users' understanding of file sharing. Our study casts known misconceptions from the programming-education literature into semantically-similar cloud file-sharing tasks. It also uses tasks that echo two kinds of analyses used in programming-education: tracing and programming. Our findings reveal widespread misunderstandings across several tasks. We also develop a formal semantics of cloud file-sharing operations, reflecting copying, referencing, and mutating shared content. By explicating the semantics, we aim to provide a formal foundation for improving mental models, educational tools, and automated assistance. This semantics can support applications including trace checking, workflow synthesis, and interactive feedback.

Problem planning is a fundamental programming skill, and aids students in decomposing tasks into manageable subtasks. While feedback on plans is beneficial for beginners, providing this in a scalable and timely way is an enormous challenge in large courses. Recent advances in LLMs raise the prospect of helping here. We utilize LLMs to generate code based on students' plans, and evaluate the code against expert-defined test suites. Students receive feedback on their plans and can refine them. In this report, we share our experience with the design and implementation of this workflow. This tool was used by 544 students in a CS1 course at an Austrian university. We developed a codebook to evaluate their plans and manually applied it to a sample. We show that LLMs can play a valuable role here. However, we also highlight numerous cautionary aspects of using LLMs in this context, many of which will not be addressed merely by having more powerful models (and indeed may be exacerbated by it).

Program planning is the process of splitting a problem description into subtasks that can be solved independently, then composed into a solution. While much has been written about planning since the 1980s, little research looks at modern contexts such as programs to process data tables. Tool support for this sort of planning is even rarer. As part of a project to develop such tools, we have run two studies to try to identify steps, representations, and interactions that would support novice university students in planning and programming multi-task programs that process data tables. This experience report describes our observations so far, while also raising questions about how to make planning useful for students.

Teaching computation in science courses can enhance science education, but doing so requires that teachers expand the vision of their discipline beyond the traditional view of science presented in most curricula. This article describes a design-based research (DBR) program that included collaboration among high school teachers and professional development leaders in physics and computer science education. Through three years of professional development and teacher-led development, field testing, and refinement of integrated curricular resources, we have combined instructional modeling practices, physical lab materials, and computer programming activities. One of the outcomes is a co-created framework for the integration of computational modeling into physics that is sensitive to teachers’ interests and expressed needs in addition to learning goals. This framework merges two evidence-based approaches to teaching: Bootstrap:Algebra, a web-based computing curriculum that emphasizes using multiple representations of functions and scaffolds that make the programming process explicit, and Modeling Instruction in physics, an approach that emphasizes the use of conceptual models, modeling practices and representational tools. In doing so, we uncover the need to balance teachers’ visions for integration opportunities with practical instructional needs and emphasize that frameworks for integration need to reflect teachers’ values and goals.

students to learn in order to succeed in an increasingly data-driven world. Foundational data literacy skills currently live in a number of subjects across K-12 (e.g., data collection and analysis in science classes, statistical calculations in mathematics/statistics, data visualization and communication in civics/social studies), however, a growing number of schools and districts are introducing stand-alone data science (DS) courses. Given the centrality of computing and programming in the contemporary practice of DS, many of these courses include topics historically reserved for computer science (CS) classes. Further, many CS courses include dedicated time for DS topics (e.g., AP Computer Science Principles' unit on Data). In many ways, DS educators and CS educators are working towards the same ends in complementary ways. However, at other times, the two disciplines are in tension, especially given the scarcity of time in K-12 student schedules for non-core subjects. This panel will explore what DS education and CS education can learn from each other, how each can contribute and advance the goals of the other, and how these two intertwined disciplines can productively live alongside each other in K-12 settings.

When novice programming students already know one programming language and have to learn another, what issues do they run into? We specifically focus on one or both languages being functional, varying along two axes: syntax and semantics. We report on problems, especially persistent ones. This work can be of immediate value to educators and also sets up avenues for future research.

Abstra t. Fairy le dete tion, a ore problem in model he king, is solvable in linear time in the size of the design model using an expli itstate representation. Existing y le-dete tion algorithms for symboli model he king are quadrati or n log n time in the worst ase and often ineÆ ient in pra ti e. Whi h default symboli y le-dete tion algorithm to implement in model he kers remains an open question. We ompare several su h algorithms based on the numbers of external and internal iterations and the numbers of image operations that they perform on both randomly-generated and real examples. Unlike re ent work by Ravi, Bloem, and Somenzi, we on lude that model he kers need to implement at least two generi y le-dete tion algorithms: the traditional EmersonLei algorithm and one that evolved from our study, originally due to Hojati et al. We demonstrate that these two algorithms are omplementary, as the latter algorithm is provably in omparable to Emerson-Lei's and often dominates it in pra ti e.

Myriad projects and efforts are underway to infuse more content on ethical and socially-responsible computing into Computer Science curricula. Talks and papers on these projects largely focus on case studies and examples that can be included in assignments. This paper instead takes a pedagogic perspective. Drawing on papers on ethics-based design from multiple computing disciplines, as well as frameworks for identifying security threats, we designed a framework for identifying a variety of social threats in the kinds of programs that university students develop in their first two years of study. The framework is unique in centering around architectural components of applications, rather than stakeholders and values.

The first hybrid North American ICER was held in Chicago, Illinois, USA, from August 7-11, 2023. A total of 194 participants attended ICER, including 172 physically and 22 virtually. Attendance was roughly split between students and professionals, with over 100 professionals and over 80 students. The program consisted of three full days due to a record number of papers, lightning talks, and poster sessions. This represented a more than 50% increase in the number of each type compared with last year.

Model-finders, such as SAT/SMT-solvers and Alloy, are used widely both directly and embedded in domain-specific tools. They support both conventional verification and, unlike other verification tools, property-free exploration. To do this effectively, they must produce output that helps users with these tasks. Unfortunately, the output of model-finders has seen relatively little rigorous human-factors study. Conventionally, these tools tend to show one satisfying instance at a time. Drawing inspiration from the cognitive science literature, we investigate two aspects of model-finder output: how many instances to show at once, and whether all instances must actually satisfy the input constraints. Using both controlled studies and open-ended talk-alouds, we show that there is benefit to showing negative instances in certain settings; the impact of multiple instances is less clear. Our work is a first step in a theoretically grounded approach to understanding how users engage cognitively with model-finder output, and how those tools might better support users in doing so.

On a growing number of campuses, data science programs offer introductory courses that include a non-trivial amount of programming. The content of such courses overlaps that of traditional computer science introductory courses, but neither course subsumes the other. This talk argues that a common introductory course that covers both data science and data structures supports students and provides curricular flexibility, while also bringing social impacts of computing into the early curriculum. We’ll discuss both the design and implementation of such a course, including the programming language features that support it and the educational research that informs it.

We propose that secondary-school data-science curricula should be based on four key ingredients: two are technical (programming and statistics, with visualization sitting at their intersection), while two are human-facing (meaningful domains, and civic responsibility). We describe their relationship and argue for their importance. Based on this, we then present the Bootstrap:Data Science curriculum, designed for integration into multiple disciplines and settings. It achieves this by (a) being designed as a set of remix-able lessons, and (b) letting classes and students choose personally meaningful datasets. We also initiate the process of evaluating this curriculum. We create two assessment instruments, one focused on learning and the other on personalization and engagement. We provide very preliminary data gathered from students and teachers.

The 18th annual ACM Conference on International Computing Education Research (ICER) will be hosted by Università della Svizzera italiana (USI) in beautiful Lugano, Switzerland. This hybrid conference will take place August 7-11, 2022. You can participate physically by traveling to Lugano or virtually through our conference platform.

Many efforts are underway to have computing curricula prepare students to anticipate adverse social impacts of computing. Much of the attention currently focuses on introductory CS courses and machine learning courses, often framed around bias that arises around algorithmic decision-making systems. The presenters on this panel have instead focused on ways to weave responsible-computing content into data structures and introductory algorithms courses. They have done so at different levels, ranging from second-semester introductory courses (so-called CS2) up through upper-undergraduate or early graduate courses. Each panelist will describe their perspective on how responsible computing fits into their course and present an illustrative assignment or lecture from their course. The goal of the session is to inspire other CS faculty to work similar content into corresponding courses at their own institutions, while also fostering a community of practice for responsible computing in core CS courses beyond machine learning.

SIGCSE is packed with teaching insights and inspiration. However, we get these insights and inspiration from hearing our colleagues talk about their teaching. Why not just watch them teach? This session does exactly that. Six exceptional educators will present their favorite piece of innovative lecture content just as they would to their students. The moderator, Colleen Lewis, will describe the central pedagogical move within the innovation and how this connects to education research. The goal of the session is to inspire SIGCSE attendees by highlighting innovative instruction by exceptional educators. The specific content of the innovative instruction may be applicable for some attendees, and the discussion of the underlying pedagogical move within each innovation can be applied across the attendees' teaching.

Integrating computing into other subjects promises to address many challenges to offering standalone CS courses in K-12 contexts. Integrated curricula must be designed carefully, however, to both meet learning objectives of the host discipline and to gain traction with teachers. We describe the multi-year evolution of Bootstrap, a curriculum for integrating computing into middle- and high-school mathematics. We discuss the initial design and the various modifications we have made over the years to better support math instruction, leading to our goal of using integrated curricula to cover standards in both math and CS. We provide advice for others aiming for integration and raise questions for CS educators about how we might better support learning in other disciplines.

Motivation. Higher-order functions are a standard and increasingly central component in many kinds of modern programming, including data science and Web development. Yet little research has been devoted to student learning or understanding of this topic. Objectives. We conducted formative research on how well students are able to correlate higher-order functions with their input–output behavior. We also wanted to evaluate a variety of techniques for assessing their understanding. Method. We created a series of instruments in which students were given either concrete input/output examples or abstracted diagrams of list transformations. Students were asked to cluster or classify these examples by their behavior, sometimes against a concrete list of higher-order functions and sometimes free-form. We administered these over the course of a month, and then once again three months later. Results. We find that students initially have several difficulties with clustering higher-order function examples. With different instruments, we find that students are later able to do quite well, largely avoiding large-scale errors but making several small-scale ones. We also find some evidence of growth in their thinking about these operations. We also find weaknesses in the nature and order of techniques we used. Discussion. Higher-order functions deserve far more attention than they have been paid in the literature on programming education. Their increasing use in several important domains makes this need critical. Our proposed methods for conducting such research are another contribution of this work. Our findings and methods should also be relevant for exploring how students understand libraries and APIs.