Odds are we've all used (or tried!) quite a few tools to facilitate efficiency inside and outside of the classroom and empower students to learn more effectively, whether on campus or off. Some of those tools are perhaps homegrown and unique to one's own institution, but freely available educational technologies abound as well, some in the cloud, some for Macs and PCs, some open-source. And quite a few commercial tools offer free or discounted educational plans as well. In this BoF, we'll begin with a whirlwind tour of the tools we ourselves use, including artificial intelligence (AI), identifying the problems they solve and how well, then quickly open the floor to everyone to share their favorites as well. Along the way, we'll jot down every tool mentioned and share the results. With educational technology an evergreen landscape, this year's list will surely be different from last! Attendees should exit this session with a better understanding of the current landscape, familiarized with innovations they can bring back to their own classes (whether high school, undergraduate, or graduate), without reinventing wheels themselves.

In our introductory computer science course, we face the challenge of supporting a sizable team of undergraduate teaching assistants while fostering both consistency and community. To address this challenge, we implement a cohort-based model for organizing staff, in which Head Teaching Assistants (TAs) take on additional leadership and course logistics responsibilities and lead a small group of four or five other TAs. This model decentralizes communication, granting Head TAs more agency in how they guide their groups while creating smaller communities where staff feel comfortable raising concerns, asking questions, and sharing strategies. In this lightning talk, we will share concrete examples of how cohort meetings have improved information flow, strengthened staff development, and cultivated a greater sense of belonging among teaching staff. Additionally, we will highlight challenges such as uneven dissemination of information across groups and discuss strategies we have implemented to mitigate these issues. Lastly, we will reflect on why we believe this structure offers a scalable and transferable model for other large courses seeking to balance efficiency with community while developing leadership pathways for experienced staff.

Teaching computer science at scale can be challenging. From our experience in CS50, Harvard University's introductory course, we've seen firsthand the impactful role that generative artificial intelligence can play in education. Recognizing its potential and stakes, we integrated OpenAI's GPT into our own teaching methodology. The goal was to emulate a 1:1 teacher-to-student ratio, incorporating ''pedagogical guardrails'' to maintain instructional integrity. The result was a personalized, AI-powered bot in the form of a friendly rubber duck aimed at delivering instructional responses and troubleshooting without giving outright solutions. In this tutorial, we share our journey and offer insights into responsibly harnessing AI in educational settings. Participants will gain hands-on experience working with GPT through OpenAI's latest APIs, understanding and crafting prompts, answering questions using embedding-based search, and, finally, collaboratively building their own AI chatbot. We will also explore the growing landscape of agentic AI tools such as Claude Code, GitHub CoPilot, OpenAI Codex, discussing their applications in educational contexts. Prior knowledge of Python is beneficial but not required, as all demo source code will be provided. Ultimately, we'll not only share lessons learned from our own approach but also equip educators hands-on with the knowledge and tools with which they, too, can implement these technologies in their unique teaching environments.

Odds are we've all used (or tried!) quite a few tools to facilitate efficiency inside and outside of the classroom and empower students to learn more effectively, whether on campus or off. Some of those tools are perhaps homegrown and unique to one's own institution, but freely available educational technologies abound as well, some in the cloud, some for Macs and PCs, some open-source. And quite a few commercial tools offer free or discounted educational plans as well. In this BoF, we'll begin with a whirlwind tour of the tools we ourselves use, including AI, identifying the problems they solve and how well, then quickly open the floor to everyone to share their favorites as well. Along the way, we'll jot down every tool mentioned and share the results. With educational technology an evergreen landscape, this year's list will surely be different from last! Attendees should exit this session with a better understanding of the current landscape, familiarized with innovations they can bring back to their own classes (whether high school, undergraduate, or graduate), without reinventing wheels themselves.

Teaching computer science at scale can be challenging. From our experience in CS50, Harvard University's introductory course, we've seen firsthand the impactful role that generative artificial intelligence can play in education. Recognizing its potential and stakes, we integrated OpenAI's GPT into our own teaching methodology. The goal was to emulate a 1:1 teacher-to-student ratio, incorporating "pedagogical guardrails" to maintain instructional integrity. The result was a personalized, AI-powered bot in the form of a friendly rubber duck aimed at delivering instructional responses and troubleshooting without giving outright solutions. In this tutorial, we share our journey and offer insights into responsibly harnessing AI in educational settings. Participants will gain hands-on experience working with GPT through OpenAI's latest APIs, understanding and crafting prompts, answering questions using embedding-based search, and finally, collaboratively building their own AI chatbot. Ultimately, we'll not only share lessons learned from our own approach but also equip educators hands-on with the knowledge and tools with which they, too, can implement these technologies in their unique teaching environments.

The scalability challenges of code review and pair-programming assessments in large computer science courses, such as CS50 at Harvard University, have opened up opportunities for the application of Generative AI. Leveraging large language models (LLMs), CS50.ai offers a suite of AI-based tools that assist both students and instructors in mastering course material while overcoming the limitations posed by human resource constraints. This demo highlights how generative AI can be employed to conduct code reviews and pair-programming simulations, providing real-time feedback, code explanations, and collaborative programming insights. By integrating these AI tools into students' learning journeys, we aim to mimic the 1:1 interaction between instructor and student, improving both formative and summative assessments. We will showcase how these tools are implemented to scale personalized feedback, ensure academic integrity, and maintain pedagogical efficacy. Our presentation will also reflect on lessons learned from deploying these AI-driven tools in recent course offerings.

In 2023, we developed and deployed AI-based tools in CS50 at Harvard University to provide students with 24/7 interactive assistance, approximating a 1:1 teacher-to-student ratio. These tools offer code explanations, style suggestions, and responses to course-related inquiries, emulating human educators to foster critical thinking. However, maintaining alignment with instructional goals is challenging, especially with frequent updates to the underlying large language models (LLMs). We thus propose a continuous improvement process for LLM-based systems using a collaborative human-in-the-loop approach. We introduce a systematic evaluation framework for assessing and refining the performance of AI-based tutors, combining human-graded and model-graded evaluations. Using few-shot prompting and fine-tuning, we aim to ensure our AI tools adopt pedagogically sound teaching styles. Fine-tuning with a small, high-quality dataset has shown significant improvements in aligning with teaching goals, as confirmed through multi-turn conversation evaluations. Additionally, our framework includes a model-evaluation backend that teaching assistants periodically review, ensuring the AI system remains effective and aligned with instructional objectives. This paper offers insights into our methods and the impact of these AI tools on CS50 and contributes to the discourse on AI in education, showcasing scalable, personalized learning enhancements.

We present the results of multi-year collaborations among Harvard University, Yale University, and Miami Dade College in which students on all three campuses took the same introductory course in computer science. We present our respective motivations therefor and discuss how the course, CS50, has been both adopted and adapted for localized needs and constraints. Faculty at Harvard provided the course's lectures on video as well as assignments, while faculty at Yale and Miami Dade provided localized support structures, including sections (i.e., recitations) and office hours, with faculty oversight. We argue that this sharing of resources should become more common across otherwise independent campuses so that faculty on each can focus their most precious resource, time, on their own students as well as on other academic pursuits. We offer reassurance that these collaborations have not led to a reduction of resources on any of our campuses. We propose how other institutions could collaborate similarly in ways that benefit all parties. We argue that COVID-19, all things considered, was a missed opportunity for universities to lean on each other at scale, too. And we reserve much of the panel's time for discussion of attendees' perspectives, questions, and concerns.

We argue in favor of Docker containers as alternatives to clusters of servers or virtual machines for students in introductory programming courses. We present our experience with the same since 2015 in CS50 at Harvard University as well as the pedagogical and operational motivations therefor. We present, too, the evolution of our environments for students over the years, from an on-campus cluster, to an off-campus cloud, to client-side virtual machines, to Docker containers, discussing the trade-offs of each. Not only do containers provide students with a standardized environment, reducing technical difficulties and frequently asked questions at term's start, they also provide instructors with full control over the software in use and versions thereof, additionally allowing instructors to deploy updates mid-semester. Particularly for large courses with hundreds or even thousands of students, containers allow staff to focus more of their time on teaching than on technical support. And, coupled with text editors that support extensions or plugins, containers allow instructors to optimize students' environment for learning, while still acquainting students with industry-standard tools. Most recently implemented atop GitHub Codespaces, a cloud-based version of Visual Studio Code, our own container-based solutions have since been used by more than 700,000 students and teachers, both on campus and off, and are also freely available to any teacher or student outside of our own university.

Odds are we've all used (or tried!) quite a few tools to facilitate efficiency inside and outside of the classroom and empower students to learn more effectively, whether on campus or off. Some of those tools are perhaps homegrown and unique to one's own institution, but freely available educational technologies abound as well, some in the cloud, some for Macs and PCs, some open-source. And quite a few commercial tools offer free or discounted educational plans as well. In this BoF, we'll begin with a whirlwind tour of the tools we ourselves use, including AI, identifying the problems they solve and how well, then quickly open the floor to everyone to share their favorites as well. Along the way, we'll jot down every tool mentioned and share the results. With educational technology an evergreen landscape, this year's list will surely be different from last! Attendees should exit this session with a better understanding of the current landscape, familiarized with innovations they can bring back to their own classes (whether high school, undergraduate, or graduate), without reinventing wheels themselves.

CS50.dev is a cloud-based programming environment offered to students taking CS50 and other CS courses at Harvard University, both on-campus or online. Built atop GitHub Codespaces, CS50.dev simplifies the initial challenges commonly faced by students and instructors because of the complexities involved in setting up programming environments at term's start. This demo offers an in-depth exploration of CS50.dev's architecture and presents a detailed guide on customizing Docker images and development container (devcontainers) to meet the specific needs of courses within GitHub Codespaces. The demo will also provide general guidance on how to help students transition from CS50.dev to using VS Code independently on their local machines at the term's end.

Teaching computer science at scale can be challenging. From our experience in CS50, Harvard University's introductory course, we've seen firsthand the impactful role that generative artificial intelligence can play in education. Recognizing its potential and stakes, we integrated OpenAI's GPT into our own teaching methodology. The goal was to emulate a 1:1 teacher-to-student ratio, incorporating "pedagogical guardrails" to maintain instructional integrity. The result was a personalized, AI-powered bot in the form of a friendly rubber duck aimed at delivering instructional responses and troubleshooting without giving outright solutions. We plan to share our journey and offer insights into responsibly harnessing AI in educational settings. Participants will gain hands-on experience working with GPT through OpenAI's APIs, understanding and crafting prompts, answering questions using embedding-based search, and finally, building their own AI chatbot. Ultimately, we'll not only share lessons learned from our own approach but also equip educators hands-on with the knowledge and tools with which they, too, can implement these technologies in their unique teaching environments.

In Summer 2023, we developed and integrated a suite of AI-based software tools into CS50 at Harvard University. These tools were initially available to approximately 70 summer students, then to thousands of students online, and finally to several hundred on campus during Fall 2023. Per the course's own policy, we encouraged students to use these course-specific tools and limited the use of commercial AI software such as ChatGPT, GitHub Copilot, and the new Bing. Our goal was to approximate a 1:1 teacher-to-student ratio through software, thereby equipping students with a pedagogically-minded subject-matter expert by their side at all times, designed to guide students toward solutions rather than offer them outright. The tools were received positively by students, who noted that they felt like they had "a personal tutor.'' Our findings suggest that integrating AI thoughtfully into educational settings enhances the learning experience by providing continuous, customized support and enabling human educators to address more complex pedagogical issues. In this paper, we detail how AI tools have augmented teaching and learning in CS50, specifically in explaining code snippets, improving code style, and accurately responding to curricular and administrative queries on the course's discussion forum. Additionally, we present our methodological approach, implementation details, and guidance for those considering using these tools or AI generally in education.

CS50.ai is an AI-based educational tool developed and integrated into CS50 at Harvard University using large language models (LLMs), supporting both in-person and online learners. CS50.ai encapsulates a variety of AI-based tools designed to enhance students' learning by approximating a 1:1 teacher-to-student ratio. We showcase: "Explain Highlighted Code," a Visual Studio (VS) Code extension that provides just-in-time explanations of code snippets; style50, a VS Code extension that offers formatting suggestions and explanations thereof; and our "CS50 Duck," an AI-based chatbot for course-related questions, implemented both as a VS Code extension and as a standalone web application. We also demonstrate the integration of our tools into Ed, the course's discussion forum. This demo will illustrate the functionality and effectiveness of these tools as well as the pedagogical "guardrails" that we put in place to ensure secure and fair usage of these tools, while sharing insights from our own experience therewith this past summer and fall.

For CS50 at Harvard, we have long provided students with a standardized programming environment, to avoid start-of-term technical difficulties that might otherwise arise if students had to install and configure compilers, interpreters, and debuggers on their own Macs and PCs. (For many students, "hello, world" is challenge enough on day 0, without also encountering "command not found" at the same time!) We originally provided students with shell accounts on a university-managed cluster of systems. We then transitioned to a cloud-based equivalent so as to manage the systems ourselves, root access and all. We transitioned thereafter to client-side virtual machines, to scale to more students and enable GUI-based assignments. We have since transitioned to web-based environments, complete with code tabs, terminal windows, and file explorers, initially implemented atop AWS Cloud9 and now, most recently, GitHub Codespaces, an implementation of Visual Studio (VS) Code in the cloud, free for teachers and students alike. In this workshop, we'll discuss the pedagogical and technological advantages and disadvantages of every approach and focus most of our time, hands-on, on using and configuring GitHub Codespaces itself for teaching and learning. Along the way, attendees will learn how to create their own Docker images and "devcontainers" for their own classes and any languages they teach. Attendees will learn what is possible educationally by writing their own VS Code extensions as well. And how, at term's end, to "offboard" students to VS Code itself on their own Macs and PCs, so as to continue programming independent of Codespaces.

As CS enrollments have grown and professors have increased their reliance upon undergraduate teaching assistants (TAs), it has become all the more important to identify strategies that equip TAs to assist students with coursework while providing the best learning experience during teaching sessions. In this lightning talk, we present a strategy consisting of clarifying and probing questions that highlight the importance of equipping students with tools to solve computer science problems on their own, instead of seeking help from the teaching staff every time they face a challenge. Toward this end, we will share a guide that we adopted during TA training for Harvard University's introductory course, CS50. Additionally, we will share scenarios in which such strategies might be most useful, as during group tutorials or one-on-one office hours. Lastly, we will share preliminary findings on how the strategies can not only benefit a student during the time when a TA is helping them but also equip them with skills to solve such problems on their own.

Conference presentations usually focus on successful innovations: new ideas that yield significant improvements to current practice. Yet we often learn more from failure than from success. In this panel, we present five case studies of "good ideas" for improving CS education that didn't go as planned, related to offering additional help to students. Each contributor will describe their "good idea," the situation that resulted, and wider lessons for the CS community.

This workshop introduces participants hands-on to GitHub Classroom, a free, web-based application that enables teachers to distribute, collect, and autograde programming assignments in any language. GitHub Classroom effectively provides an abstraction layer atop Git and GitHub, automating tasks for students and teachers that would otherwise be time-consuming and tedious via a CLI or GUI, particularly for larger courses. To distribute an assignment, a teacher need only create a "repository" with starter code (and optional tests) in their own "organization" on GitHub, which students can then "accept," automatically creating within that same organization a copy thereof to which the student has write access. To submit work, students need only upload (or push) files to the same, which automates execution of any tests. Students' submissions (and the results of any such tests) are then accessible via the teacher's own dashboard. GitHub Classroom does not strictly require familiarity with Git of students and teachers; basic operations can be performed via GitHub's GUI. But some comfort with cloning, adding, committing, and pushing files with Git itself is ideal. By workshop's end, participants will be prepared to use GitHub Classroom in their own courses if they so choose. And by way of GitHub Classroom can participants' students acquire all the more comfort with Git itself by courses' end.

Odds are we've all used (or tried!) quite a few tools to facilitate efficiency inside and outside of the classroom and empower students to learn more effectively, whether on campus or off. Some of those tools are perhaps homegrown and unique to one's own institution, but freely available educational technologies abound as well, some in the cloud, some for Macs and PCs, some open-source. And quite a few commercial tools offer free or discounted educational plans as well. In this BoF, we'll begin with a whirlwind tour of the tools we ourselves use, identifying the problems they solve and how well, then quickly open the floor to everyone to share their favorites as well. Along the way, we'll jot down every tool mentioned and share the results. With educational technology an evergreen landscape, this year's list will surely be different from last! Attendees should exit this session with a better understanding of the current landscape, familiarized with innovations they can bring back to their own classes (whether high school, undergraduate, or graduate), without reinventing wheels themselves.

In Fall 2020, Harvard University transitioned entirely from on-campus instruction to Zoom online. But a silver lining of that time was unprecedented availability of space on campus, including the university's own repertory theater. In healthier times, that theater would be brimming with talented artisans and weekly performances, without any computer science in sight. But with that theater's artisans otherwise idled during COVID-19, our introductory course, CS50, had an unusual opportunity to collaborate with the same. Albeit subject to rigorous protocols, including face masks and face shields for all but the course's instructor, along with significant social distancing, that moment in time allowed us an opportunity to experiment with lights, cameras, and action on an actual stage, bringing computer science to life in ways not traditionally possible in the course's own classroom. Equipped with an actual prop shop in back, the team of artisans was able to actualize ideas that might otherwise only exist in slides and code. And students' experience proved the better for it, with a supermajority of students attesting at term's end to the efficacy of almost all of the semester's demonstrations. We present in this work the design and implementation of the course's theatricality along with the motivation therefor and results thereof. And we discuss how we have adapted, and others can adapt, these same moments more modestly in healthier times to more traditional classrooms, large and small.

For CS50 at Harvard, we have long provided students with a standardized programming environment, to avoid start-of-term technical difficulties that might otherwise arise if students had to install and configure compilers, interpreters, and debuggers on their own Macs and PCs. (For many students, "hello, world" is challenge enough on day 0, without also encountering "command not found" at the same time!) We originally provided students with shell accounts on a university-managed cluster of systems. We then transitioned to a cloud-based equivalent so as to manage the systems ourselves, root access and all. We transitioned thereafter to client-side virtual machines, to scale to more students and enable GUI-based assignments. We have since transitioned to web-based environments, complete with code tabs, terminal windows, and file explorers, initially implemented atop AWS Cloud9 and now, most recently, GitHub Codespaces, an implementation of Visual Studio (VS) Code in the cloud, free for teachers and students alike. In this workshop, we'll discuss the pedagogical and technological advantages and disadvantages of every approach and focus most of our time, hands-on, on using and configuring GitHub Codespaces itself for teaching and learning. Along the way, attendees will learn how to create their own Docker images and "devcontainers" for their own classes and any languages they teach. Attendees will learn what is possible educationally by writing their own VS Code extensions as well. And how, at term's end, to "offboard" students to VS Code itself on their own Macs and PCs, so as to continue programming independent of Codespaces.

As computer science courses grow, instructors may find it increasingly difficult to meet all learners where they are, offering more-experienced students appropriate challenge and less-experienced students sufficient support to become more experienced themselves. In this lightning talk, we present how we've differentiated the instruction and assignments in CS50, Harvard University's introductory course for majors and non-majors, to support the growing variability we see in students' comfort with computer science. We share how we group students in sections according to their comfort levels, with additional support for those less comfortable in the form of smaller sections. We also share how we designed the course's problem sets for less-comfortable and more-comfortable students alike, ensuring both groups have adequately challenging "floors" and "ceilings" [1]. Our future work includes strengthening support for students who identify as "least comfortable," whose secondary schools might not have prepared them for studies in computer science or college more generally. We also plan to address questions about assessing students of varying comfort levels, which we presently accomplish through score normalization across comfort levels.

No abstract available.

This panel is the evolution of a Technology that Educators of Computing Hail (TECH) Birds of a Feather session held at SIGCSE for seven years, grew into popular panels for many years, and served as a springboard for a regular column in ACM Inroads. It will provide a chance for seasoned middle school, high school, and university educators to showcase the technologies they can't live without, what problems they solve, and how to use them. This year, we asked our panelists to highlight any technology in particular that helped them survive (and possibly even thrive!) during their remote teaching.

Odds are we've all used (or tried!) quite a few tools to facilitate efficiency inside and outside of the classroom and empower students to learn more effectively, whether on campus or off. Some of those tools are perhaps homegrown and unique to one's own institution, but freely available educational technologies abound as well, some in the cloud, some for Macs and PCs, some open-source. And quite a few commercial tools offer free or discounted educational plans as well. In this BoF, we'll begin with a whirlwind tour of the tools we ourselves use, identifying the problems they solve and how well, then quickly open the floor to everyone to share their favorites as well. Along the way, we'll jot down every tool mentioned and share the results. With educational technology an evergreen landscape, this year's list will surely be different from last! Attendees should exit this session with a better understanding of the current landscape, familiarized with innovations they can bring back to their own classes (whether high school, undergraduate, or graduate), without reinventing wheels themselves.

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.

Odds are we've all used (or tried!) quite a few tools to facilitate efficiency inside and outside of the classroom and empower students to learn more effectively. Some of those tools are perhaps homegrown and unique to one's own institution, but freely available educational technologies abound as well, some in the cloud, some for Macs and PCs, some open-source. And quite a few commercial tools offer free or discounted educational plans as well. In this BoF, we'll begin with a whirlwind tour of the tools we ourselves use, identifying the problems they solve and how well, then quickly open the floor to everyone to share their favorites as well. Along the way, we'll jot down every tool mentioned and share the results. With educational technology an evergreen landscape, this year's list will surely be different from last! Attendees should exit this session with a better understanding of the current landscape, familiarized with innovations they can bring back to their own classes (whether high school, undergraduate, or graduate), without reinventing wheels themselves.

In 2010, we proposed to eliminate letter grades in CS50 at Harvard University in favor of Satisfactory/Unsatisfactory (SAT/UNS), whereby students would instead receive at term's end a grade of SAT in lieu of A through C- or UNS in lieu of D+ through E. Albeit designed to empower students without prior background to explore an area beyond their comfort zone without fear of failure, that proposal initially failed. Not only were some concentrations on campus unwilling to grant credit for SAT, the university's program in general education (of which CS50 was part) required that all courses be taken for letter grades. In 2013, we instead proposed, this time successfully, to allow students to take CS50 either for a letter grade or SAT/UNS. And in 2017, we made SAT/UNS the course's default, though students could still opt out. The percentage of students taking the course SAT/UNS jumped that year to 31%, up from 9% in the year prior, with as many as 86 of the course's 671 students (13%) reporting that they enrolled because of SAT/UNS. The percentage of women in the course also increased to 44%, a 29-year high. And 19% of students who took the course SAT/UNS subsequently reported that their concentration would be or might be CS. Despite concerns to the contrary, students taking the course SAT/UNS reported spending not less but more time on the course each week than letter-graded classmates. And, once we accounted for prior background, they performed nearly the same. We present the challenges and results of this 10-year initiative. We argue ultimately in favor of SAT/UNS, provided students must still meet all expectations, including all work submitted, in order to be eligible for SAT.

For CS50 at Harvard, we have developed a suite of free, open-source tools to help students with writing, testing, and submitting programming assignments and to help teachers grade those assignments and check them for similarities. help50 parses often-cryptic error messages and explains them in beginner-friendly terms. check50 runs a set of automated tests on students' code, providing feedback on errors. style50 lints students' code, highlighting that don't adhere to the course's style guide. submit50 allows students to submit assignments to a GitHub repository, without students needing to have knowledge of git or version control themselves. And compare50 allows teachers to analyze submissions for similarity, looking for pairs or clusters of submissions that might be the result of improper collaboration. In this workshop, we'll introduce each of these tools and discuss how other teachers can use them in their own classrooms. Along the way, we'll discuss how to use the tools effectively, compare and contrast them with alternatives, identify how the tools have changed students' behavior for the better and for worse, and highlight pedagogical and technological changes we've made to redress the latter.

This workshop offers hands-on experience with a suite of interactive programming environments for teachers and students, each of them cloud-based and free. The first tool is CS50 Sandbox, via which teachers create temporary programming environments quickly and share copies of those sandboxes with students. The second tool is CS50 Lab, via which teachers can create step-by-step programming lessons, providing incremental feedback at each step, enabling students to progress from an empty file (or starter code) to working code, with hints and feedback along the way. And the third tool is CS50 IDE, via which teachers can provide students with their own cloud-based Linux environment. Each of these environments offers students a built-in file browser and code editor, along with a terminal window with shell access to their very own container. The IDE additionally provides an interactive, graphical debugger. Each tool enables students to write programs in any language for which a compiler or interpreter can be installed in the underlying container, including Java and Python. Not only will we demonstrate each tool, we'll discuss lessons learned from having deployed these tools in CS50 at Harvard to hundreds of students on campus and thousands of students online. We'll compare and contrast with commercial and open-source tools. And we'll discuss challenges encountered and best practices adopted.

Massive open online courses (MOOCs) show highly irregular participation behaviour among users. In this study, using data from Computer Science 50x of HarvardX, we investigated one extreme, yet common strategy to foresee the endgame: taking the final problem set at the beginning of the course. We found such a strategy to be the only dominant trajectory alternative to following the sequence prescribed by the syllabus. Whereas all students who took and passed the final problem set at the beginning of the course subsequently completed the course, those who took and failed the final problem set at the beginning of the course finished the fewest number of milestones, even fewer than those who never attempted the final problem set. Moreover, students with a lower prior programming proficiency were more likely than better prepared students both to take the final problem set early and to fail it. This study revealed the disconcerting phenomenon that many students dropped out of a MOOC because, apparently, their confidence was crushed even before they learned any course content. The study suggests that future MOOC practices and policies should offer informative and constructive syllabi to accommodate students' need for previewing the endgame.

We present check50, an open-source, extensible tool for assessing the correctness of students' code that provides a simple, functional framework for writing checks as well as an easy-to-use API that abstracts away common tasks, among them compiling and running programs, providing their inputs, and checking their outputs. As a result, check50 has allowed us to provide students with immediate feedback on their progress as they complete an assignment while also facilitating automatic and consistent grading, allowing teaching staff to spend more time giving tailored, qualitative feedback. We have found, though, that since introducing check50 in 2012 in CS50 at Harvard, students have begun to perceive the course's programming assignments as more time-consuming and difficult than in years past. We speculate that the feedback that check50 provides prior to students' submission of each assignment has compelled students to spend more time debugging than they had in the past. At the same time, students' correctness scores are now higher than ever.

Odds are we've all used (or tried!) quite a few tools to facilitate efficiency inside and outside of the classroom and empower students to learn more effectively. Some of these tools are perhaps homegrown and unique to one's own institution, but freely available educational technologies abound as well, some in the cloud, some for Macs and PCs, some open-source. And quite a few commercial tools offer free or discounted educational plans as well. In this BoF, we'll begin with a whirlwind tour of the tools we ourselves use, identifying the problems they solve and how well, then quickly open the floor to everyone to share their favorites as well. Along the way, we'll note every tool mentioned and share the results. Attendees should exit this session with a better understanding of the educational-technology landscape, familiarized with innovations they can bring back to their own classes.

For CS50 at Harvard, we have developed a suite of free, open-source tools to help students with writing, testing, and submitting programming assignments; and to help teachers grade those assignments and check them for plagiarism. help50, a program that parses error messages and provides beginner-friendly advice to interpreting them, helps students understand and resolve often-cryptic compiler errors. check50 runs a set of automated tests on students' code, providing feedback and hints about where students have made errors. style50 lints students' code, highlighting places where it doesn't meet the course's style guide. submit50 allows students to submit assignments to a GitHub repository, without students needing to have knowledge of git or version control themselves. And compare50, an open-source and customizable alternative to Moss, allows teachers to analyze submissions for similarity, looking for pairs or clusters of submissions that might be the result of improper collaboration. The grading and submission tools require only a GitHub account to use, and can serve as free, extensible alternatives to tools like Codio, Gradescope, and Vocareum. In this workshop, we'll introduce each of the tools, and discuss how to use them for your own classroom. To date, each tool has been deployed to hundreds of students on campus and thousands online. Along the way, we'll discuss how to use the tools effectively, compare and contrast them with other options, identify how the tools have changed students' behavior for the better and for worse, and highlight pedagogical and technological changes we've made to redress the latter. Laptop (with Wi-Fi) required. Linux, macOS, or Windows. Latest version of Chrome.

We aspire to teach academic honesty in CS50 at Harvard University not only by addressing academic dishonesty when it occurs but by addressing it before it does. By way of communication, course- and campus-wide awareness of policy, just-in-time prompts, interventional conversations, and problem sets have we tried to preempt submission of plagiarized work. But few interventions have had significant or lasting effects on the number of instances thereof. Most impactful has been the addition of one sentence to the course's syllabus, a "regret clause" that encourages students to come forward within 72 hours of some dishonest act on their part, before the course itself is even aware. While we might zero the work in question in such cases, we commit to not escalating the matter further to the university's honor council, where the outcome might instead be admonishment, probation, or even required withdrawal from the university itself. We instead advise students on how best to move forward and connect them as needed with support structures on campus for academics and mental health. Since 2014 have 89 students invoked the clause, between 1% and 3% of the course's student body each year.

The Nifty Assignments special session is about promoting and sharing the ideas and ready-to-use materials of successful assignments. Each presenter will introduce their assignment, give a quick demo, and describe its niche in the curriculum and its strengths and weaknesses. The presentations (and the descriptions below) merely introduce the assignment. A key part of Nifty Assignments is the mundane but vital role of distributing the materials - handouts, data files, starter code, rubrics, autograders - that make each assignment ready to adopt. Each assignment presented has complete materials freely available on the Nifty Assignments home page nifty.stanford.edu. If you have an assignment that works well and would be of interest to the CSE community, please consider applying to present at Nifty Assignments.

Odds are we've all used (or tried!) quite a few tools to facilitate efficiency inside and outside of the classroom and empower students to learn more effectively. Some of those tools are perhaps homegrown and unique to one's own institution, but freely available educational technologies abound as well, some in the cloud, some for Macs and PCs, some open-source. And quite a few commercial tools offer free or discounted educational plans as well. In this BoF, we'll begin with a whirlwind tour of the tools we ourselves use, identifying the problems they solve and how well, then quickly open the floor to everyone to share their favorites as well. Along the way, we'll jot down every tool mentioned and share the results. Attendees should exit this session with a better understanding of the educational-technology landscape, familiarized with innovations they can bring back to their own classes.

We present in this hands-on workshop a suite of interactive programming environments for teachers and students, each of them cloud-based and free. The first is CS50 Sandbox, a web app at sandbox.cs50.io that enables teachers and students to create temporary programming environments quickly and share copies of those sandboxes with others. With this app can a teacher start programs in class that students can then finish, distribute starter code for problems, and post interactive solutions. The second tool is CS50 Lab, a web app at lab.cs50.io that enables teachers to create step-by-step programming lessons, providing incremental feedback at each step, and enables students to progress from an empty file (or starter code) to working code, with hints and feedback along the way. Via this app can teachers author their own Codecademy-style lessons using just a GitHub repository of their own. And third in the suite is CS50 IDE, a web app at ide.cs50.io built atop Cloud9 that provides students with their own cloud-based Linux environment. Each of these environments offers a built-in file browser and code editor and, most importantly, an interactive terminal window with shell access to their very own container. And each enables students to write programs in any language. Throughout this workshop will we discuss lessons learned from having deployed these tools in CS50 at Harvard to hundreds of students on campus and thousands of students online. And we'll discuss challenges encountered and best practices adopted.

The pace of technology for use in computing education is staggering. In recent years, the following technologies have completely transformed our teaching: Piazza, GradeScope, YouTube, Google Docs, Doodle and whenisgood.net, Skype and Google Hangout, and Khan Academy among others. Hardware has also played a part. We love our Zoom digital voice recorder (for recording CD-quality lecture audio), Blue Yeti USB mike (for audio/videoconferences), and iClickers (for engaging students in class). This panel is an outgrowth of a Technology that Educators of Computing Hail (TECH) Birds of a Feather session that we've held at SIGCSE for seven years, and the panel from SIGCSE 2015 [1] that served as a springboard for a regular column in ACM Inroads [2]. It will provide a chance for seasoned high school and university educators to show you the technologies that have "bubbled to the top" for them, and what key problems they solve. Like concert musicians, they will give live demonstrations and reveal the configuration options required to make their technology "sing". We hope this forum will allow the presenters to dive deeply into the common use cases of these technologies, highlight why they are invaluable, share any "gotchas" they've uncovered, and explain how others can adopt them at their institutions. The highlight of the panel is when the audience, inspired by the presentations, is invited to share their favorite "can't live without" technologies as well.

Undergraduates are widely used in support of Computer Science (CS) departments' teaching missions as teaching assistants, peer mentors, section leaders, course assistants, and tutors. Those undergraduates engaged in teaching have the opportunity to deeply engage with CS concepts and develop key communication and social competencies. As enrollments surge, undergraduate teaching assistants (UTAs) play a larger role in student experience and outcomes. While faculty and graduate student instructional support does not necessarily increase with the number of students in our courses, the number of qualified undergraduate teaching assistants for introductory CS courses should scale with the number of students in our courses. With large courses, the significance of the UTAs' role in students' learning likely also increases. Students have relatively little interaction with the instructor, and faculty may have more challenges monitoring and supporting individual UTAs. UTAs have a major role in affecting climate in computer science courses. The climate in large courses has substantial implications for students from groups traditionally underrepresented in computing. This panel will discuss how undergraduate teaching assistants can serve as a scalable effective teaching resource that benefits both the students in the course and the UTAs themselves.

This workshop introduces participants to CS50 IDE (cs50.io), a web-based integrated development environment based on Amazon's Cloud9 (c9.io). Not only does the IDE enable students to work on programming projects within a browser, without need for local downloads or installations, it also provides students with an integrated terminal window and full sudo privileges. Underneath the hood is a Docker "container" that allows students to experiment with the underlying Ubuntu Linux OS, installing and configuring software at will, adapting it to their particular projects' needs. The IDE supports any compiler, interpreter, or other software that can be installed via a Linux command-line, while the IDE itself provides a fully-featured text editor for text files and source code that reside on the underlying instance. The Cloud9 GUI is fully extensible through a plugin system and is leveraged by CS50 IDE to provide additional functionality for students. Among the additional features implemented through this mechanism are a GUI-based file submission system, an optional "less comfortable" mode that simplifies the GUI to provide a scaffolded experience for students new to programming, and a GUI front end for the GNU Project Debugger, a CLI debugger for many languages, including C. This workshop will highlight useful features of the IDE in the context of classrooms (including the collaborative nature of a workspace to allow pair programming or provide alternative one-on-one instruction), provide tips for writing or adapting assignments based on its architecture, and introduce developing plugins for full customization.

This workshop introduces participants to CS50 IDE (cs50.io), a web-based integrated development environment based on Cloud9 (c9.io). Not only does the IDE enable students to work on programming projects within a browser, without need for local downloads or installations, it also provides students with an integrated terminal window and full sudo privileges. Underneath the hood is a Docker "container" that allows students to experiment with the underlying Ubuntu Linux OS, installing and configuring software at will, adapting it to their particular projects' needs. The IDE supports any compiler, interpreter, or other software that can be installed via a Linux command-line, while the IDE itself provides a fully-featured text editor for text files and source code that reside on the underlying instance. The Cloud9 GUI is fully extensible through a plugin system and is leveraged by CS50 IDE to provide additional functionality for students. Among the additional features implemented through this mechanism are a GUI-based file submission system, an optional "less comfortable" mode that simplifies the GUI to provide a scaffolded experience for students new to programming, and a GUI front end for the GNU Project Debugger, a CLI debugger for many languages, including C. This workshop will highlight useful features of the IDE in the context of classrooms (including the collaborative nature of a workspace to allow pair programming or provide alternative one-on-one instruction), provide tips for writing or adapting assignments based on its architecture, and introduce developing plugins for full customization.

CS50 is Harvard University's introductory course aimed at majors and non-majors alike. Each week, students complete programming assignments and have traditionally received feedback from staff in the form of comments on PDFs of their code. Staff have historically reported spending significant amounts of time grading because of bottlenecks that included generating PDF documents and manually emailing feedback to students. Because we preferred that staff spend less of their time on grading logistics and more time providing feedback and helping students online or in person, we set out to improve the efficiency of the grading process.

We propose a client-side virtual machine (VM) as an alternative to on-campus clusters and off-campus clouds as a development environment for students in introductory courses. In Fall 2011, we deployed the CS50 Appliance, our own such VM, to 600 students on campus and, in Fall 2012, to 700 students on campus and 140,000 students online. We present in this work the results of that two-year experiment. The appliance itself is available as open source for others to adapt or adopt. Not only did the appliance enable us to provide students with simpler tools, among them a graphical editor without any latency, it also enabled us to provide more sophisticated tools too, including a web server and database server. Moreover, the appliance ensured that the course's workload no longer required constant Internet access, particularly of students abroad. And the appliance alleviated load on the course's servers, with execution of students' programs now distributed across students' own CPUs. Without the appliance (or more costly clusters or clouds), we certainly could not have accommodated as many as 140,000 students.

In his SIGCSE 2007 keynote, Grady Booch exhorted us to share the "passion, beauty, joy and awe" (PBJA) of computing. This led to sessions that have provided a forum for sharing: What we've done: Highlighting successful PBJA initiatives the presenters have undertaken or seen and wish to trumpet; What we should do (curriculum): Pointing out where our curriculum is lacking in PBJA, and how to fix it; How we should do it (pedagogy): Sharing how a change in attitude/focus/etc. can make strides to improving PBJA.

We introduce CS50 Sandbox, an environment for secure execution of untrusted code. Implemented as an asynchronous HTTP server, CS50 Sandbox offers clients the ability to execute programs (both interactive and non-interactive) written in any compiled or interpreted language in a tightly controlled, resource-constrained environment. CS50 Sandbox's HTTP-based API takes files, command lines, and standard input as inputs and returns standard output and error plus exit codes as outputs. Atop CS50 Sandbox, we have built CS50 Run, a web-based code editor that enables students to write code in a browser in any language, whether compiled or interpreted, that's executed server-side within a sandboxed environment. And we have built CS50 Check, an autograding framework that supports black- and white-box testing of students' code, leveraging CS50 Sandbox to run series of checks against students' programs, no matter the language of implementation.

Every time I re-use a handout, I look it over and make a few little "improvements". I play around with code demos and entertain myself with different slide transitions. However, inevitably, I return to the conclusion that most of what my students learn in my course comes from the assignments. Great assignments are hard to dream up and time-consuming to develop. With that in mind, the Nifty Assignments session is all about promoting and sharing the ideas and ready-to-use materials of successful assignments.

I worry over topics for the syllabus, fretting over demos and presentations. And yet, I always come back to the fact that most of what my students learn and remember from my course comes from the assignments. Great assignments are hard to dream up and time-consuming to develop. With that in mind, the Nifty Assignments session is all about promoting and sharing the ideas and concrete materials of successful assignments.

Computer Science 50 is Harvard College's introductory course for majors and non-majors alike, enrollment in which both rose and fell along with the dotcoms. Although enrollment peaked in 1996 at 386 students, it had settled by 2002 in the neighborhood of 100.We set out in 2007 to combat that trend by tackling two problems. We hypothesized that CS50 suffered from two, one of perception and one of design. Although, per end-of-term surveys, the course had never lacked for good teachers or good content, the consensus on campus for years had been to beware this particular course. And the course's own syllabus may very well have been dated in the eyes of students who had begun to carry regularly modern hardware and software in their backpacks and pockets.Not only did we proceed to revamp every one of CS50's problem sets, we brought its syllabus more in line with technological trends already familiar to students. And we altered the tone of the course to appeal to those less comfortable with computing on campus. But we took care to preserve the course's rigor and underlying fundamentals, lest we do our own students a disservice.Our new approach appears to be working. Between 2006 and 2007, enrollment in CS50 more than doubled from 132 to 282 (+114%). Between 2007 and 2008, enrollment increased another 17% to 330, though even more striking was that year's 48% increase in female enrollment. By 2009, enrollment remained strong at 338.We present in this work what we have done and why we have done it.

In Fall 2007, we introduced "virtual office hours" into Harvard College's introductory computer science course, CS 50, so that students could meet with teaching fellows (TFs) online to discuss problem sets at any hour from anywhere. Our goals were to lower the bar to interaction among TFs and students and to improve the efficiency and convenience of the same. Rather than rely on email alone, we experimented with Elluminate, third-party software that not only allowed students and TFs to chat via IM and VOIP, it also enabled the latter to see and even share control of the former's screens (eg, code in students' terminal windows). Students, in turn, were able to troubleshoot bugs with TFs by their (virtual) side.

No abstract available.

We present a critical evaluation of the first known implementation of elliptic curve cryptography over F 2 p for sensor networks based on the 8-bit, 7.3828-MHz MICA2 mote. We offer, along the way, a primer for those interested in the field of cryptography for sensor networks. We discuss, in particular, the decisions underlying our design and alternatives thereto. And we elaborate on the methodologies underlying our evaluation. Through instrumentation of UC Berkeley's TinySec module, we argue that, although symmetric cryptography has been tractable in this domain for some time, there has remained a need, unfulfilled until recently, for an efficient, secure mechanism for distribution of secret keys among nodes. Although public-key infrastructure has been thought impractical, we show, through analysis of our original implementation for TinyOS of point multiplication on elliptic curves, that public-key infrastructure is indeed viable for TinySec keys' distribution, even on the MICA2. We demonstrate that public keys can be generated within 34 seconds and that shared secrets can be distributed among nodes in a sensor network within the same time, using just over 1 kilobyte of SRAM and 34 kilobytes of ROM. We demonstrate that communication costs are minimal, with only 2 packets required for transmission of a public key among nodes. We make available all of our source code for other researchers to download and use. And we discuss recent results based on our work that corroborate and improve upon our conclusions.

In recent months have teachers become publishers of content and students subscribers thereof by way of podcasts, feeds of audio, video, and other content that can be downloaded to clients like iTunes and devices like iPods. In the fall of 2005, we ourselves began to podcast Harvard Extension School's Computer Science E-1 in both audio and video formats, the first course within Harvard University to do so. Our goals were to provide students with more portable access to educational content and to involve them in technology itself.To evaluate this experiment, we have analyzed logs and surveys of students. We find that our students valued E-1's podcast more as a vehicle for review (45%) than as an alternative to attendance (18%). We also find that most students (71%) tended to listen to or watch lectures on their computers, with far fewer relying upon audio-only (19%) or video (10%) iPods. We argue, meanwhile, that podcasting, despite its widespread popularity, is but a marginal improvement on trends long in progress. It is this technology's reach that we claim is significant, not the technology itself. Logs suggest that E-1's own podcast, available not only to students but to the public at large, has acquired (as of September 2006) between 6,000 and 10,000 subscribers from over 50 countries. We argue, then, that podcasting offers to extend universities' educational reach more than it offers to improve education itself.

Scratch is a "media-rich programming environment" recently developed by MIT's Media Lab that "lets you create your own animations, games, and interactive art." Although Scratch is intended to "enhance the development of technological fluency [among youths] at after-school centers in economically disadvantaged communities," we find rarkable potential in this programming environment for higher education as well.We propose Scratch as a first language for first-time programmers in introductory courses, for majors and non-majors alike. Scratch allows students to program with a mouse: programmatic constructs are represented as puzzle pieces that only fit together if "syntactically" appropriate. We argue that this environment allows students not only to master programmatic constructs before syntax but also to focus on probls of logic before syntax. We view Scratch as a gateway to languages like Java.To validate our proposal, we recently deployed Scratch for the first time in higher education via harvard Summer School's Computer Science S-1: Great Ideas in Computer Science, the summertime version of a course at harvard College. Our goal was not to improve scores but instead to improve first-time programmers' experiences. We ultimately transitioned to Java, but we first introduced programming itself via Scratch. We present in this paper the results of our trial.We find that, not only did Scratch excite students at a critical time (i.e.,, their first foray into computer science), it also familiarized the inexperienced among th with fundamentals of programming without the distraction of syntax. Moreover, when asked via surveys at term's end to reflect on how their initial experience with Scratch affected their subsequent experience with Java, most students (76%) felt that Scratch was a positive influence, particularly those without prior background. Those students (16%) who felt that Scratch was not an influence, positive or negative, all had prior programming experience.

We present the first known implementation of elliptic curve cryptography over F/sub 2p/ for sensor networks based on the 8-bit, 7.3828-MHz MICA2 mote. Through instrumentation of UC Berkeley's TinySec module, we argue that, although secret-key cryptography has been tractable in this domain for some time, there has remained a need for an efficient, secure mechanism for distribution of secret keys among nodes. Although public-key infrastructure has been thought impractical, we argue, through analysis of our own implementation for TinyOS of multiplication of points on elliptic curves, that public-key infrastructure is, in fact, viable for TinySec keys' distribution, even on the MICA2. We demonstrate that public keys can be generated within 34 seconds, and that shared secrets can be distributed among nodes in a sensor network within the same, using just over 1 kilobyte of SRAM and 34 kilobytes of ROM.