Web applications are increasingly the main way to create user interfaces, and they are often the most common software beginners have encountered. However, web development relies on concepts like HTML, CSS, JavaScript, and backend technologies, which are challenges beyond the scope of an introductory course. Additionally, many features of modern web frameworks conflict with CS1 principles, such as avoiding global mutable state and promoting test-driven development. Consequently, web development is rarely integrated into CS1 courses, despite its motivational potential.

Despite rising enrollment, CS Education struggles with training adequate educators, leading to increased teaching loads. Open-source teaching materials alleviate this by streamlining course preparation. Yet, there is a scarcity of free, open curricula that offer a contemporary coding experience while covering CS fundamentals. To address this gap, we introduce the CS1 Python Bakery curriculum with a "Batteries Included" approach, aiming to furnish instructors with comprehensive teaching resources. This curriculum refines an earlier open-source CS1 with detailed lesson plans, slides, rubrics, reference answers, student answers, and more. We present the learning content in a cross-platform, autograded textbook format and embrace modern Python features such as Dataclasses and static types. We deployed the curriculum in multiple university CS1 courses and collected data on the tradeoffs of our approach. This paper offers a thorough self-assessment based on student learning outcomes, code snapshot analyses, and reflection via the TEC Rubric for curriculum evaluation. Although we improved teacher accessibility, the change in student learning outcomes was unexpectedly minimal. Recognizing room for advancement, we conclude with recommendations for our next iteration to emphasize Equity, Community, and Identity.

The ever-increasing enrollments in programming courses has driven the need for sophisticated grading tools that can provide students with precise, insightful, and timely feedback. This SIGCSE workshop presents an interactive session on our powerful, open-source Python autograding framework, Pedal. As a free library, Pedal is available on a wide range of grading platforms, including GradeScope and BlockPy - anything that allows installation of a pure Python library. Pedal supports but goes beyond traditional unit testing, providing advanced code analysis techniques, such as type checking, liveness checking, structural code pattern matching, and more. Pedal has a large collection of assertions to evaluate dynamic program traces, query the Abstract Syntax Tree, re-execute student code under varying conditions, mock inputs, and capture outputs. Every feedback message is treated as a first-class object, empowering educators to fine-tune feedback as desired. Pedal is not just a toolset but a comprehensive pipeline optimized for feedback selection, resolution, and evaluation. With functionalities like command-line batch execution, exhaustive metadata tracking, and A/B testing, educators and researchers can analyze and refine their feedback strategies. With Pedal's successful deployment across multiple courses and institutions over the years, this workshop will offer attendees firsthand experience and a plethora of real-world examples. By the end of this workshop, participants will be proficient in leveraging Pedal, even venturing into the realm of creating interactive activities using the framework.

As undergraduate computer science enrollments continue to grow, individualized instructor attention becomes increasingly scarce. The impact of social distance between students and their teachers is particularly apparent in large introductory classes, exacerbated by students' lack of common prior experience in computer science. Some institutions remedy class size and experience gaps by hiring advanced undergraduate students as teaching assistants for their introductory courses. However, without the resources to carefully hire, train, and manage undergraduate teaching assistants (uTAs) during the semester, their potential as trustworthy peer mentors and helpful tutors often goes unrealized. This poster presents details of the uTA hiring process, training course, and management strategies used during the 2022-2023 academic year for the introductory computer science courses at the University of Delaware (UD), a large, public, research-focused institution. This system was designed for introductory CS classes, with the goals of low instructor overhead, long-term scalability, and the development of empathetic teaching assistants who could motivate students toward successful learning. Highlights of the system include a hiring process that considers candidates' personality and enthusiasm alongside their technical skills, asynchronous training provided through the university's learning management system, and the use of a head uTA to manage other staff members. Following the implementation of these policies, instructors and uTAs alike reported positive experiences compared to previous semesters without significant changes to students' learning outcomes.

In our previous research we found that teaching novice programmers introductory programming in Java using subgoal labels led to deeper knowledge [2] and increased persistence for students potentially at risk of dropping out or failing their first undergraduate course in CS [3]. Subgoals are an instructional tool that is designed to bridge the gap between novices and experts, i.e., students and instructors. Experts often have difficulty explaining concepts at a level that novices understand because they have automatized much low-level knowledge. The task analysis used to identify subgoals makes this knowledge explicit. Subgoals are often expressed to students through subgoal-labeled worked examples that explicitly state the conceptual knowledge expressed through examples. This instructional design of examples allows students to see past superficial details of the example to the structural problem-solving procedure being exemplified [3].

During the Spring 2021 semester, stuck in quarantine due to the ongoing global pandemic, I decided I needed to do something completely different with my undergraduate-level Algorithms course. Tired of teaching via Zoom to little boxes, I recreated the entire course, inspired by my love of Escape Rooms and Alternate Reality Games. Connecting Canvas, Ohyay, and GradeScope with my own custom technology, I weaved a zany, video-based narrative whereby students would inevitably have to save me from my own Frankenstein's monster: an evil Intelligent Tutoring System named "AlgoTutorBot" who threatens not only the course, but the entire world! The learning experience incorporates a range of engaging assignments, available to external adopters. This includes not only programming problems and conventional algorithmic logic problems, but also a novel web application for experimenting with runtime analysis, an interactive point-and-click adventure for practicing graph algorithms, and an assignment framework for concretizing students' problem-solving process into tangible artifacts. There are also smaller assignments that would be easily adopted into a regular Algorithms course. This demo will show off the final version of the course and describe the lessons learned along the way. All resources and a walkthrough video of the experience are available at https://acbart.github.io/algotutorbot/

Subgoal labeling is an instructional design framework for breaking down problems into pieces that are small enough for novices to grasp, and often difficult for instructors (i.e., experts) to articulate. Subgoal labels have been shown to improve student performance during problem solving in many disciplines, including computing. Improved student performance occurs because subgoal labels improve student transfer and retention of knowledge. With support from NSF (DUE-1712025, 1712231, 1927906, 2110156, 2111578), subgoal labels have been identified and integrated into a CS1 course (variables, expressions, conditionals, loops, arrays, classes) and an e-book has been created on the Runestone platform to enable students to complete practice problems using the subgoals. This workshop will introduce participants to the materials and demonstrate how the subgoal labels and worked examples are integrated throughout the course. Materials include nearly 50 worked examples and 300 practice problems that increase in complexity and difficulty within each topic. The materials are designed to be integrated into CS1 courses as homework or classroom examples and activities. Assessment of topics using subgoal labels will also be discussed. Participants will leave with access to the e-book containing worked examples and practice problems for common topics in an imperative Java-based CS1 and will also engage in an activity where they create an example for their own course using subgoal labels.

As a solution to the challenge of motivating and retaining undergraduate introductory computer science students, game development and image manipulation are popular motivational contexts in introductory computer science (CS1) classrooms. However, there has been little research on how to empirically make the required code libraries friendly for novice learners. This work explores how novice preconceptions of vocabulary and code structure should affect Designer (https://krishols.github.io/designer), our new pedagogical interactive graphics Python library. Preconceptions were measured through two successive surveys. Survey responses were analyzed for differences between survey version and students' prior programming experience. Although specific preconceptions varied based on students' degrees of prior programming experience, students do tend to prefer simple vocabulary. Motivated to fill a gap in the libraries available for early Python education, these results were used to guide the development of Designer. Alongside the library, this work provides three successive CS1 lesson plans developed using the Use-Modify-Create lesson progression. Future work is in progress to measure and improve the usability of Designer and its resources through further collaboration with students, to ultimately create a truly novice friendly game and graphics API.

This demo introduces attendees to Pedal, a Python framework that streamlines the process of authoring semi-automated feedback on students? Python code. As a pure Python package, Pedal is compatible with a wide range of autograding platforms, including GradeScope, VPL, WebCAT, and BlockPy - as long as the platform allows package installation, Pedal should work. Pedal is a collection of modular program analysis tools exposed with a declarative interface, built around a centralized infrastructure. These tools include a sandboxed execution environment for running students' code with enhanced tracebacks, pattern matching syntax for specifying common student mistakes, basic type inference and flow analysis, random question pools, and a library of over 60 high-level, pedagogically-oriented assertions. Pedal's model for these tools synthesizes the detection of conditions and their instructor-mediated responses, encapsulated into dedicated feedback functions that can be tracked and modified as first-class objects. Our goal is to elevate Feedback with Software Engineering and Instructional Design practices, to become a central part of your course's development rather than an afterthought. Our toolchain also includes command lines utilities for unit testing your feedback to verify behavior and analyze collected programming snapshot data. Our hope is that adoptees will find that Pedal expands the power of their autograder and opens new avenues of research.

Pattern-based feedback detects incorrect code patterns in students' programs and provides feedback that can be personalized to the details of the matched code. Currently, a high level of instructor effort is required because the pattern detection must be expressed using complex programmatic interfaces. A specification language for pattern-based feedback is presented that mitigates this cost. Examples from actual student code illustrate the language's design and expressiveness. The language's implementation and testing is briefly described. Reflections are given on the the language design, where it is effectively used, and lessons learned from experience with its use. While our implementation is targeted at Python, other programming languages could be targeted using a similar approach.

In this paper, we introduce ProgSnap2, a standardized format for logging programming process data. ProgSnap2 is a tool for computing education researchers, with the goal of enabling collaboration by helping them to collect and share data, analysis code, and data-driven tools to support students. We give an overview of the format, including how events, event attributes, metadata, code snapshots and external resources are represented. We also present a case study to evaluate how ProgSnap2 can facilitate collaborative research. We investigated three metrics designed to quantify students' difficulty with compiler errors - the Error Quotient, Repeated Error Density and Watwin score - and compared their distributions and ability to predict students' performance. We analyzed five different ProgSnap2 datasets, spanning a variety of contexts and programming languages. We found that each error metric is mildly predictive of students' performance. We reflect on how the common data format allowed us to more easily investigate our research questions.

This paper describes Pedal, an innovative approach to the automated creation of feedback given to students in programming classes. Pedal is so named because it supports the PEDAgogical goals of instructors and is an expandable Library of components motivated by these goals. Pedal currently comes with components for type inferencing, flow analysis, pattern matching, and unit testing to provide an instructor with a rich set of resources to use in authoring and prioritizing feedback. The larger vision is the loosely-coupled architecture whose components can be readily expanded or replaced. The Pedal library components are motivated by a study of contemporary automated feedback systems and our own experience. Pedal's components are described and examples are given of Pedal-based feedback from three different introductory classes at two different universities. The integration of Pedal into several programming and autograding environments is briefly described.

Packaging materials is a generalized term to capture a broad array of tasks (creating, revising, sharing, finding, crediting, etc.) for materials such as assignments, teacher notes, and evaluation data. Substantial effort has gone into creating materials over the years, but the community still struggles to find ways to effectively manage these. This BoF provides an opportunity to identify needs, concerns, prior efforts, and future plans. A primary goal is the formation of a Working Group tasked to develop a standard for curricular material creation and sharing, joining with broader efforts of standardization (e.g., CSSPLICE) and existing initiatives for creating repositories, tools, and materials.

The SIGCSE-Members listserv has been archiving posts by the Computer Science Education community for the past 22 years. This paper characterizes the post collection, in order to better understand the nature of the community from a quantitative perspective. We apply a number of email mining techniques, including a topical analysis through N-grams. Threads, posters, and posts are characterized in terms of duration and temporally. We also demonstrate how emails from the listserv can be successfully classified using machine learning algorithms, and report on an unsuccessful attempt to predict thread popularity. All of the scripts we used to collect, process, and analyze the data are freely available in the hopes that other researchers will replicate, refine, and extend our results.

Rising enrollments and limited instructor resources underscores the growing need for reusable, scalable curriculum. In this paper, we describe an open-source introductory Python course for non-Computer Science majors in STEM, designed following best practices of Instructional Design (a process similar to Software Engineering). The created resources include 234 learning objectives, 51 lesson videos, 45 lecture slides, 170 programming problems, 281 quiz questions, 6 unit tested projects, and 4 ethical prompts. A teaching field guide has also been produced as a result of this effort, documenting how to deploy this curriculum on a daily level. We describe our experiences deploying over two semesters. The course serviced over 500 students, with 100s in some sections. Along the way, two interventions were conducted in an Action Design Research style: one using Worked Examples, and another using Structured Small Groups. We report on the mixed results of these experiments, plus evaluations of the assignments from student surveys and statistical measures of item effectiveness. Finally, we describe lessons learned when following Instructional Design processes.

The feedback given to novice programmers can be substantially improved by delivering advice focused on learners' cognitive misconceptions contextualized to the instruction. Building on this idea, we present Misconception-Driven Feedback (MDF); MDF uses a cognitive student model and program analysis to detect mistakes and uncover underlying misconceptions. To evaluate the impact of MDF on student learning, we performed a quasi-experimental study of novice programmers that compares conventional run-time and output check feedback against MDF over three semesters. Inferential statistics indicates MDF supports significantly accelerated acquisition of conceptual knowledge and practical programming skills. Additionally, we present descriptive analysis from the study indicating the MDF student model allows for complex analysis of student mistakes and misconceptions that can suggest improvements to the feedback, the instruction, and to specific students.

Data science keeps growing in popularity as an introductory computing experience, in which students answer real-world questions by processing data. Armed with carefully prepared pedagogical datasets, computing educators can contextualize assignments and projects in societally meaningful ways, thereby benefiting students' long-term professional careers. However, integrating data science into introductory computing courses requires that the datasets be sufficiently complex, follow appropriate organizational structure, and possess ample documentation. Moreover, the impact of a data science context on students' motivation remains poorly understood. To address these issues, we have created an open-sourced manual for developing pedagogical datasets (freely available at https://think.cs.vt.edu/pragmatics). Structured as a collection of patterns, this manual shares the expertise that we have gained over the last several years, collecting and curating a large collection of real-world datasets, used in a dozen of universities worldwide. We also present new evidence confirming the efficacy of integrating data science in an introductory computing course. As a significant extension of our ongoing work, this study not only validates existing positive assessment, but also provides fine-grained nuance to the potential of data science as a motivational educational element.

Working with real-world data has increasingly become a popular context for introductory computing courses. As a valuable 21st century skill, preparing students to be able to divine meaning from data can be useful to their long-term careers. Because Data Science aligns so closely with computing, many of the topics and problems it affords as a context can support the core learning objectives in introductory computing classes. In many instances, incorporating a real-world dataset to provide concrete context for an activity or assignment can improve student engagement and understanding of the abstract educational content being presented. However, there are many problems inherent to bringing real-world data into introductory courses. How do instructors, with finite amounts of time and energy, find and prepare suitable datasets for their pedagogical needs? Once the datasets are ready, how can students conveniently interact with and draw meaning from the datasets, especially when they are used in complex projects that are typical of later introductory courses? On the other hand, how does an instructor balance the complexities of using real-world datasets in the classroom, making sure that students appreciate the meaningfulness of course activities and their connection to learning objectives? This panel brings together experts with experience in using real-world data in introductory computing courses. Each panelist provides unique perspectives and skills to the problem of preparing, interacting, visualizing, and using pedagogical datasets. This panel should be of particular interest to instructors who are considering integrating current and real-world data into their assignments and projects, and to educational developers who want to create and manage datasets for pedagogical purposes. The panel will follow a conventional format: 5 minutes of introduction, 10 minutes for each panelist to present, and then 30 minutes for audience Q&A.

Collaborative learning can help reduce the anxiety level of learners, improve understanding and thus create a positive atmosphere for learning. This study analyzes students' collaborative learning experiences within small interdisciplinary "cohorts" while learning computational thinking in a university-level class. The cohort allows students from different disciplines to contribute diverse perspectives, socially interact with each other and in turn create situations where two or more students learn together. This study uses both qualitative and quantitative means to explore students' collaborative learning experiences. Ethnographically-informed qualitative data using Stahl's collaborative framework is analyzed. The analysis revealed that most students found the cohort model to be valuable in learning computational thinking by allowing them to ask about and explain problems, especially with students from different disciplines who perceive and explain a problem differently. Quantitative data from a multi-term survey complements and confirms the findings from the qualitative data. Our study helps to inform those teaching foundational computing concepts to a diverse audience of learners.

This paper reports on a systematic method used to improve an existing unit of instruction. The method is distinctive in combining steps of instructional design with "knowledge components" from a cognitively-based framework of learning. Instructional design is used to develop assessment instruments that incorporate information about student misconceptions. The method uses the assessment instruments to evaluate student performance and learning gains, while statistical analysis evaluates the quality of the instruments themselves using measures of difficulty and discrimination. Fine-grain insight into possible improvements is enabled by the knowledge components implicated by the assessment. The method is illustrated and evaluated by applying it to a unit of instruction on collection-based iteration in a computational thinking class. Data gathered during this evaluation highlights a number of opportunities within the unit to refine the instruction.

Introductory non-major learners face the challenge of mastering programming fundamentals while remaining sufficiently motivated to engage with the computing discipline. In particular, multi-disciplinary students struggle to find relevance in traditional computing curricula that tend to either emphasize abstract concepts, focus on entertainment (e.g., game and animation design), or rely on decontextualized settings. To address these issues, this demo introduces BlockPy, a web-based environment for Python (https://blockpy.com). The most powerful feature of BlockPy is a dual text/block view that beginners can freely move between, using advanced Mutual Language Translation techniques. The environment contextualizes introductory programming with data science by integrating real-world data including weather reports, classic book statistics, and historical crime data. A fusion of Blockly and Skulpt, the entire interface runs locally with no need for server sandboxing. BlockPy is also a platform for interactive, guided practice problems with automatic feedback that scaffolds learners. This demo will walk through the novel features of BlockPy's environment, including the instructor's perspective of creating new problems and how BlockPy can be embedded in modern LTI-compatible learning management systems. BlockPy is available online for free and is open-sourced on GitHub. This material is based on work supported by the NSF under Grants No. DGE-0822220, DUE-1444094, and DUE-1624320.

To successfully bring introductory computing to non-CS majors, one needs to create a curriculum that will appeal to students from diverse disciplines. Several educational theories emphasize the need for introductory contexts that align with students' long-term goals and are perceived as useful. Data Science, using algorithms to manipulate real-world data and interpreting the results, has emerged as a field with cross-disciplinary value, and has strong potential as an appealing context for introductory computing courses. However, it is not easy to find, clean, and integrate datasets that will satisfy a broad variety of learners. The CORGIS project (https://think.cs.vt.edu/corgis) enables instructors to easily incorporate data science into their classroom. Specifically, it provides over 40 datasets in areas including history, politics, medicine, and education. Additionally, the CORGIS infrastructure supports the integration of new datasets with simple libraries for Java, Python, and Racket, thus empowering introductory students to write programs that manipulate real data. Finally, the CORGIS web-based tools allow learners to visualize and explore datasets without programming, enabling data science lessons on day one. We have incorporated CORGIS assignments into an introductory course for non-majors to study their impact on learners' motivation, with positive initial results. These results indicate that external adopters are likely to find the CORGIS tools and materials useful in their own pedagogical pursuits.

A key retention issue when educating computing novices is ensuring that the frustrations of mastering programming fundamentals do not demotivate and discourage students from studying the discipline. In particular, non-CS majors often struggle to find relevance in traditional computing curricula that tend to either emphasize abstract concepts, focus on non-practical entertainment (e.g., game and animation design), or rely on decontextualized settings. To address these issues, this paper introduces BlockPy, a block-based environment for Python (http://www.blockpy.com). BlockPy is a web-based, open-access programming environment that supports introductory programming with an emphasis on data science. It promotes long-term transfer by scaffolding an introduction to textual programming (Python) through a block-based programming view, ideal for beginners of any background. By supporting the latest Learning Tools Interoperability (LTI) standards, BlockPy is designed to support both informal learners and formal class settings. Specifically, it can be configured to provide guiding feedback for its interactive programming problems, so as to support learners at their own pace. The results from a pilot study of the initial deployment and utilization of BlockPy indicate the potential of the environment to address many of the problems faced by novice learners.

Software Engineers apply systematic techniques to formalize requirements, build tests, and plan out complex architectures. However, few Computer Science Educators bring the same rigorous methods to the design of their students' learning experiences. Educational theories of Instructional Design (compatible with a wide range of popular educational theories) bridge this gap by emphasizing meaningful assessment, identification of instructional objectives, and analysis of the learners; unfortunately, these theories have been neglected within Computer Science Education. I have applied the Dick & Carey Model of Instructional Design in two formal case studies to create new learning modules with extensive documentation, detailed components, and clear results. In fact, my formal evaluations of my materials with real learners suggest that students had average learning gains of up to 43%. More crucially, however, the model provided key opportunities to improve the instruction a priori and posteriori. My major contribution in this research is not the generation of new instructional materials, but the demonstration of the raw potential of this methodology for curriculum development.

This special session will explore practical results from the educational theory of Instructional Design (ID), with particular focus on the widespread similarities between a process for creating successful courses and a process for creating successful software. We present a small set of specific practices that should be easy for CS educators to adopt. In particular, the session will cover the popular Dick & Carey model, meant for beginners to ID. This model helps instructors rigorously define who they will teach to, what they will teach, how they will assess, and (only then) how they will teach. The approach is parallel to Software Engineering techniques such as Test-Driven Development, Requirements Engineering, and Iterative Development.

This paper describes the design and initial assessment of a general education course in computational thinking for non-computer science majors. The key elements of the course include multidisciplinary cohorts to achieve learning across contexts, multiple languages/tools, including block-based and textual programming languages, repeated exposure to the underlying computational ideas in different forms, and student-defined projects using real world ("big") data to heighten motivation through self-directed contextualized learning. The preliminary multi-methods assessment shows that the course engendered high levels of motivation, achieved key objectives for learning in and across contexts, largely affirmed the choice of languages/tools, and supported, though less strongly than anticipated, the motivational effects of real-world data

As Computational Thinking becomes pervasive in undergraduate programs, new students must be educated in meaningful, authentic contexts that they find both motivating and relatable. I propose working with big data as a novel context for introductory programming, authentic given its importance in diverse fields such as agriculture, history, and more. Big data is considered difficult to use because of its inherent technical obstacles. To overcome these difficulties, I introduce a new project: CORGIS - a "Collection of Real-time, Giant, Interesting, Situated Datasets". The CORGIS project comprises a collection of libraries that provide an interface to big data for students, architectures for rapidly enabling new datasets, and a web-based textbook platform for disseminating relevant course materials. This textbook features an online block-based programming environment, real-time collaborative text editing, and continuous server-side storage. In this poster, I describe the educational theory guiding this work, the novel technolgy created and deployed, and the initial, promising results.

This workshop introduces participants to CORGIS, a technology developed under the auspices of an NSF-funded project at Virginia Tech. The CORGIS Datasets Project comprises a software architecture framework and carefully engineered client libraries through which students can access either large datasets or those generated by real-time web services from domains, including weather reports, stocks, earthquakes, and news updates. The CORGIS technical scaffolding gradually introduces students to some of the most vexing complexities of distributed computing. To support the diverse needs of computing educators when teaching introductory CS classes, each CORGIS dataset is available in Python, Java, and Racket, with compatibility on key platforms. The dataset libraries are available through an online curated gallery, designed to be easily adapted to instructors' specific academic needs, including the ability to rapidly prototype new CORGIS libraries. With CORGIS, computing educators can introduce important big data or real-time distributed computing concepts without overwhelming students with the low-level details that working with such data typically requires.

While computing is becoming increasingly distributed, programming projects in introductory classes remain mostly divorced from the student's day-to-day computing experiences. These experiences entail interacting with real-time Web-based data from sources that include weather reports, news updates, and restaurant recommendations. The disconnect between student experiences and the content of their programming projects is known to drive some students away from computing. In addition, to adequately prepare students for the realities of modern software engineering, educators should introduce issues pertaining to distributed computing early in the curriculum. To address these problems, we have created RealTimeWeb - an architectural framework that makes real-time web data accessible for introductory programming projects. The framework effectively introduces important real-time distributed computing concepts without overwhelming students with the low-level details that working with such data typically requires. Preliminary results indicate that our approach can be effective in the context of a typical CS2 course, and that real-time data is relevant to students. RealTimeWeb libraries and associated resources are publicly available for use, with multiple language bindings to many real-time data sources. A rapid-prototyping tool available through the project's website facilitates the development of client libraries with easily accessible APIs for new real-time Web-based data sources.

This workshop introduces participants to RealTimeWeb, a technology developed under the auspices of an NSF-funded project at Virginia Tech. RealTimeWeb is a software architecture framework that makes real-time web data, such as weather reports, news updates, and restaurant recommendations, accessible for introductory programming projects. The presented technology offers technical scaffolding for the students to gradually ease into (or completely circumvent if appropriate) some of the most vexing complexities of distributed computing. At the heart of RealTimeWeb are carefully engineered client libraries through which students can access the data provided by real-time web services. To support computing educators teaching introductory CS classes in a variety of programming languages, each library is available in Python, Java, and Racket, with compatibility on key platforms, including Android. These libraries are readily available through an online curated gallery, designed to be quickly adapted to instructors' specific academic needs. This gallery also provides a tool for rapidly prototyping new libraries based on our framework. RealTimeWeb enables computing educators to introduce important real-time distributed computing concepts without overwhelming students with the low-level details that working with such data typically requires. This workshop introduces RealTimeWeb via a hands-on approach by introducing participants to the core functionality of our architectural framework and client libraries. The workshop proceeds in three parts in which we: (1) present RealTimeWeb by working through a case study of creating a programming project in a typical CS 2 course; (2) demonstrate how the framework can be used to rapidly prototype a new library of the participants' choice; and (2) critically discuss the technology in small and large groups.