DAVID MALAN: All right. Hello, world. Can everyone hear me OK, from Harvard University in Cambridge? Well, welcome to CS50 AP Educator Workshop 2020. My name is David Malan, and so nice to see so many faces here from around the country and around the world. We're here on campus with very few people in beautiful Sanders theater, which is, in ordinary semesters, where we hold CS50's lectures. Indeed, if you've seen any of CS50's lecture videos online, that's where we are right now. But today it's just me and Brian and Tara and Andrew, all of whom are many feet away from me, so that we can host this in situ for what would otherwise be an in-person event. 

Just to give you a quick tour, if you're a little less familiar or unfamiliar with Zoom, odds are if you're on a Mac or PC, if you move your mouse along the bottom of your screen, you'll see a few buttons that are helpful today and tomorrow and Saturday, one of which will toggle your microphone on and off to mute it or unmute it. By default, we'll keep everyone muted just so there isn't any accidental background noise. But if you'd like to ask a question or answer a question or otherwise participate, we'll be sure to prompt you to unmute yourself. You'll see a message on the screen. 

There's also a way of turning your video on and off. Note that we are live streaming, and we'll post a recording of this thereafter. So if you'd prefer not to appear on camera, that's quite fine. But otherwise, today and tomorrow and Saturday we'll be as interactive as we can make things over Zoom. So please do feel encouraged to keep your video on, especially for any interactions and discussions. 

Also, along the bottom, there's a participant's button. And if you click that, you should see the 77 or so participants who are currently here with us live. And if you click the chat button along the bottom, you'll be able to chat with folks as well. Brian, a colleague of mine who you'll meet tomorrow, is kindly off screen and going to help me keep an eye on any textual questions that come in. But also, let's go ahead and test the user interface in the participants window. 

If you've clicked that participants button, and you see all of the names along the side of your screen, you should see a few buttons, one of which is, yes, with a green checkmark. If everyone wouldn't mind clicking, yes, just to try out the user interface. We should suddenly see a whole bunch of yeses appearing on the screen. If you'd like to click your yes button. So far so good. 

Indeed, let's go ahead, Brian, and put everyone's hands down. We'll clear things on our end. You should also see, in that window, a blue hand. So if you'd like to raise your hand virtually by clicking that blue button, what I will see, and what Brian will see on our end, is a whole bunch of questions going up. And so that will be the mechanism via which we can call on you for answers to questions or for questions of your own. 

So please, at any point, today, tomorrow, Saturday, if you have a question or a comment or any confusion, you're certainly welcome to raise that blue hand and we'll do our best to call on people in real time. Or if I happened to miss it, or you just want to ask of the group more subtley, please feel free to use the chat instead. 

So a quick overview of what lies ahead. So this morning session will be about teaching CS50 AP itself, an overview of curricular resources, including materials and software and events and more. But let me give you a quick rundown of the schedule for the coming days, including today and this afternoon. So we're here on Thursday, 25 June 2020. And the first session is where we are right now. 

Following this at 3:00 PM eastern today will be a session led by Kareem Zidane of CS50's team on CS50's tools. What they are and how to use them, that one will be a little interactive. So be sure, if possible, to have your laptop or desktop in use, as opposed to a mobile phone or the like. 

All right. So take two. Can everyone hear me, again, from Cambridge? OK. Well, allow me to apologize. I'm horrified what happened here. This is certainly not the confidence we were aspiring to inspire of everyone today. We are indeed a computer science class. I'm afraid we did lose power over in the main theater on campus, so we'll have to cut that tour short. But I'm now here in CS50's office in Cambridge on a different power grid. So I think we're in much better shape. But please, I hope you'll forgive the technical difficulties. But here on out, hopefully smooth sailing. 

So let me dive right in and give you a sense of the community that you're joining. So pictured here on stage was our very first cohort of teachers some years ago in that same theater, Sanders theater. Under normal circumstances, of course, we would all be here in Cambridge chatting and learning and getting to know each other. We hope that will happen before long. And indeed, we hope to bring everyone here on campus at some point. But until then, allow us to introduce you to Harvard and CS50 a bit vicariously. 

So just a few building blocks first, thought we would give folks a tour first of what AP Computer Science principles is or expects of teachers. This is, perhaps, familiar to some of you, less familiar to others. Please interject at any point with the virtual blue hands and then unmute yourself if you'd like to ask a question or answer a question. And that goes for the entirety of the session. I know it's a little different from just raising your hand physically, but please do feel so inclined to make this as dynamic and interactive as possible. 

So AP Computer Science principles, as you may or may not know, is a curriculum from the college board that any number of providers can implement. Essentially, it's a framework for an introduction to computer science that does not assume one particular programming language, indeed it's agnostic. And therefore, there's a number of different implementations of this framework that teachers can teach and students can take. And CS50, otherwise known as CS50 AP in this context, happens to be among the endorsed providers for this curriculum so that students and teachers around the country and around the world can satisfy AP CS principals by taking CS50, and then sitting for the exam locally or online, most recently. 

In terms of other providers to give you some context, CS50 is one of several these days. Odds are you've heard of Code.org and some other names on the screen here might be familiar as well. And indeed, so that you have access to these slides and others, Brian, do you want to go ahead and share the link to these slides in case we fly by anything too quickly? No need to jot things down unless you'd like. We'll be sure to share any of the slides or materials. 

So CS50 is one of those providers. And what we thought we'd do today, and this morning, now afternoon, is give you a tour of, again, the materials, the software, the events, and the philosophy, ultimately, of CS50. But before we dive into that, any questions from you? Steven, if you'd like to unmute yourself. 

SPEAKER 1: I'm glad that you asked for questions. So I got this year's updated principles, binder, they sent in the mail. And it said suggested languages, and I mean C wasn't on there, which I know a lot of people probably aren't using. But is there-- do you have any thoughts on that? Or-- 

DAVID MALAN: Yeah. Really good question. And indeed, just, lest I go by the slide too fast, all of these blue links here are indeed links to official pages on the College Board's website where you can see all of the official materials if you have not yet had something physically mailed to you, or cannot for some reason. I would say that CS50 is unusual, in so far as we do focus on C, at least for the first half or so of the semester. Thereafter, we transition to Python, and thereafter to SQL and JavaScript with a bit of HTML and CSS. And we actually start the semester with Scratch. 

So CS50 isn't so much of course in C as it really is of course in procedural programming. And as such, it does satisfy the goals of CSP, but it also is a non-trivial superset of what's expected and CSP. More commonly are languages like Scratch only used or Snap, other building-block-based languages if familiar. Others might use a language like Python or perhaps even Java. But generally speaking, CS50 happens to be more programming-centric than most of the CSP offerings. 

All right. Well, allow me to forge ahead then with a look at what CS50 itself is. So this link here, for CS50 syllabus, is a draft of a syllabus that the college board has reviewed and approved for the coming year 2020, 2021. When it comes to teaching an adaptation of AP CS principles in your own classroom if unfamiliar, you are required, as part of the process, to have a syllabus audited by the college board for approval. You can use any of the providers officially approved syllabi. CS50 is among them. 

If you make adaptations to that, changes that is, on your end, realize that you would want to submit that. I'm happy to discuss those kinds of details offline or during this session as well. But here, you'll see a link to CS50's syllabus for the current semester. It's based on last year's materials. And what we'll be doing over the course of this summer, over the next month really, is updating things further. So you're welcome to follow either the version that's there now, or the one that will be up in just a couple of weeks. 

So AP CS principles really boils down to some big ideas and some practices. And if unfamiliar, those big ideas most recently are creative development, data, algorithms and programming, computer systems and networks, and the impact of computing. And on the College Board's main document, this is from the introduction to AP CSP as a course and as an exam, there's this taxonomy here. And again, via the link in the slides, can you access the original version of this here. 

But what you'll see here is a taxonomy, essentially, of the kinds of things that fall into those five big ideas. And just to give you a sense of what lies ahead, essentially, most everything on the left of this picture is covered, indeed, by this course, CS50. So big idea 1, 2, and 3. And then roughly speaking, the two big ideas here on the right, 4 and 5, are roughly covered by an alternative course called CS50 T, which we'll talk about today, which together compose CS50 itself. 

So more on that in just a moment. But via CS50AP is their coverage of all of these big ideas. But separate from those are the so-called practices that the college board documents for CSP. And these are more practical takeaways that they aspire for students to take away from a class. And these include in a high level computational solution design, algorithms and program development, abstraction, code analysis, computing innovations, and ultimately, responsible computing. 

And for even more detail on this, you'll see a separate taxonomy in the official College Board documentation for those practices that are expected to be taken away from CSP. And you'll see a number of examples, or really explanations, of what all of these practices are ultimately getting at. And so via CS50 AP, will you find that these practices and big ideas collectively are hit by way of the courses several weeks and the materials throughout. 

And then lastly, the semester of course ends, like most APs, with an exam. This has been changing over time. And in fact, it's a little slimmer now than it was in the past. There's essentially two components to the exam that students are expected to take. One is an end-of-course multiple choice exam. The particulars here are on the slide as well as in the College Board's official reference. And you'll see that it's a collection of multiple choice questions, reading passages, and multiple choice alike. 

And then there's a create performance task, something that the students actually create of their own, submit to the college board for their review as well. And you'll see by way of CS50's so-called problem sets and quizzes and tests, do we more than cover what's expected in section 1 or prepare students by way of those for section 1. And then by way of CS50 APs final projects, so to speak, do students ultimately satisfy, provided they meet the criteria and spend adequate time on it, the so-called performance task as well. 

So before-- that's a whirlwind overview of what AP CS principles itself is. For the most official documentation, those are these links here. I'm happy to chat about any of those particulars in more detail. But before we forge ahead with a look and an overview of CS50 AP itself, any questions on AP CSP specifically? Any of the process before we focus really on curriculum itself? 

And do feel free to, if you prefer to chime in more subtly via chat, Brian is kindly keeping an eye on that window here. All right. So you've heard me rattle off CS50 in a few different forms already. And allow me to give you a quick glossary of sorts of what it is that compose this entity we describe as CS50. So CS50 itself is Harvard University's introduction to the intellectual enterprises of computer science and the art of programming, which is to say, it's our introductory course in computer science for majors and non-majors at Harvard College. 

It happens to be Harvard's largest class these days with about 800 students on campus, about 200 plus students through Harvard's extension school or continuing ed program, as well as about 300 students at Yale University down the road, where the course is offered in parallel as well. So when generally speaking, CS50 is that undergraduate course on which everything else is ultimately based. And I would say that distinctive for CS50 itself, are these three characteristics, if you will. And this frames, I think, the pedagogy of, and the philosophy behind, how we approach the teaching of this class. 

So first and foremost is intended to be the course's accessibility. The goal being that even though the course, some three months or six or nine months later, will have taken students, really, from 0 to 60, assuming no prior background. The slope of that on ramp is meant to be very accessible. So that we truly assume no prior knowledge at the course's start. Indeed, we start with something like Scratch and computational thinking more generally. But by semester's end, our students are building their very own web applications or even mobile applications in a number of different languages. 

But it's, indeed, meant to be an accessible introduction to students, irrespective of their backgrounds or lack thereof. At the same time, that's complemented by what we hope is the course's rigor. At Harvard, it's reputed, over the course of a semester, to be among the more time intensive courses for students. But that's partly a function of the projects and the immersion that we encourage among students when it comes to the so-called problem sets. And more on those in just a little bit. 

But it's been important to us that this be not only an introduction to computer science, but one that is immersive enough to be even a terminal course for students. Here at Harvard for instance, about 50% of the students only take CS50 in terms of computer science classes. And then they go off into their other fields at the college level, whether it's in the arts, or humanities, or social sciences, or sciences more generally. And so for those students, the course is meant to be adequate preparation for the concepts that might be useful in those fields in computer science and the practical skills of procedural programming. 

For the other half of students who want to go off and do more computer science, more programming, more studies in the field, does it also serve as a solid foundation for them in computer science itself. But perhaps most distinct about CS50 is, I think, an unusual emphasis on the community of the class, both here on campus in New Haven and, really, online and abroad as well. And you'll see, in turn, over the course of this overview, that we have focused unusually on bringing students together, not only locally in classrooms in ordinary times, but really connecting them and teachers online as well. 

And so, indeed, some years ago was born what we call CS50x. So CS50x is the free OpenCourseWare version of CS50, the very same course. So it is distributed via YouTube and edX and iTunes U and other platforms. And it is literally the same curriculum. It is the same assessments. It is the same software and technology. Everything is made freely available to the public at large via this vehicle called CS50x. 

All that is missing from CS50x, for instance, would be the on-the-ground support from a local teacher, the on-the-ground support at the college level from teaching assistants, for instance. But CS50x itself is a packaging of all of the courses OpenCourseWare for a broader community. And if you're curious to take a look at the most recent incarnation, you can go to this URL here, cs50.harvard.edu/x. Or if you are a user of edX, the same materials are available in a different user interface via edX's url instead. 

So that then is CS50x, which is the same as CS50 itself, but it's the outward-facing free version thereof. But separate from CS50, and in turn CS50x, is a course that we call CS50T. So CS50 technology for short, or understanding technology as the formal title of the class. So this is a course, or really a curriculum, that's separate from CS50 itself, that introduces anyone to the world of computing, the world of computer science, by way of hardware and software and multimedia and internet and any number of other topics that are used by us and experienced by us every day, but aren't necessarily understood by us. 

And as it happens, this too is available as free OpenCourseWare on CS50's own website here, as well as, again, on edX's website as well. And so what then is CS50 AP? CS50 AP, which is explicitly alluding to the College Board's AP Computer Science principles curriculum, but does not need to be taught for AP credit, is essentially, the combination of CS50x and CS50T, the undergraduate programming class plus the higher level technology class. Whereas one is more hands on, bottom up, the other is more conceptual top down. And so, collectively, do they you compose what would be a yearlong offering of AP CS principals, otherwise known as CS50 AP. 

So now, in context, with respect to the College Board's five big ideas earlier, CS50x is roughly the three columns on the left. CS50T is roughly the two columns on the right. But collectively, they are together, CS50 AP. And that's what the curriculum itself ultimately is. So for the CS50 AP-specific curriculum, that lives quite simply at this url here, cs50.harvard.edu/ap. 

On that website right now are the materials that teachers have been using up until, literally, this week in a number of private and public high schools around the world. That will soon be switched over to the newer materials. However, the older materials will remain available. The newer materials will be based on this most recent fall semester here in Cambridge. And that, too, is available on edX at this url. But the edX version, by nature of it being an alternative for students to taking the AP class with their school or teachers, for students around the world who can not-- who do not have access to a teacher or to a classroom where they can take AP CS principles. 

Just so you know, students may take the class alternatively via edX at this url, so long as their teacher or principal or school, more generally, is willing at the end of the school year to, at least, administer the local exam. So it can be a self-paced, self-taught course by students online, or of course in one of your own classrooms as well. Allow me then to pause, with hopefully that taxonomy and those building blocks in place, for any questions or comments before we dive into next implementation details, and exactly what is available. Any a blue hands here? No? All right. Seeing none, but please feel free to interject at any point. 

Allow me then, to give you a sense of what is included then in CS50 AP. What is it that is available to you as teachers? And in turn, what is it that's available to your students as well? In terms of what's included, the course's content. And we'll dive into a bit more detail to give you a sense of exactly what menu of options are available to you. 

Two, software. Tools that you can use as a teacher, tools that your students can use as a student to successfully navigate the world of programming and computer science by way of CS50's own curriculum. And then lastly, a series of events that we traditionally hold here in Cambridge, but we've also begun to encourage folks to hold elsewhere and online. And we'll give you a sense of what those community characteristics are as well. 

So when it comes to content of the course, and again, this is a course that's taught traditionally in the fall semester at Harvard University and then made freely available thereafter each year. We have lectures. It's in lectures once per week, here at Harvard, that we introduce in that stage of Sanders across campus, in which we began today, the course's concepts. And I, on the stage of Sanders, will demonstrate a number of concepts, a number of principles each week as well as do a number of hands-on programming activities, involving students as much as we can, admittedly in a theater with some 800 plus seats. 

We also offer sections. Sections in Cambridge, are opportunities for our own teaching assistants themselves, typically undergraduates or graduate students, to lead smaller-scale versions of the class for students who have already watched or attended those same lectures, but sections are an opportunity here on campus for 10 to 20 students maximally, with one teaching assistant, to ask questions about the material. Something that might have been confusing when they heard me discuss it first, to dive into more detail on certain topics, or go into new topics for which we didn't have time in lectures, or most importantly, to do some hands on applications of some of those week's topics. 

And so in the form of lectures do we have for the broader audience of CS50 AP, recordings thereof. And more on those in just a moment. And for the sections, do we have all of the lesson plans that accompany each week's section, so that you, as a teacher, can adopt or adapt those materials or portions thereof so that you have explicit hands-on materials that you can work through with your students. 

We also have what we call shorts. Shorts are indeed, short videos filmed most recently by a member of CS50's team, Doug Lloyd. And this is a series of videos that allow students to explore at their own pace in more detail a number of concepts as well. So for instance, whereas the lectures and sections, roughly speaking, follow this categorization starting at top left with a look at Scratch and then C, arrays, algorithms, followed by memory data structures and more, shorts dive into those topics, but also subtopics thereof ever more precisely. And so indeed, here is a menu of the 50 or so videos called shorts that are available to teachers to better understand the concepts themselves, and also available to students to better understand topics that they might have heard about or watched in class or online as well. 

And then besides that, do we have what we call problem sets, and in turn walk throughs. So problem sets is just Harvard nomenclature for homework assignments or programming projects. And it's the problem sets that really define student's experience primarily in the class. They might sit in on your class. They might watch our classes. But at the end of the day, the highest returns, by design and for sure, are by students actually doing and applying those ideas from those classes in your classroom and ours. 

So to give you a teaser of the kinds of problems that we assign to students via CS50 AP, this is an exhaustive list of the menu that we use this most recent semester here, plus a few others from past semesters as well, all of which are included in the CS50 AP curriculum. But we start this semester, for instance, with Scratch. If unfamiliar, it's a graphical programming language by which you program by dragging and dropping puzzle pieces. 

We transition, thereafter, to C, an older, more traditional text-based language. And we have students implement the simplest of programs like Hello World. Then we have them implement their own approximation of Super Mario Brothers from the original Nintendo game, but doing it just with ASCII characters or unicode characters on the screen, otherwise known as ASCII art. 

But then we quickly begin to introduce students to algorithms. And we have them implement, for instance, a program called Cash. And program called Cash asks them to come up with a greeting algorithm in C that figures outs, at a convenience store for instance, if you hand the cashier some amount of money and they owe yourself around of change, what is the fewest number of coins that the cashier can provide to you so as to minimize how many pieces of coinage they actually have to hand to you? And so we introduce to students algorithms by way of that problem there. 

And then we won't go through all of these problems in detail, but to give you a sense of the steps along which students progress on that slope from earlier, we introduced them shortly thereafter to the world of cryptography via problems like Caesar in Vigenere. Students implement their own ciphers, algorithms for encrypting or scrambling information. We had students this most recent year implement a number of electoral algorithms, which is becoming all the more real here in the US. And we have them write code that actually decides who is the winner of an election given a certain number of votes for a certain number of people and using different electoral algorithms. 

It turns out that it doesn't have to be a simple plurality, or majority vote, or any number of schemes, there's different systems that have their pluses and minuses. And the goal is to get students thinking about their own community, whether it's the US or abroad. And how fairness might even factor in to very real world processes like these. Students of course, these days, spend a lot of time on Instagram, Snapchat, and other platforms. And so midway through the course, do we have students implement some of their own code that explores files, inputs and output, and images, and how you go about representing them. And they implement a number of filters a-la Instagram to maybe blur an image, or turn it into black and white or sepia, or any number of other transformations as well. 

We also, around that time too, typically take photographs of people or places or things on campus. Unfortunately, accidentally delete the memory card, or it somehow gets corrupted it seems every year. And so what we do as part of this narrative for a problem, is make a forensic image of those photographs. And we hand students a file, inside of which are the contents of a camera or a phone's memory, and we have them write code to recover all of the JPEGs or images that used to be on that device. 

We have students implement a spell checker. We give them a dictionary of like 100,000 plus words, and challenge them to write code that very efficiently searches those words to determine whether or not some input text is misspelled or not. And then later in the class, do we begin to introduce students to web programming. So we don't spend the entire year on command line programming in C. We eventually introduce them to Python. And again, we introduce them to SQL, a language for databases, a bit of JavaScript, and HTML and CSS for the web. 

And they implement, for instance, their own web based application via which to buy and sell stocks. We introduce them to the notion of APIs. Talking to Yahoo Finance or some other API, and pulling in nearly real time data, so as to experience their own approximation of tools that exist in the real world. And that's, maybe, a third of the problems that are available. And it's ultimately left to the teachers decide which subset of these problems they might like to use on what schedule or at what pace they might like to assign them. 

But suffice it to say there is a robust menu of options. But all of them are characterized, really, by this project-based nature. I personally have never been a fan of the end of chapter textbook-style problems where you write a program that adds two numbers together, or write a program that averages a bunch of numbers. Problems that might give students good muscle memory when it comes to programming, but doesn't necessarily inspire or excite interest in the field itself. And so you'll see, indeed, that almost all of CS50's problems are very much domain inspired and meant to connect students to some technology or technique or idea that they might have already experienced in the real world. 

But accompanying almost all of these problems are what we call walk throughs, often led by Brian, whom you met earlier, are short videos, generally embedded into the problems themselves, designed to answer the FAQ, or frequently asked question of, where do I begin? Even though each of these problems is accompanied by a write up of the problem itself, the problem statement, the requirements, how to test it, how to submit it, they are also accompanied, typically, by a walkthrough video, which might be two minutes or 10 minutes. And it's someone like Brian on camera walking students through some tips and tricks that allow students another perspective on the problem and another set of hints and tips. Never provide students with solutions or tell them what to do, and indeed, what Brian will typically do, is if there's ever advice to be given, to offer one tip or another. And then ultimately leave it to the student to decide what road they might want to go down, or how they might want to ultimately solve some problem. 

So lastly, when it comes to content then, are quizzes tests. So these are fairly traditional assessments, albeit administered typically by us online. The quizzes we tend to use to supplement each class or each lecture in our case. The motivation being to ensure that students understood some prior concept. Or if they happen to be watching the material in advance online, to help incentivize, motivate, or as ensure that they've at least engaged in that content, whether it was here on campus or in a CS50 AP environment, perhaps some video assigned in advance by their own teacher. 

These two are generally themed around real world problems. You might recall, for instance, a couple of years back when horrifically, the residents of Hawaii were startled to receive an incoming missile alert. This long story short was an unfortunately very real world event that boiled down, in part, certainly, to human failure and process, but also in part, arguably, to poor user interface design. 

And indeed, we invite students in that type of problem to consider how they could have approached the technological solution to that problem differently to critique the user interface, and to think about, knowing what they know about programming and computer science, how they, and in turn humans more generally, might solve real world problems like that more generally. So these will be made available too, so you can assemble your own quizzes or homeworks or tests. You certainly don't need to use everything verbatim in the same way that we happen to use things here. 

And ultimately, that really is, I think, the message for CS50 AP as a course offering. It is not necessarily a turnkey solution that you follow from page one to page n at the end of the book. Indeed, it's a curriculum that's meant to be either adopted or adapted by teachers. And generally, what we mean by that is this. If you're a teacher who's new to AP Computer Science principles, or perhaps new to computer science itself. 

It's quite common the case for teachers to be asked to take over a computer science class for the very first time be they a mathematician by calling, historian, a gym coach, or the like. And they themselves might quite often, for better or for worse, have to pick up the material as they go, or study intensely over the summer. And indeed, that's one model. In fact, I think, as an aside, one of the opportunities at hand with OpenCourseWare more generally, is really for teachers themselves to be able to take on new projects, new concepts, new materials, and to have it provided to them so that they can really focus on the most precious opportunity, which is the one on one time or classroom time with their own students. 

And so indeed, CS50 AP is meant to be a curriculum from which you can pick and choose those components that you think would work best for you and your comfort as well as that for your students as well. And if you're particularly green to computer science or programming or APCSP, you can adopt the course outright. And for instance, you might even have your own students watch the lectures that we deliver here in Cambridge. And then maybe you use your own classroom time to work through the problem sets. 

And you assume that students have been introduced to the concepts, but you then give them classroom time and one on one time to apply those concepts to the week's homework assignment or quizzes or tests or the like. Or alternatively, if you yourself are feeling more comfortable, and you'd much rather do things your own way too, that would be the so-called adapt model, as we propose. And you as the teacher can certainly look to our materials, for better for worse, for inspiration, for ideas, for demonstrations, for sample code, for slides, any of the available content resources. But then present it exactly the way you would like your students to experience it. 

And they need never look at any of our own videos. Those can be a resource entirely for you or as the teacher. Or of course, you can select any amalgam in between the two using what resources you think work best for you as a teacher or for your students and your classroom. So without further comments on content, allow me to see, for me, allow me to see if there's any questions here then before we forge ahead. 

Any questions on content at the highest level here? Any blue hands? No. All right. Well seeing none, let me make this a little more real, so that you have been oriented to the various content resources available when you yourself go on CS50 AP's website. Generally speaking, the resources that we make available are made available in any number of digital formats. And odds are, there are more resources and more materials than you yourself might need, or your students might need. But this is all toward an end of accessibility. And also, with a mind for the fact that some folks do not have the same internet that we have here, though today is not a great example of that, here in Cambridge, and indeed might need to use as many resources offline as they can. 

So a typical unit of content in the course might be broken down into what we call lecturers here, those shorts, and say, a problem set. And if we zoom in on this, with each lecture, is available like an mp3 recording of it for folks who might just want to listen, sort of podcast style. Notes, which are taken by one of our own teaching assistants who go through the lectures and actually jot down notes much like students themselves might. But in our case, the design is to ensure that one, the notes are thorough and exhaustive and correct. But two, also thereby freeing students up from not having to scribble down everything I might say or you might say on some topic. They can rely on those notes as a reference to supplement what might have otherwise been in class or on video. 

Slides-- so I happen to use slides, not unlike these using Google slides in the lectures there in Sanders theater. We make those available as one clean PDF that you or students could download, but also the Google slides version that you're welcome to copy into your own Google account if you're a Google user, and then modify them, or use just one or more of the slides, changing them as you see fit. In terms of source code, most weeks, of course, include code of some sort, whether it's Scratch or C or Python or the like. We make these available as one big index, so a listing of all of the files that you or students can access individually, a PDF which we render with color coded syntax highlighting in case you or your students might want to take notes on it, either digitally or paper pencil. And then a zip file that just makes it easier to grab all of that at once too. 

Then the video itself. So CS50 has its own CS50 video player, which we'll give you a look at in just a moment. But we also make all of the courses lectures available as mp4s, which is a very popular video format, as well as via YouTube links. And indeed, among those mp4s, there's all different resolutions. So if you or your students happen to have very slow or intermittent or expensive internet connections, 360p refers to a relatively small but still visible version of the video that's relatively easier to download. And it goes all the way up to 4k, which means if you have a nice fancy TV at home, and you might want to watch the lectures on your sofa or the like, you can even watch them in the highest resolution at 4k as well, albeit at the cost of a couple of gigabytes to download. 

When it comes to shorts too, all of these are available as downloads as mp4s, they're also available as playlists and as individual videos on YouTube as well. So what you're seeing here is a glimpse of one of our weeks of CS50 AP, in which we've had shorts on data types and operators, conditional statements, and more. And then last but not least is the problem set. We on campus tend to group our problems into what are called problem sets, which means a collection of one or more problems that is due some number of days after its assignment. 

In CS50 AP, we make all of the problems individually available, because we are operating, for instance, on a 12 week semester. A typical high school or middle school classroom might operate on 32 weeks, 36 weeks, give or take. And so it is entirely up to you exactly how you pace your choice of materials, and how you might group them into sets. You can assign one problem per day, one problem per week, or really combine them in classroom time or homework however you see fit. 

All right. That then brings us to software. But before we leave content behind, any questions that would be helpful here? Or clarifications? Questions or clarifications? No? All right. So seeing none, allow me to share some screenshots and really a teaser for this afternoon session. So at 3:00 PM eastern time-- 

SPEAKER 2: Sorry. David? 

DAVID MALAN: Oh, yes please. 

SPEAKER 2: Can I ask a question quickly? Do we have access to the answers set, answer keys the problem sets as teachers? 

DAVID MALAN: Yes. Yeah, you do. So we make available, in a so-called vault, sample solutions to all of the problems sets. So absolutely, you have access to those as well as the teacher. Other questions on content? No? All right. So to be clear, today's session will still remain at 3:00 PM eastern. It will be led by my colleague, Kareem Zidane. And we'll go into more detail on CS50's various software tools, and also provide opportunities for hands on interactions with the same. 

What I thought we would do here together before then though, is just give you an overview of those tools, so you can sort of fit everything into the mental model and know exactly what's available to you. So like content, it's a fairly long list of available tools. And let's start with the first, with which you as the teacher, or perhaps your students as learners, might interact with the most, which is CS50's own video player. 

So this is software that we wrote that simply makes available those mp4s or those YouTube videos in a slightly different user interface. And at the risk of sharing an awkward screen grab of myself here, it looks a little something like this. And so it can fill the student's screen, like here. And you'll see along the top right hand of the screen, there's some mention of shortcuts and snacks and chapters and captions. 

Let me go ahead and zoom in on just a few of those at once. So this is the chapter's menu. So what we do for each of the the course's lecture videos, is we create a table of contents of sort. Within a typical two hour lecture at Harvard, we might cover a dozen or so topics or examples or demonstrations or the like. And to make that content more navigable for our own students and for high school and middle school students and teachers as well, everything is quantized down into smaller units as table of contents chapters. 

And so when in the context of a high school or middle school classroom, it would quite often be the case that you not have a student watch an entire lecture, for instance, from Harvard, but maybe a subset thereof. And indeed, on the new version of CS50 AP's website in a few weeks, will you have individual links to all of those chapters as well. So you can propose to a student that they watch a demonstration of our discussion of unicode in class. If that's all you want to do one day, you don't need to consume these in their entirety. 

There's also captions. So we also have a human caption for subtitling purposes and screen reader purposes, all of the courses videos. And so you'll see here, a dropdown containing the captions, literally for better for worse, every word that came out of my mouth that day. But it's also searchable. And if you or a student types some keyword, maybe they want to review binary and they weren't really sure where in the video it was, they can literally type binary, or a substring thereof, and jump right to that particular content. 

Slightly more fun are these snacks. So this is a relatively new feature. It turns out that on campus, we generally take a break partway during class, and we serve some cake or some cookies or some candy or some vegetables or some fruits. But we got some non-zero feedback from students online, and teachers as well, that the snacks were unavailable to them. But no longer, thanks to the world of emojis and unicode, can you consume virtually one or more healthy or not-so-healthy snacks. So we give you that feature there as well. 

But perhaps most usefully, when it comes to the course's content, is this last feature here. In the top left hand corner of the window is a little toggle switch that says screen. And indeed, you'll see from this screen grab of an actual lecture, it's me standing on stage where we were earlier today when we began in front of a big TV. And on that TV is a screenshot-- a frame of Scratch, the graphical programming language to which I alluded earlier. 

This, of course, is not all that useful a view for the student if they want to actually see, in high fidelity, what it is that's on my screen. So if they click, literally, that toggle called screen, they can actually zoom in and enhance exactly what it was on my screen, thereby toggling between the human view, me, or the courses students on stage, or the full screen example thereof. 

So in fact, Brian, do you mind sharing a sample url from video.cs50.io. It's literally the example link at top. I suspect everyone might start playing a video off to the side now, but that's fine. But there is a live demonstration that you're welcome to play with as well that Brian will paste kindly into the chat window. But feel free to tinker with it now or later as well. 

Allow me to give you a quick tour of CS50 Sandbox. So CS50 has a number of programming environments that we use for students. The goal of which is to ensure that they don't need to install anything on their computer. And this is actually driven by the course's philosophy. Students, other than having access to a computer and the internet, whether at home or at school or a library or the like, CS50 has no required textbooks to purchase. CS50 has no required software to purchase. And students do not need to even install anything on their own Macs and PCs. 

Everything can be done from a web browser on their own Mac or PC or Chromebook or the like. And all of their files and such are saved in the cloud for them to access at any time. What you're about to see are the most recent incarnations of these tools. The user interfaces will change a bit over the course of this summer, but the functionality you're about to see and experience this afternoon will all remain available. 

The first tool is CS50 Sandbox. CS50 Sandbox is meant to be our simplest programming environment. It looks a little something like this, and again more on this later this afternoon, that allows students to create a very simplified, no bells and whistles, programming environment in their web browser. And this environment has tabs along the top for code. For instance, here I've pre-written a program called hello.c in a language called C. And it also has, and this too is driven by the course's pedagogy, a terminal window at the bottom of the screen. 

For those less familiar or unfamiliar, whereas Macs and PCs, of course, have graphical user interfaces with which you interact with menus and buttons and icons and the like, a more traditional or old school mechanism, that's nonetheless very much alive and used today among software developers especially, is more command line interface, or CLI, like this one here, a so-called terminal window. And so indeed, whereas a lot of programming environments today tend to abstract away and hide this detail altogether for students, we've actually by design embraced it. And students do not run their code by clicking a play button. 

They do not compile their code by clicking a button. They do it by executing the underlying commands that even in Xcode or Eclipse or NetBeans or the like, are being automated for them. We deliberately, in CS50 AP, have students run those commands themselves. So case in point, to compile this example program, a student would type, make hello, and then they would type a separate command to actually execute it. 

But you'll see at the top right of the screen too, there's a share button. What CS50 Sandbox also enables teachers and students to do is share that Sandbox via a Bitly url, and then submit their code that way, or share it with a teacher or classmate so that you can sort of remix projects, much like in the world of Scratch, if familiar with that one. Related in spirit to the Sandbox, but adding additional functionality, is what we call CS50 Lab, that we often use for hands on exercises within the class. This essentially adds to CS50 Sandbox a list of instructions for an actual homework assignment. So it keeps them entirely within this environment. 

So the screenshot here that you see has what is essentially the same user interface as before at the side, a terminal window at the bottom, and one or more code tabs at the top. For example, this is the beginning of a program I might call mario.c. And this, recall, is one of the problems I alluded to earlier as a student homework assignment. And on the left hand side, you have some very user friendly looking HTML and the instructions for that lab. And what's powerful about CS50 Lab is that it gives you and the student an environment similar in spirit to what you might find on Code.org or Codecademy or the like, where you have these integrated lessons all in one user interface. 

But with CS50 Lab, everything is made freely available to teachers to create labs via a simple GitHub account. So if unfamiliar, GitHub is a very popular website for storing code, sharing code, and collaborating with others. And it's free to sign up for. And it allows you to create one or more repositories, folders essentially, in which you can store code. What CS50 Lab does, even though it's hosted by us, we will automatically, based on how you as a teacher configure it, pull files from your own GitHub account, and then render them in this user interface. 

So you'll hear more from one of our teachers who might have said hello earlier, Margaret, and our own staff here are much in the habit of creating these labs by just editing some text files in their GitHub accounts. And then, voila, we, CS50, handle the rendering of the user interface for you. So there's nothing proprietary. It happens to all be written in a language called Markdown, which is a very lightweight text format. And YAML, which is a configuration file format. So there's nothing to sign up for or subscribe to to use that particular type of functionality. 

Last but not least, when it comes to programming, is the tool that we use during much of the semester at Harvard, because it adds bells and whistles. And it adds powerful tools, but in a relatively simple user interface still for students to use. So here is just one teaser of a tool you'll again see later today with Kareem, called CS50 IDE. This is, essentially, a fancier version of CS50 Sandbox. So it has all the same features. 

It has tabbed code windows. It has a terminal window. It also has a file browser, so students can, again, point and click as needed. But it also includes a number of other features. It includes an interactive debugger, one that's graphical so you can actually interact with your C code or Python code, and actually chase down bugs. It also has an automated version control. So literally, with a slider that you move left and right, you can scroll forward or back in time in case you or the student goofed, and they want to see what their code previously looked like, or they want to save other check points. 

And it's got a number of other features as well, including share-ability, not unlike the Sandbox, but an interactive chat window, which might be all the more germane these days, if all of us are to be home for the several months or school year. You can chat interactively with your students, or students with each other. And you can also share workspaces, if you're a fan of pair programming or group projects, all of that can be done within this environment as well. And so those features and more by way of Kareem, a bit later. 

So in terms of programming environments, Sandbox, which is just nice and simple and easy to start. Lab, which adds to the Sandbox, just some teacher written instructions, whether by us or by you. And the IDE, which is a more full-fledged feature-full web programming environment. Any questions on those? But again, you'll get your hands dirty with some of those later today. 

SPEAKER 3: I have a simply question. If we ask to hear the language one of these tools, say the sandbox, will it automatically be added to all other? Like if I add the language to-- if I ask to get the language to CS50 Sandbox, will it also appear in CS50 IDE? 

DAVID MALAN: No. They are currently separate. But the forthcoming changes that I alluded to earlier, the plan is to merge them all together. So I will have a different answer to that before long. But right now, no. They are separate tools. And I heard one other voice start. I didn't see a hand, but I'm not sure who it was. 

SPEAKER 4: I have a really quick question. 

DAVID MALAN: Sure. 

SPEAKER 4: In terms of just using the IDE versus the Sandbox versus the other tools, since they're all kind of layers onto each other, is that all built into the curriculum, so that you're starting out at the lowest denominator? And then as you're moving up and getting more familiar with the use of GitHub, then you're ending up in the IDE? Is that how all of that works? 

DAVID MALAN: It is. That's exactly the trajectory. And now, these tools, for the past couple of years, have existed independently, because we were trying out these different ideas. Now that we like the use cases that they have solved for us, we're in the process of merging them so that they will all be the IDE, ultimately. But you'll be able to turn on features week after week as needed, as opposed to having to dive right into it. 

With that said, the IDE itself is built on top of a product called Amazon Cloud 9, which itself is a web-based programming environment. And what CS50 IDE technically is, is a simplification of that cloud-based tool. So frankly, the IDE itself is a perfect place to start, even from the very beginning of the semester with your students. But we're in the process of making it easier to turn things off so that you can really eliminate menu options and visual distractions that they just don't need. Peter, I see your hand went up too. 

SPEAKER 5: So the one question I have, is that we're using Google classroom. But when I was looking through your documents, it looks like you have us set up a site of our own. I think that's what I wrote. So how do they-- is there any integration between this and Google classroom? Or do we build better ourselves? 

DAVID MALAN: More so the latter, with help from us to make that easier. So what we found over the years is that everyone uses something different, whether it's Google classroom or Moodle or Schoology or Blackboard or the like. And so we have not tried to force one approach on everyone. So indeed, we do have a standalone site, it's cs50.harvard.edu/ap, which is currently this past school year's version, will soon be updated. Essentially, we will provide you with links that you can excerpt from that one website and embed in your own tool as needed. Or if you prefer, you can link to our website. 

Or a third option, if you just like the layout or the capabilities of our website, using GitHub again, you can actually create your own version of it. And some teachers have done that as well. So it's really up to you. We don't force one paradigm on you. But it does not integrate directly with something like Google classroom. Diego, question from you? 

SPEAKER 6: Yeah. I have a question. Is there a limit of the number of students you can have signed up for the IDE? 

DAVID MALAN: No. You are welcome to use it with any number of your students. Good question. All right. All right, just a final more teasers of what lies ahead on the realm of software, and then finally, events. CS50 Render, this is a simpler tool. But it's just to give you a sense of some of the other tools in the toolkit that are available to you. Back in the day, we very commonly solicited students submissions via PDF so that we could actually annotate on them using Apple Preview or Adobe Acrobat or the like. 

I frankly, am still in the habit of printing all of my notes and code out in front of me so that I have a paper backup, especially if I'm live coding, and I want to be able to have something handy. You could, of course, solve this in a number of ways. You don't need a special tool. But what CS50 Render does, this is just a website that lets you upload one or more files in C or Java or Python or whatever the language is. And it just generates very clean PDFs for you. And it deliberately does it in landscape mode, so that the lines don't wrap. It leaves you plenty of room to comment or annotate. 

So what some teachers or teaching assistants might do to provide qualitative feedback or written or typed feedback, is just turn a student's submission into a PDF, or even have the students do the same for them, so that you can actually annotate on something. Or I, again, use it for my own teaching purposes. It also lets you lay out code side by side. So midway in the semester, for instance, when we introduced Python to students, we do so in CS50 AP, by showing them the C code that they wrote weeks prior side by side with the Python code, which frankly, is going to be much shorter and simpler typically, than the C code. So you can do that same thing in PDF form as well. 

But last but not least, are the courses events. And these perhaps have visuals that are applicable in more ordinary times. But they really go to the heart of what we mean by community in the class. So in terms of events that we encourage among students and teachers on campus. We have three primary traditions on campus, something called CS50 puzzle day, something called system Hackathon, and finally CS50 fair. 

CS50 puzzle day is an event that we usually use to start our school year off. We've been doing it for almost 10 years now, and it's an opportunity for students to gather, in our case usually on a Saturday afternoon. Or in the high school or middle school case, maybe on a Friday morning or afternoon in school, or a Monday morning or afternoon in school, to collaborate with one or two or three classmates on a printed packet or a PDF of puzzles, which was quite the alliteration there. And that packet of puzzles has nothing to do with computer science. It does not require any prior programming experience. It's all about just logic and problem solving more generally. 

And we very deliberately start our school year off with CS50 puzzle day, inviting all of our CS50 students to it, as well as their classmates and others on campus who might like to partake, really to send and reinforce the message that computer science is not programming per se. It's absolutely a powerful tool. It's a way of applying ideas to practical problems. But it's not necessarily an end unto itself. 

The field itself is more about problem solving. And so puzzle day has been such a fun opportunity to reinforce that message, gather students at the beginning of the school year to get to know each other, to collaborate semi-competitively on something that's really just for fun. And really, just to gather a lot of smart people together to work on relatively challenging problems, and to get them thinking a little more methodically and a little more algorithmically, and frankly, to have some pizza and soda together, and give away a few fabulous prizes to whatever teams come out best. 

So here on campus in ordinary times, would we gather in some space on campus. Students would form teams of one or two or three or four people. And they would kind of group themselves off in some corner of the classroom, working on those puzzles. When space overflows, sometimes the floor becomes their canvas. But it's been a wonderful way to get students to know each other and to dive into something fun at term start. And we have actually been doing this for some years online as well. 

So assuming your schools do not meet in person this fall, that is certainly fine. We will hold a global event, open to all teachers and all students, and we will distribute the PDF of puzzles online. It will span most likely four or so days, generally a Friday through a Monday. And it will be an opportunity for you to gather your students in person, circumstances permitting, or online if you would like, and really kick the semester off with a fun, thoughtful event. 

The CS50 Hackathon is an event that we've held here at the end of our semester. This is an opportunity for students to gather, in our case, pretty late at night. We at Harvard start at 7:00 PM, and we end at 7:00 AM. That is not a model that works terribly well for high schools and middle schools. And so more common among CS50 AP classrooms, has been for their teacher or their school to hold a CS50 AP Hackathon that's maybe during first period, or second period, or maybe it's over the course of a Saturday afternoon or morning or the like. 

But the design of the CS50 Hackathon is to convene students to focus, in our case, on their final projects, which is the capstone experience class, and meets the College Board's requirements of a create task, ultimately at the end of the semester. But it's really an opportunity to get students to come together in a very fun, social, collaborative way to solve some problem of interest to them, and to delight in what each other are doing. 

Here this fall at Harvard, it will only be online if we do it. It will not, unfortunately, be in person. We would leave it to you to decide based on your own city's circumstances whether this could even be in person or online. But this too is an opportunity to have students in high school and middle school classrooms work maybe on their final projects at the end of the year, or frankly, on any of the problem sets, or on any of the more hands on tests or quizzes. 

So in fact, we've held a few of these at high school classrooms. One of our guests here today, Margaret, might recognize this photograph here of her own classroom a year or so ago in New York City where we gathered to help students work on programming projects that they happen to be at that point in the semester. And then a few years prior to that, we gathered five public schools and five private schools in Manhattan as well, if only because it's a little easier to get to in Cambridge, and held a large scale multi-school CS50 AP Hackathon as well. 

And this is probably not the year to be bringing multiple schools and students together, but certainly if you're in this for the long haul, two or more years, hopefully this is something possible in your own geography. And indeed, members of our staff have flown out to different cities in the US. We're happy to drop by if we can. Ohio, for instance, is one of the most common events that we attend each year by invitation. And we would encourage you, and we can help you connect with other schools perhaps in your geography, if you might indeed like to bring teachers and schools together for events like that. 

But perhaps the most gratifying event that we hold here on campus and we would encourage you to consider, this year perhaps in online form, but in future years in on-campus forms, is what we call the CS50 Fair. So much like you have-- some schools have science fairs where you demonstrate experiments and the like, the CS50 Fair is meant to be an end of year celebration, really, of students' final projects. A capstone experience that is generally a project of their own design and implementation. We as the teachers in Cambridge provide students with a reality check as to whether, yes, that sounds viable in the amount of time allotted. Or no, you're trying to bite off too much, let's help you re-scope it. 

You and your classroom might do the same, ultimately leaving it to students to design and implement a software website, a software application, a mobile app, whatever it is for their own purposes or AP CSP. But the CS50 Fair is meant to happen after that capstone experience is due. And it's meant to bring students in the class, out of the class, teachers, faculty, and staff alike, to some location on campus, to which all students are invited. They bring their laptops. We play some music. We serve some popcorn and candy and the like. And it's meant to be an opportunity, over the course of an hour, two hours, or longer, to just have everyone demonstrate their final projects. Not unlike a science fair, but this one a computer science fair, so that everyone can see what each other accomplished. 

And it's been, perhaps, one of the most remarkable recruiting mechanisms I daresay, certainly for us, in just raising the visibility of what it is students are doing in computer science. And more powerfully, what students are doing in computer science that had never studied computer science before just a few months prior. And so it's, perhaps, the best messaging that you might do in your own school or environment is to invite others into your classroom in these kinds of environments. 

This year, we will likely do something entirely online. We traditionally ask students to record a YouTube video or some kind of screen cast of their final project as well. And we'll likely create a collage of some sort of those videos, which if not on campus yourself, you might consider doing as well. So these are just six or so photographs or memories that we had. But just to plant some seeds along the lines of community, if your school permits, and your students are comfortable, and parents are fine and such, we would encourage you, honestly, to begin these traditions, where possible, of just capturing as many of in-classroom and out-of-classroom experiences students have, especially when it comes to building and creating things. 

We have now, the fortune of having some 12 plus years of photos and videos of pretty much every Puzzle Day, Hackathon, Fair, and even some classroom activities that we've done. And it's a wonderful way for students to sort of look back on experiences fondly. And it's also a wonderful way, if you display the photos in your classroom or in the halls of your school, to just entice other students who might not consider themselves computer people, or might be a little too timid to consider taking a computer science class, to get up the nerve inspired by their own classmates, who might have once felt as uncomfortable as they. 

And in terms of online communities, these are certainly resources available to you. If your students want or are permitted to join various social media style communities, we have generally not tried to create a walled garden of any sort for CS50, but rather brought the course and its curriculum and its teachers and its alumni to the platforms that folks are already using. And so here is a pretty long list of all of the presences that CS50 has in terms of tools with which you might be familiar. And indeed, almost any hour of the day, you can pick up many of these tools, Facebook among them, LinkedIn now, Instagram, and the like, and actually ask questions of other students, past and present, and get answers relatively fast as well. 

We would defer to you as to whether you or their parents would want students engaging in these communities. But certainly for teachers, you might find this a wonderful support structure that's available to you as well. And indeed, let me point out, and we will send you a formal invitation to these email lists, besides the emails I've been sending you and Brian has sent you for having registered for this workshop, there are two lists for which you can sign up ultimately. And again, we'll send you the invitation. 

One specific to those teaching AP at the high school level, particularly. And then a more general list for teachers, more broadly, that are teaching at the middle school, high school, college, community college, university level, nonprofit, or other organizations. These will be ways for you, as teachers, not to just learn what's available to you by way of CS50 AP, but honestly, to have colleagues to whom you can reach out, especially if you're the only, and maybe even the first computer science teacher at your school, realize that the advantage of availing yourself of these online communities, is that you can connect with so many more teachers and lean on them for help, especially as you get your own feet wet or want to pick up something new yourself. 

And then lastly, a sort of memento that we offer for students in your classrooms, are CS50 certificates. So if at the end of your own school year, you determine that a student has satisfactorily completed your expectations, and in turn CS50 AP, what we're happy to do is generate for you, certificates that are specific to your own school or your own classroom. Here, one is a sample certificate for John Harvard, who went to St. Savior's Grammar School 400 years ago. And we're happy to generate these kinds of mementos at term's end, so that you can have a sort of certification ceremony or the like, whatever it is you'd like to do for your own classrooms as well, so that students, too, in turn, feel like they've been part, not only of your class, but perhaps a broader global community that's somehow anchored here at Harvard in Cambridge. 

So that, then, is the whirlwind overview of content, of software, of community, some of which we will certainly dive into more detail this afternoon, tomorrow, and beyond. But allow me to pause even more deliberately here for any questions or comments that you might like to share. 

SPEAKER 7: David, I have a question, please. 

DAVID MALAN: Sure, please. 

SPEAKER 7: Yeah. Regarding the certificates that you said that you are more than happy to provide for the schools, do we as teachers need to provide some kind of evidences on each student? Or do we just send you the name so you generate PDFs or whatever? 

DAVID MALAN: We've generally done the latter. So typically, we generate certificates via an automated process for students who officially satisfy the requirements of CS50x, which is the OpenCourseWare version of the class. You of course, as a teacher, might have your own approach to the class. You might not have them do the same problems. So we trust that the teachers will tell us who should be issued such via the tool. Peter, question from you? 

SPEAKER 5: Yeah. During the school year, I know that you guys have your whole class and structure and all this stuff, what kind of support can we get during the school year if we run into issues with the curriculum? 

DAVID MALAN: Really good question. Let me go ahead and make this-- can I edit this? I can. Give me one second. So the primary contact, which you might have emailed in the past already, would be this address here, which should be showing up on your screen. And that's by read by me and other colleagues. at@cs50.harvard.edu. So if you ever have questions about curriculum, tools, or the like, you're welcome to reach out to us directly. 

We would encourage folks, generally, unless it's not something particularly personal or individual, to email one of the email lists instead, again, to which we'll invite you, so that any number of fellow teachers can also chime in. And for those of you who might already be on what we've called AP Discuss, which is a Google group, we're in the process of transitioning to these more canonical lists that will be more general email-based and no longer Google-based. 

So if you are familiar with that, the old is becoming the new. So in short, yes, Peter. Other questions or comments. No? Well, allow me to do two final introductions here. Margaret, I know you might have to dash momentarily. Would you like to say just a quick hello so that folks know who to expect in the coming days? 

MARGARET TANZOSH: Sure. Hey, everybody. My name's Margaret Tanzosh. I've been teaching CS50 AP for the last five years at my high school. So happy about the curriculum. Students are enjoying it. And I've created a lot of tools, labs, etc, and I'll show them tomorrow. So looking forward to doing that then. 

DAVID MALAN: Wonderful. And it was Margaret's classroom that you saw one photograph from earlier. At the risk of a cold call, would another longtime teacher, Douglas, would you like to say hello? 

DOUGLAS: Of course. Of course, yeah. I have been, gosh, I was at the original training in Seattle, I think, that you guys did. I love CS50, I think because of the number of tools that are available to me as a teacher, just in terms of having one place where kids can turn in their assignments. One of the things that I've found makes the biggest difference in terms of kids learning is feedback, giving them feedback, and specifically in-line feedback, so where they make little mistakes, making those notes there, and then in class, I actually require kids to go read the comments. 

I tell them, I spend a lot of time leaving you comments, you need to at least read them. And what was really interesting to me, was I was actually very sloppy about-- like, sometimes would take me a couple of weeks to grade. I'm ashamed to admit this, but it would take a couple of weeks to get feedback back to kids. But when I was at Harvard teaching CS50, they had it pretty much required that as soon as kids turn stuff in Sunday night, Monday afternoon we're getting together and going over it as a group and grading it together, and getting kids feedback immediately. 

And the big adjustment for me going from high school to college was that I only saw them once a week. But what was really interesting to me, was I didn't feel like I had the same personal connection with the students, because I didn't see them as frequently as my high school kids. But I could see their code week after week getting better, because they were reading the feedback, and they were taking it to heart, and they were improving in a way that I hadn't seen in high school. 

So when I came back to my high school, I basically just swore to myself, I'm going to get feedback done within a couple of days after they turn it in. And the tools that CS50 made available made it a lot easier to do that. And I think even more importantly, now that we're going to a distance learning model, I think because I've been able to use the tools from CS50, I actually feel like I'm in better shape than a lot of my colleagues, because I'm already used to giving kids remote feedback, giving it to them regularly, and then seeing those improvements. So, yeah. I've been pretty happy with a lot of the tools that they provide. 

DAVID MALAN: Wonderful. Welcome and thank you to Douglas. Allow me to share one url, if folks wouldn't mind pulling this up. And Brian, if you wouldn't mind pasting this into the chat. What we'd like to do at the end of each session is get a bit of quick feedback from everyone. If you go to cs50.ly/feedback, there are a few questions that await. And no rush on that, but if you wouldn't mind submitting before 3:00 PM eastern, so within the next 30 minutes, that would be great. 

Allow me to reintroduce one final speaker here. Brian, if you'd just like to say hello and give folks a verbal teaser of what awaits tomorrow after this afternoon session today. 

BRIAN: Hi, everyone. I'm Brian. I spoke to a couple of you before the session began. But I work here with CS50 as a preceptor at Harvard. And so Kareem, later today, is going to talk to you a little bit more about CS50's tools, introducing things like the IDE and the Lab and the Sandbox, which David mentioned a little bit today. Tomorrow, I'm going to go into more detail about other tools specifically for grading and submission. 

So we have tools to automatically grade students work, to handle the process of collecting student's work, and providing feedback on student's work, organizing all of that, and working on trying to detect any possible similarities in cases of plagiarism. So we'll talk about all of those tools and a couple more tomorrow, to go into more detail about submission and grading. So good to talk to so many of you today, and looking forward to the rest of the workshop. 

DAVID MALAN: Indeed. And allow me to paste the url of the workshop's agenda into the chat window just in case you don't already have that open. Our next session is with our colleague Kareem to focus in more detail and more hands on on tools. That'll be in just over 30 minutes at 3:00 PM eastern time. And allow me to wrap things up here for this session to allow folks some time for one final thing. 

Allow me to propose here that we end with some brief breakout groups. If you would like to stay off the grid, that's totally fine. But we thought we'd end by breaking everyone up into small groups, just so that folks can get to know each other a little better. We'll try to do these in different sessions so you get to know a different small group of folks, in particular, so that you feel that there is a community of teachers out there to whom you can turn as well, and perhaps ultimately put some faces to the names. 

In just a moment, Brian's going to click a button and break us out into smaller groups. And we'd like you to consider, if you're comfortable participating in such, just three questions, to introduce yourself, who you are, and where you are, where you teach and the like. And then, more pointedly, what are you excited about when it comes to the coming school year, be it in the context of CS50 AP, Computer Science, or any of the classes you might be teaching? And three, what are you nervous about? 

So if you're comfortable sharing both an excitement and a bit of nerve, it'll perhaps put people at ease as well as inspire them to consider their own direction this fall. So in just a moment, you'll get a pop up inviting you into a small breakout group. There is no need to spend 30 minutes on there. When it feels like the conversation has petered out, feel free to disconnect. And we will see you again at 3:00 PM eastern, per the agenda, in the chat window. Wonderful to see everyone. We will see you again soon.