AP CSP Deep-Dive

Hello and welcome everyone. Thank you so much for joining us for our afternoon webinar. We are coming through the tail end of our summer webinar series. We've been running these free webinars on various CodeHS courses and programming languages all through the month of June. We've had some wonderful teacher trainer panelists here to answer questions about courses and provide insights into the classroom practices that they have found most effective in their years of teaching experience. And so we are so lucky today to be joined by another fantastic teacher trainer.

I will welcome everyone to the session. Today we're going to be exploring the AP Computer Science Principles course and the CodeHS coursework that goes along with that College Board exam and framework. My name is Stephanie Bennett. I'm a professional development specialist. I'm joined by Steve in the background who will be answering questions in the chat and monitoring the Q&A. So, if you would like to go ahead and find your chat, I will make sure that we can all chat with everyone.

We're a pretty big group here today, and so I will ask attendees that what you put in the chat be greetings and sharing your ideas and anything that is fun and interesting that you want to share. However, if you have questions, please put those in the Q&A because then Steve will guarantee that he sees those and can either answer them in the Q&A or can float them to Chopen if you have specific questions about her classroom practices or experiences—which I hope you do today because she is a wealth of knowledge.

I'm going to put a link to the slide deck in the chat. As you can see, I am screen sharing in the Zoom, so you don't need to have the slides pulled up. But if you want to reference them later, come back to them when we're closer to your start of school in the fall, you will have access to those slides for a long time, probably until we do this webinar again next year. So, we're very excited you all are here. I've introduced our CodeHS team and so now I'll ask Chopen to introduce herself and tell us about her teaching experience.

Hi everyone. It's so great to see you here during your summer. My name is Chopen Jacobson. I am a computer science teacher, and I've been teaching Computer Science Principles since 2016 when the course first launched. I've been reading since 2017 and I love teaching AP Computer Science Principles. It reaches so many different learners, and I have so much fun teaching them, seeing them learn, and seeing them sparkle in the class. I also have been a table leader recent years and a College Board AP Computer Science Principles consultant. I love to work with the students in the classroom and I also love to work with the teachers. So welcome, guys.

Thank you, and we love to have Chopen and all her expertise here. So, what we're going to do is we're going to work through some information about our AP CSP courses. We are going to get Chopen's opinion on how she approaches teaching the course throughout the school year and how she approaches exam prep with her students.

We'll start with a courses overview because here at CodeHS, we actually have a couple different flavors of AP CS Principles, so you get to pick which language do you want to teach in and what concentrations do you want for your students. We will ask all the attendees here today to put on their teacher hats and experience a lesson from the student side. So, if you are brand new to CodeHS or you are brand new to AP CSP, then fear not. We're going to give you some time to see what this content is about and experience a lesson and all the great resources that are available to students in this course.

We are going to talk about AP general College Board information, and we are very lucky to have another CodeHS team member here on the line, Regita, who updated our CSP Python course this past spring and brought us lots of new exercises and practice for your students. So if you have questions about the CodeHS Python AP CS Principles updates for this summer, feel free to drop those in the chat, and I'll describe a little bit about what's been updated in that Python version of the Principles course. All throughout today, and especially we'll save some time at the end, we'll get advice from Chopen and her experiences.

So again, if you would like to introduce yourself in the chat, drop fun facts in the chat, meet other teachers in the chat, that's all great. Steve is going to monitor that and also the Q&A. If you have a question, please, because we are a big group today, we don't want your questions to get lost, put your questions in the Q&A.

All right, so a little housekeeping. If you do not have a CodeHS account, I will ask you to click this link in the chat and go ahead and sign up for a CodeHS teacher account. There are some questions you'll have to answer to get verified as a teacher, but that will get you access to answer keys and tools—the things that you as a teacher need to implement and teach. So please go ahead and start that process if you are new to CodeHS, and I'll tell you a little bit about our company, history, and product.

We are a comprehensive computer science curriculum provider. You might think when you see our name CodeHS that we are high school only curriculum, however, we have recognized over the years the need for younger and younger students to have the opportunity to get exposure to computer science curriculum and learning opportunities because it is becoming more recognized as a necessity for career readiness and college readiness. We want to help students just have fun, express their creativity, and feel comfortable at an early age experiencing computer science content.

And so we've trickled down. CodeHS is 14 years old. We've trickled down in those 14 years from only high school content to middle school content. Then in the last four years, we've also created CodeHS Elementary, which is our elementary teaching platform. So we are K to 12. All of our curriculum is web-based, so as long as your students have devices, whether it's iPads or Chromebooks or MacBooks—whatever your students have, as long as they have good internet—they'll be able to get access to the great high-quality instructional materials we have to offer.

We do also have some LMS features to help you teach more effectively and more efficiently. Things like the ability to communicate via message with students that you enroll and roster on the platform, the ability to give feedback to students on their work, to view their work, and grade it. All of these are available through that free account. If you are a Pro license holder, then you get even more powerful tools. Things like access to our academic integrity suite of tools, customizable grade book, and the ability to pace and configure access to assignments for students. Either way, we're happy you're here, whether you're a free user or a Pro user, and we're going to focus on the content today. So if you have questions about any of it—content, curriculum, teacher tools—ask away. We'll get you answers. That's why we are here to spend the next 90 minutes together.

So, I appreciate everybody being here and I'm ready to jump in if you are. So, first let's take a look at the different flavors of our CS Principles course. We have four options for your high school students, and they range from 125 to 175 contact hours. So, these are all yearlong courses if you want them to be. I know some teachers do teach AP CS Principles in one semester; there will be a lot of content to cover in that one semester if so, but I want to just show you the options. In the chat, Steve, thank you, has put a link to the overview pages for each of our flavors of the CS Principles content. We have AP CSP in Python, and since that's the most updated one, we are going to kind of deep dive into that one when we take a look at the different modules today. But we do also have Principles in JavaScript, the Roblox-based flavor of Principles, and then our Cyber Security course which uses JavaScript but then adds lessons on cyber security and has some great content there for students.

Chopen, here's your first question. The Principles exam we all know is language agnostic. So which version of CS Principles do you teach and why did you pick that one?

I teach the AP CSP Python version. I have tried many different things since I started teaching CSP. In the beginning, I used Snap, and then I felt like Snap hid a lot of details. The abstraction level is higher than I like. So I switched to Snap and CodeHS. I used Snap to help the kids do the Create task and then CodeHS to learn deeper the code behind the block language. But since 2024, we have a new curriculum; we have the written response components due to the impact of AI, so I totally switched to CodeHS. I mean, I use CodeHS in its entirety; it is phenomenal.

Initially, I was worried that my kids were going to have a hard time building the Create task, but it turned out that is not the case. Number one, it gives students enough specificities to navigate through the core skills that the Create task requires and the written response requires, and the block-based language does not help that much in terms of the written response. If you look at the written response scoring guide, it asks a lot more than block language can provide. That's why I love the CodeHS Python version of the CSP. The another reason I use Python language is because it's a popular programming language. The kids love using Python because it's easy to learn and easy to understand. So that's this one. I hope I have answered your question.

Yes, yes. And I love that it sounds like you have high expectations of your students and they rose to it, right? I just love that the CodeHS Python version of the CSP curricula really aligns with the CED well and provides the opportunity for kids not only to build their understanding of the concepts but also helps to transfer the skills required for the Create task and written response, and CodeHS does that really well. I appreciate the great praise there.

That leads us into our next question. How is this course content received by your students? Do they tell you they felt well prepared for the exam?

That's the main reason they love it. After we go through CodeHS in connection with AP Classroom, the kids are really well prepared. When they finished the AP exam, they said, "Oh gosh, you overprepared us." That's what they were saying, so the curriculum is really well written. The autograder really helps the kids because they can get instant feedback from their coding project and see what they did right and what they did wrong, and they can improve right away. That is really a huge success with the CodeHS curricula.

Fantastic. Well, I know that Regita worked really hard to update some of the autograders in the Python course over the spring. Hopefully, like you said Chopen, that instantaneous feedback helps, and also the ability for students to get lots of repetition and lots of practice opportunities. Because our system is made to really have clear indicators for students when they've successfully passed an assignment or if they still need to keep working on it a little bit, they just get so many opportunities and repetition, and that's essential when you're learning something for the first time. As I think most AP—Chopen, would you say most of your Principles students, this is their first coding course?

Yes, most of them, because this is an intro-level AP course. Then they're going to get promoted to CSP, and this year we're going to have an AP Cyber Security course. They're going to get promoted to either CSP, Cyber, or CSA. So it is the introductory level of the AP course. Most of them did not learn any programming language in the past.

Yeah, and that just speaks again to the ability of the course content—the way that the College Board decided what to include in the course and made it really accessible to students. Then we supported that with these modules that we'll kind of take a deep dive into. Regita, this is from the revamped version of the Python course, so if you want to chime in here and talk about any of these specific units or projects, please feel free to.

I'll just do a quick overview. Students start in our Carol coding environment, and it's a really pared-down coding environment. Carol is a dog; she's our mascot right over my shoulder here. Because she's a dog, she only knows a few limited commands, so students get lots of practice with the syntax of the language they're learning. They get lots of practice with the algorithmic thinking that they need to put in to create their code in such a way that they successfully pass the coding challenges. But it really takes a lot of the cognitive load off because they're working with just a limited set of commands that they can give Carol to move her around her world and put down tennis balls or pick up tennis balls. Actually right now, because we're in the World Cup season, we have soccer balls in our Carol world right now, so a really fun, playful addition to our Carol modules this summer.

Then we move on to a pair programming project, and Carol learns a few more commands where she can paint the blocks of her grid world different colors. Then students actually get into seeing Python and typing the characters and coding whatever they want. They have to define functions and call them, define variables and use them in their code, and use the for loops and the conditional structures available in Python. It's all really step-by-step and well-suited to new programmers.

Then a practice Create task, Tell a Story. I believe this is new, Regita? Not quite, it looks like we snuck in an old screenshot here. What's existing is Tell a Story is still in the updated version, it's a little bit later when we get to the practice performance tasks. Yep, here we go.

Okay, yeah, so this is the overview page that Steve put in the chat. Here's the Tell a Story practice, and then we get into students learning data structures, number systems, pixels, all that fantastic stuff, and get to then try another performance task, Shopping List. Is this the new one?

Yes, they might have seen the Shopping List in our supplemental modules before, but we revamped it a little bit and moved it to a main module just to better tie it to the College Board's expectations.

Fantastic. Thank you. Okay, so then we move away a little bit from coding to help students see the full picture of computer science as a field. We know that there's more than just programming involved in computer science, so we see some units on the internet, the effects of the internet, data and how data can help us through modeling and visualizations to do all kinds of things and make great data-driven decisions. Another practice, Personal Data Tracker, a project, the Impact of Computing, and a final Create Performance Task Helper. This one walks students through the process of what they need to know as they approach that performance task submission to the College Board. We do also have an exam review and, if you'd like, a final exam and a pre-test for your consideration.

That is kind of the throughline of our new revamped Python course. You can expect 125 contact hours including 163 video lessons and 308 exercises. Again, we want to get students lots of repetition and practice. This time there are 49 challenges, I think that's a few more than the previous version of this course, and lots of handouts because there's a variety of CS topics involved in this course. We want students collaborating and talking about what they're learning, debating the merits of how to use data and when to use data, and it's just a lot of great activities for students. We are still 100% aligned to the AP CSP Principles 2020 standards, but we just have some new assignments, new item types, notes, updated quizzes, and again that additional practice performance task. We can get you the syllabus too, if you would like.

I don't want to cut you off, just one more thing with the Python updates. They might have seen the Shopping List before, as I mentioned, but now it is revamped. Once we launched at the end of May, we also added in the Data Tracker performance task, which we tried to get to before the end of last year, but it's definitely in there for next year for them to practice. The Data Tracker is another new practice performance task in the Python course.

Awesome. Thank you for interjecting, that is great information for folks to have. I do want to share that we still have supplementals. If you find yourself needing more practice for your students or additional content for your students, we do also have these curated supplemental modules that you can find at the very bottom of your assignments page once you create an AP CSP section.

Chopen, because this is a survey of the computer science field, what topics and projects tend to engage your students the most?

Thank you, Stephanie, for giving us an overview of the new updated Python version, that's very helpful. I think you have touched base on it: Carol the dog is the most engaging one in the first week of the CSP class, and it provides instant visual feedback. When the students type the right line—for example, `move` or `turn_left`, and then pick a ball or put a ball—they hit the run button and they can instantaneously see how their instruction works and where it doesn't work. Also, having the debugger line up with the code is a great, reassuring unit. I always give this one at the beginning of the school year. They have fun, they work through the group, pair programming gets introduced, they work together, the fear gets removed, and they say, "Oh, I can do it," instead of dropping out right away. They give it a try and then later on get a little bit deeper.

The thing is, this is the most engaging one because it helps the kids to focus on logic over syntax. It's really problem-solving based. I want Carol the dog to move to the right three steps to pick up the ball; I don't have to think of the syntax, just click the block that is hiding the details. It's a good introduction with a high abstraction level programming construct which is block-based, and it's really helpful to move them forward with programming. The last piece is a gamified problem-solving approach. Basically, they are given the four basic commands and the kids can use this to pick up the ball, move the ball, and carry the ball over the fence. It's fantastic. I could not say more about this unit. I have loved this unit since the first time I taught with CodeHS. I highly recommend using this one in the beginning of the school year so that you can engage your kids and encourage them to stay with your class.

Yeah, I appreciate that advice. We had somebody in the chat asking about collaboration and whether it's kind of built into the course, or do you find that it's really you the teacher who's saying, "Well, on this exercise I want my students to collaborate versus a different exercise," because the Create task allows students to collaborate.

That's a really great question. I basically introduce pair programming in the beginning of the class. I'm from the field, so I know how much fun I had when I was in the programming field with five or six people in a team. We are not working alone; we code, we shout out, "Hey Steve, how does this work? Why is there a bug here? Can you help me?" It's not like you stay alone and work by yourself. We want to recreate this work-based programming environment, so helping the kids see that collaboration is a huge piece in the real world is key. They should not only be able to code, they have to be able to—like Stephanie said—talk through the code and walk through the code. That's a huge piece, a skill we need to help the kids develop over the time they are in CSP, CSA, or Cyber.

Yes, collaboration is highly recommended in the beginning of the class. That's the tone we set up for the kids: you're not alone, you work with your peer, you do the programming, I help you, you help your partner, and you work with your partners. It's not like you have to do it by yourself, that's the main message we send out. Like Stephanie said, the Create task encourages collaboration until you get to creating your written response and video piece; the rest of it you can work with the group. We want to get this message across so that they enjoy learning more. This is one way to really invite the kids who never think of being in the field of computer science or a computer programming class to come in.

That was kind of why the Principles course was created, right? To be inviting to a wider variety of students. Let's go to the other end of that: what concepts do you find year after year students kind of struggle with, and do you prepare scaffolds in advance?

Well, that's really a great question. Based on my years of experience and reading, I really know that data abstraction and procedural abstraction are huge concepts, and they are very challenging for kids to understand. To be specific, variables hold values that change line by line, which is the core concept of a variable. The CSP Create task asks you to use a list or a collection data item—a variable holding a collection of data, meaning you can use a list, an array list, a 2D array, or a dictionary to hold a bunch of data and then see how you're going to process the data in front of it. How do you understand that this data structure hides implementation details? This is the hardest part of it.

I intentionally created a "mom's fur bag" case study for it, and that helps the kids to understand: oh, mom's fur bag is the name of the list, it's a collection of information stored in the mom's fur bag, and then I can use the variable of the data structure and an index to look at the information stored in mom's fur bag. It's really important we do this and then walk through how data helps manage complexity.

I like that suggestion of the case study, that's really great and gives them lots of examples of why they use this abstract concept in their coding. Regita has updated the new version to add the Shopping List and a Data Tracker in it, which can be your case study. CodeHS set it up for you. Using the Shopping List is a great example because everyone goes shopping with their mom or dad and knows what a shopping list is. You can use that to really get through what data managing complexity means, and what the Create task is looking for regarding this concept. This is a very huge piece.

We want to really showcase how to rewrite loops. If you do a linear search or a binary search, how do you rewrite that part of the linear search to search every element on the shopping list using a loop and a list to write the code, and how would you rewrite it without using a list? This gets tested every year; it is one of the most challenging topics there is for kids.

Another one is procedural abstraction. This year, they talk about procedural abstraction. If you write your procedure and another programmer wants to use your procedure in their programming environment, how is that programmer going to test your procedure to see if there are bugs or if it's working properly with any possible inputs? Many kids do not understand this question because they do not understand what procedural abstraction really is. If you model this in the CodeHS environment, the kids have a much better chance to answer this question correctly. If you have Code.org, they have their own environment where the buttons are already built-in, and they just phrase things there. You can tell many of them write beautiful programs and talk about all the test cases, but the test cases come from their own programming environment; they didn't ship it out as a unit and test it in a different environment. This is a huge piece.

Regita has done the rewrite for this year's Python program. What I did with my kids is add a lot of activities to scaffold this practice, walk through the code, and share what a parameter is versus what an argument is. In this case, in this tiny Create task, the argument literally is the value passed through the procedure in the place of the parameter. This is the hardest part of the topic, but they test the kids every year; it is the dividing line for scores of a four or five, or a three to four, so we really want to pay attention to this testing piece.

The CodeHS Sandbox and the completed programs can help your kids do so much with this. Testing and data abstraction are the most challenging pieces, and we need to really model them throughout the year multiple times.

Those insights are so valuable, and you have such specific examples relating back to the test itself. What I'm hearing as a throughline to those examples is that we rely on intuition in our human language, but computers don't have intuition. Getting students to understand the exact logic and computational thinking that a computer needs to be given directions in both of those scenarios requires a huge leap from human intuition to the way the computer understands commands. I think that is the core theme of your answer.

Let's go ahead and have folks jump into our lesson as a student. Hopefully you've had time, if you are new to CodeHS, to sign up for your teacher account. Now, we're going to ask you to put on your student hat. Go ahead and click the link to join our section. Wow, I see the chat is just popping, I love it. Folks are sharing ideas. I am going to put a link to this summer webinar CSP section so you will actually be joining as a student where Chopen and I are the teachers in this section. You can either click on the link in the chat or type out this URL: codehs.com/go/d0984. Once you click on that link, you will be brought to a screen that shows "summer webinar CSP." Chopen and I will be listed as teachers, and there's a big blue button that says "join section." Go ahead and click that, and we're going to be looking for module 3, Hello World. That's the lesson we're going to walk through today with our student lens on so you can get a feel for how CodeHS lessons are structured and what you and your students can expect working through this coursework.

I am going to jump over to my teacher side. It might help if you have the screen real estate to put the Zoom on one half of your screen and the CodeHS platform on the other half of your screen to follow along here. I will jump over to the teacher side, go to our assignments, and find this lesson that I wanted to show off for you.

Let me move into the student view so I will mirror what you're seeing as a student, and I'm going to collapse this unit one because we want to move down to programming with Python. I wanted to get you a view of a typical lesson in the programming part of this course, so we're going to check out lesson 3.3, Hello World.

A little vocabulary as you're following along and navigating the site: modules and units are used interchangeably here at CodeHS. That will be a thematically grouped set of assignments. Lessons are listed vertically: 3.1, 3.2, 3.3. Generally, I would say you can probably allocate 45 minutes per lesson. If it's a more introductory level lesson, especially the Carol modules, maybe you could get through two lessons in 45 minutes. Because there is that flexibility to decide the pacing of this course, you have all these great materials, but what is the pacing that's going to be appropriate for my students? What is my teaching style? Do I want to allow students to work self-paced through this content and everybody's learning something different, or do I want to try to keep my students all learning the same lesson the same day of the week while I do more direct instruction and my students are collaborating? It's totally up to you. We have teachers who do both; we have teachers who are at one end of the spectrum and the other. As we're looking through these materials today, I encourage you folks to be thinking about how this resonates with your students and their needs, and how this resonates with your teaching style and what you're used to doing in the classroom. You don't have to throw the baby out with the bathwater; you can really make this yours with these great curricular materials.

Let's take a look at the activities. Within each lesson, your students are going to have several activities or assignments to complete. Generally with our coding lessons, the content is going to be delivered via a short video. You can see this video icon here. It will generally, though not always, be followed by a check for understanding. This is a short little formative assessment; we call it a quiz by name, but it's really just a check for understanding. Next, this piece of paper icon indicates an example exercise. These are fully coded; they already work and are professionally made. They're for your students to practice reading code, predicting the output of code, and tinkering and exploring. Because these are fully functioning programs, encourage your students to try to introduce a bug, try to change the output, or try to be creative with this code because you can't break it since it's already written.

These pencil icons indicate an exercise where students are going to have to code either from a bit of starter code or just from a blank file in our editor. We do have other kinds of assignment types like debugging activities. You can see a badge here that students can earn as they work through the course. We also have notes types of activities which will provide a written explanation of a concept and then maybe a little interactive widget for them to explore.

Let's stick with lesson 3.3, Hello World, and let's dive into our video from the student view to get a feel for what these videos are like.

"Hi. In this video, you'll learn how to make the most basic Python program, one which displays text on the screen. When you run these programs, you'll see the text appear on your screen in what is called the console window or just the console. You can print in Python using the print statement. It looks like this. First, you have to start with the word print. This is pretty self-explanatory. You then need to include a set of parenthesis. Anything to be printed should be included inside the parenthesis. You need quotation marks around the thing you want to print. Note that you can use single or double quotes, but we'll be using double quotes throughout this course. The important thing here is that the quotation marks need to match. A sequence of characters surrounded by quotes is called a string. You'll learn more about strings later. So, here we have your program or code on the left and your console window on the right. When you click the run button, the Python interpreter will jump right to the first and in this case only line in your program. It executes that line and you see hello world appear on your console. A program is essentially a sequence of instructions. If we have two prints in our program instead of one, they will be executed in order. The interpreter executes the first one and then it executes the second one. Now it's your turn to try using the print statement in your own Python programs."

A quick little video there for your students to watch. If you want to do a more direct instruction approach, you could put the video up on your projector and the whole class could watch it together. Alternatively, if you've got a couple of years of teaching computer science under your belt and you want to present, you can still use our slide deck. If you toggle at the top here from video to slides, then you could add explanations or different examples, or pause and ask students questions as you are clicking through this slide deck.

Before I continue to the next assignment, I want to draw your attention down to the bottom of my screen here where we can see these bubbles indicating where we're at in this course and the color coding. There is meaning throughout the platform on both the teacher side and the student side to these colors. Yellow means that I have opened an assignment but I have not submitted it as complete. Gray means I have not opened an assignment yet. This quiz that we're going to head into next hasn't been opened yet, but the video I did watch and click through the slides, so it is this teal green color. I've earned my point in the grade book and I can click this continue button and move on to the next assignment.

Here we have our quiz. All right students, here's where I'm going to ask for your help. Looking at the video, what is the proper keyword to print to the screen? Answer me in the chat. Is it `write`, `print`, `len print`, or `output`? All right, we're getting some answers; I will go with the majority. We'll click `print`, click check, and yay, we get some confetti. We got it correct. Awesome job, students.

Question two: Which of the following print statements is written correctly? You can put one, two, three, or four in the chat, let's go with that option. Ah, they're quick on it today. All right, I'm seeing three, so let's try it out. I'll click check. Awesome job students, you got the second question right also. Now we can submit this quick check for understanding. Again, watch those bubbles on the bottom of my screen: we'll go from gray to a green completed bubble.

We've moved on to an example exercise. I love to point these out because there's not a lot for students to do here inherently; they run the program, they can click next, and they can move on. However, that's a missed opportunity. We want to encourage students to really push these example programs to the limits, tinker with them, change the code, see what happens, and it's even a great exercise to not even let students run it at first. Show the code, give them time to think about what might happen when the program is run, ask them to predict what's going to happen, and see if their hypothesis is correct. Here we can click run and we see "hello world" printed to our console.

Chopen, how do you use examples with your students?

I think, Stephanie, you have just covered that. Basically, you have the example with the complete code in CodeHS, and you can just pull that up. When the kids are working on coding for a little while and you see them starting to chat about something not related to CodeHS, it means they are done or they are bored, so drag them back into your focused instruction. That's the perfect time for you to pull up the complete example to be explored, make some changes, and then intentionally create a runtime error. When you run it and show them, ask them to see what's going on and ask them to describe right in their notebook: what did I do to create this error? What type of error is this—is it a syntax error, runtime error, or logic error? And then what is the result? How do you classify the type of error?

That's what the College Board looks for. This links to Big Idea 1.4, where there are three great videos. I always introduce these videos in week one or week two of the lessons. I ask them to watch those videos, take notes, and then we will have a class discussion about syntax errors and grammatical errors. You write some English sentences where the grammar is not correct—that's a grammatical error. How do you classify that in the environment in CodeHS? What is a logic error? The program runs but gives you the wrong result. How do you introduce logic errors? Then runtime errors—infinite loops, mathematical unbound calculations, or any number divided by zero. We want to really use this great opportunity to create errors intentionally and ask them to write about it.

In the beginning, you will see they watch the video and they understand it, but when you ask them to write about it, they just cannot connect. You just have to model it. Let them line up one-on-one, chat with each other, shift, talk, and practice. This takes a lot of practice to really understand the three types of errors they will encounter in their coding. This is something I really do a lot in my earlier days before they start their Create task. This is a really important part of it, and you just intentionally connect with the core skills in the CED to make sure they get it. Those core skills are the heart of the Create task and the written response.

Yeah, that's excellent advice. It's a different kind of thinking for students, a different sort of challenging task, but just as important as getting the code correct.

Let's move on in our student view here to an actual coding exercise. I want to point out some of the features of our programming environment. We have some instructions: "Write a program that prints out your name on one line and then on the next line says a hobby that you have." We can move our file panel out of the way so we have a little bit more coding area here, and we can start coding away.

I do this because I want to show you some of these cool features that we have available to students so they can help themselves. We all know that students are going to struggle from time to time and introduce bugs into their code more frequently than they would like, but we want to keep them in that productive struggle and help them through it. Students can write their code here, but look at the features over on the right-hand panel. We can run our code here and see the output, and we can use this "Check Code" button that Chopen mentioned is really helpful to students. It displays test cases and rules in our autograder, making them visible to students to help them understand if they do have an error and what they're missing to submit this challenge successfully.

The other thing I want to point out is our docs tab. This is super important once students get into control structures. Maybe they forget how to write a loop in Python; they can open up the documentation, move to control structures, and find for loops. Oh, it's `for i in range` however many times I want the loop to run. This is essential for students to learn as a professional skill—to be able to look at documentation to find what it is you're looking for.

In the assignment tab, they see the directions again. In the grade tab, they can see a grade if you have provided one to them. There are a couple things in the more tab that I want to show you, and then I'll ask Chopen what routines she builds with her students around these self-help items.

The first one was the docs tab—absolutely essential. The next thing I want to show you is the history. We don't have an undo button in the CodeHS text editor; instead, to get back to a place where a student's code was working, or if they want to go back to the starter code, we have this timeline of snapshots. If I paste code, there will be a flag up here that says I pasted or ran my code, and if I need to reset my code, I can go back in time to whatever snapshot I want my code to look like from my coding history. That's a really important one to show your students from day one.

The other is the video tab. It's called video, but actually, it pulls up the slide deck. If students forget how to print to the console, they can go to the slides and check their code syntax: `print` open parenthesis, quotation marks, and make sure right next to that video slide deck they can copy the coding structure from the video.

The last one I'll point out is the conversation tab. This is a really amazing feature for teachers who are teaching virtually or asynchronously. If you're assigning homework or any kind of asynchronous work to your students, this conversations tab is a lifesaver. Your students can say, "I need help with this one," and send you a message. You'll be notified that the student has reached out for help. The best part about it is, if you are assigning homework and you think, "What was that name and hobby assignment? I don't remember what Stephanie is asking for help with," you can jump directly from your notification into your student's program and see exactly what they're supposed to be working on.

These are some features that are important to establish routines with your students and make sure that they understand the tools they have available. Chopen, what tools and routines do your students find most useful when working through coding assignments?

You have introduced everything in a very comprehensive manner. I'm just going to add my classroom practice here. In my class, I use a flipped classroom strategy. At home, I ask them as homework to complete pre-reading—for example, watch the AP Daily video from AP Classroom, take notes, and then pre-assess something from CodeHS, like watching the CodeHS video and completing the formative assessment quiz in each lesson. They can then explore and try the coding piece. However, in class, we're going to do pair programming and help each other get through the programming piece. That's how I did it in my classroom.

Regarding the IDE, I really like the instantaneous self-check part of it. The kids just pick up on it on their own. First day I'm going to say, "Hey, this is how we're going to do it." They write the code just like how you did it. Then I'm going to say, "If you didn't finish your code, you hit save, and if you want to submit and continue, you can use that button." What I ask them to do is the checking. Run the code, and if there is an error, I tell them ahead of time: the culture of computer science is error and testing. Creativity comes from error and testing. Do not get scared or afraid of seeing an error in your code. If you see red crosses when you run the code, that's normal, that's part of computer science and part of being a computer scientist. Just look at the error message, don't panic, don't say, "Oh my gosh, I'm a perfect student with a perfect GPA," and throw your hands in the air.

Don't be afraid. Tell them this is a really good time to introduce the culture of computer science—being creative and not afraid of errors, especially for girls. The girls often focus more on GPA and want to have perfect scores, so tell them that this is a normal part of computer science, and that helps a lot. The docs tab is really helpful because we are developing their understanding of the concepts and content while helping them transfer their understanding to be able to do something with it. That's the hard piece. Like Stephanie just said, repetition is the key. How can I help the kids do the repetition if they cannot find information right under their eyes? The docs tab is really powerful; you can open it up and find the sections for loops, selection, or logical operators—it's all there. For teachers, if you click more, there's a solution button; that's your lifesaver. That's how I use it in my class. The history tab is a good one too; I didn't use it as much, but in the coming year, I'm definitely going to use it. Thank you, Stephanie, for sharing that.

As a lifelong perfectionist, I appreciate the coaching that you do with your students that errors are normal. Computer science has definitely taught me that. I didn't know you did a flipped classroom, but I love that. We'll have to do a webinar on the flipped classroom for computer science sometime.

I'm telling you, Stephanie, this is a very good way to help kids learn. Another thing to extend this a little bit more in terms of assignments: I focus on the process, not the end result as much. Some kids need a longer time to digest and understand, even to understand the concept of iteration, not to mention applying, transferring, and being able to do it. So I give them longer. Usually, I give one week for a set of assignments. They can use their own time to digest the content and concepts and then be able to do it. I have found success in this way, especially for the kids who are not initially comfortable with computer science concepts. Thank you.

Great. Steve, I want to see if there are any questions to elevate to Chopen about the curriculum, lessons, or assignments before we transition over to the College Board information teachers need.

Yeah, well, actually the one question for Chopen is going to be about AP Classroom. Chopen, there was a question about the videos in AP Classroom and how you match them with the CodeHS curriculum units—whether there's like a general rule you follow or any specific advice. That was the question in the Q&A for you.

That's a great question. This is how I do it. I start the lesson with the CED, Big Idea 1. I go through Big Idea 1 through 4, and then I assign the videos based on Big Idea 1: 1.1, 1.2, and especially 1.4. The three videos for 1.4 are a must-watch; whenever I have a workshop, I say these three videos are a must-watch. Then I assign the topic questions aligned with Big Idea 1.1, 1.2, and 1.4. For the CodeHS piece, I align the beginning when I assign the Big Idea 1 test to my students with Carol the dog module; that aligns really well.

When I get to Big Idea 2, I skip it at the beginning of the school year because I intentionally finish up Big Idea 1 and Big Idea 3 first. The CodeHS unit 3 that Stephanie introduced starts following Carol the dog, and then unit 4, I believe, is control structures. I align loops with 3.2-ish, and then unit 5 is functions and parameters, which I align with 3.1, 3.4, and 3.5. Then you go down to unit 7—I skip unit 6—unit 7 is lists and basic data structures, which aligns with loops and lists.

Once you finish this, students are ready to have their first mock Create task. I literally go with the AP Classroom CED order for Big Idea 1 and Big Idea 3, aligning perfectly with CodeHS unit 3 Carol the dog, unit 4, unit 5, and unit 7. That packages up nice basic concepts and skills for the kids to start working on their mock tasks. This year is even better because we have the Shopping List and the Data Tracker modules; you can use these to do your mock tasks instead of creating your own case study like I did with "mom's bag." If you have time, create your own case study; your kids love it, and lining up the activities is really good. I hope this answers the question, and I'm going to add this: AP Classroom, AP Daily videos, AP topic questions, and CodeHS pair together perfectly to help your kids be successful.

Thank you again for that praise. We'll move into some additional information from the College Board and get more of Chopen's advice on getting your kids ready for the exam.

Here are some key components that you should be aware of regarding the exam itself. There is Section 1: Multiple-Choice Questions. There are 70 exam questions and students get 120 minutes to answer those; it is 70% of their score. Most of these are single-select multiple-choice, but there are a few with a reading passage and multi-select versions of some questions.

In Section 2, we have the Create Performance Task. This is 30% of students' scores, and they have a lot of work to do that will require some class time to complete. You do need to provide nine hours of in-class Create task prep time for students. They need to be ready on exam day to answer two written response questions for 60 minutes about the product that they created.

Chopen, you talked to us about how to align the College Board materials with CodeHS materials. Any other advice for navigating the College Board system or helping teachers prepare for the exam?

The first thing I do is look at my pacing and take a look at when I want to get the Create performance task done. Usually, I do it no later than the end of February or early March. Once you nail down that timeline, you go back and see what practices you can use in CodeHS to prepare your kids with the four core skills; that's the foundation for them to set up their Create task properly and answer the written response efficiently.

How do you do that? You want to align the CodeHS first seven units, skipping some, with Big Idea 1 and Big Idea 3. This beautifully helps the kids see what input and output are, and what sequencing, selection, and iteration mean, as well as procedure calls, parameters, and arguments. Once they have all those understandings and are able to transfer and apply them to build it up, they are ready. That is a very important piece because the core skills also get tested in the multiple-choice sessions. If the kids are not able to submit their Create task video, program code, and personalized project reference properly in the College Board system by April 30th, they just lose 10 points. They cannot pass the AP exam without those 10 points.

The rest of the 20 points comes from the written response during the AP exam. We need to complete mock practice after mock practice, as Stephanie said—repeat and repeat. Let them practice explaining the purpose and function of their code. Everyone should be able to do it starting from day one. Look at Carol the dog, pull up an exercise, and take a look at what the purpose was to design this one versus what its functionality is. Ask them to explain this.

Prompt category two is algorithm development: why do you use loops? Why do you use variables? Why do you use lists? Why do you use conditional statements? What is the boolean evaluation? What are the logical operators? How does this help the program function sequentially, make a choice via selection, and repeat actions via iteration? Those are the things we really need to go through and help the kids understand; it is the harder part of the exam. We need to provide opportunities for the kids to practice in different scenarios throughout the year.

The second session is the multiple-choice section. This is both easier and harder. We tend to focus heavily on the core skills of Big Idea 1 and 3 in the multiple-choice session, but we sometimes forget about the Impact of Computing. Steve and I talked about it in the beginning of this session: the Impact of Computing has a good 35% to 40% of the questions. Those are the baseline questions. We really want to help our kids get those points, especially language learners who are not as comfortable learning computer science or programming. Those questions help them boost their scores; that's how the AP course is designed—they want to help everyone find success. If they're struggling at coding, those computing impacts really help boost their scores, and the rest of it relies on core skills.

Internet concepts—guys, there are a lot of questions about the internet. What I do in class after the kids finish their Create task at the end of February or early March is start the internet introduction. I make sure they understand routing, the TCP/IP model, redundancy rules, and all those concept-based questions. That's why I push this unit to the end of the course—because those units are understanding-based and don't necessarily ask you to transfer a complex coding skill. It's a little bit lighter, but that doesn't mean it's not important. A lot of kids say they encounter many internet questions, and those points should be guaranteed. We should help every kid find success in this session. The data piece focuses on using data to generate new knowledge: based on this data, what information or new knowledge do you get, and what are you going to do with that? That is the focus of the data piece, which spans units 2, 4, and 5. That is what we really want every kid to get, and that is very important.

Those insights are so valuable to new teachers and returning teachers, I appreciate you sharing that. We do encourage you to use AP Classroom as a supplement to the curriculum materials on CodeHS; there's lots of great content there. Under the course guide, you can find videos, formative MCQs for each big idea and topic, and full-length practice exams that include the written response prompts. The question bank also has more MCQs for each topic and additional written response practices as well.

Let's talk a little bit about recruitment because AP Principles is meant to be an inclusive, inviting course for students. Do you do much recruitment? Do you talk to counselors about helping students enroll in AP classes, or go visit eighth-grade students and encourage them to enroll in computer science? How do you grow your AP computer science program?

Stephanie, you have described exactly what I have been doing, but there's more to it. You need to create an inviting environment once the kids get to your class. I often hear teachers asking how to engage students and get them into the class. On top of the approach where you visit classes and do a short 15-minute presentation to get more kids involved, word of mouth from the kids and parents is incredibly powerful. If you set up your class well, stay prepared, and engage your students—meaning you make the content accessible to all your kids, not just the top performers—using a collaborative approach and pair programming in class, and intentionally practicing quick writes once or twice per week, every kid connects with the content. They become able to do something with their understanding of the core skills, and the kids feel engaged. They say, "Hey, this is really a good class. It's an AP course, and I can get AP credit for courses I want to take in most colleges." They don't have to be a computer science major in college to benefit; they can use this in political science, pre-law, or a medical major. The word from the students and parents is really powerful, and you will build up your enrollment that way. Talking to counselors is one method, doing short presentations is another, and being well-prepared for curriculum night ensures your program performs stronger before you know it.

Related to that question, AP courses are meant to be rigorous. How do you balance welcoming everyone and making it an inclusive class with having high expectations of your students and preparing them for a college-level class?

The mandate from the College Board CED states we want to get all kids who are willing and ready to take an AP course into the Computer Science Principles class. When we implement it, we find many kids face unique challenges. When I was doing AP reading, one of the AP readers shared with me that in her class in the Boston area, 99% of the student population are English language learners. How do we engage those kids and help them find success? This is not an easy task. When you teach only top performers, you feel like you can sail right through. But if the majority of the kids in class face linguistic barriers while being intellectually ready, how are you going to approach it?

We have to find the opening, get them engaged, and chunk the content. CodeHS has done a great job in this case. I have mentioned this numerous times among all the curriculum I have reviewed: CodeHS makes computer science accessible to almost all learners. As Stephanie just showed, each programming lesson doesn't just throw a task at you; it gives you a short video, a quick check for understanding, and a complete example to try out and see how it works. You can change a couple lines to see how it reacts, and then finally you write code on your own with the documentation right there to help you. This learning path repeats throughout the school year, which significantly reduces the cognitive load for the kids, especially those who feel overwhelmed with the AP CSP content.

The chunking piece helps the kids, alongside extra levers you put in like tutoring time or club time to help them connect in the end. As I always say, if a kid is on track for a score of a one and you move them to a two, that is a success. Kudos to you. This is not a class where getting every kid a score of a three is the only goal; we want to see their growth. If they grow, kudos to you. It's hard if you have kids who face severe language barriers to get them to a three or a four, but their growth is the most important thing. If you work through the CodeHS lessons, help the kids connect with the content, help them transfer the skills, and connect it to AP Classroom, you pace it so they master the accessible content. They won't lose points on the conceptual topics like Big Idea 2 (Data), Big Idea 4 (The Internet), and Big Idea 5 (Impact of Computing). If they can get those points and you help them submit their digital portfolio properly, even if they struggle with some components of the written response, they still have a great chance to pass the AP exam.

This is exactly what I wanted to hear, Chopen, because you mentioned at the top of the webinar about the process being more important than the end result. When I was in the classroom, I really struggled with that balance. But now that I've had time to step back and look at the research, these are growing humans. Yes, we feel pressure to teach bell-to-bell, make them successful on this exam, and have our numbers in line for our evaluations, but their individual development and step forward is more essential than a five on an AP exam. I was a former English as a Second Language teacher, so I love to hear you mention that many of your students are English language learners and find success on the exam.

One thing before we bubble up questions to Chopen from our attendees is that Regita worked very hard this spring to update the items in the CodeHS CS Principles Python course. That was a standard curriculum update, but the College Board has recently announced that there will be upcoming changes to the CS Principles framework and exam. While we don't have all the specific details yet, I want to let everyone in attendance know that our curriculum team is fully aware of upcoming changes to the exam and the course, and we will be providing updated course materials once those definitive parameters are released by the College Board.

Steve, I'll kick it over to you. What questions are remaining in the Q&A? Maybe we'll have time for one or two here before we get to our wrap-up.

There was a question about inspiring students to pick creative ideas for the Create performance task. Chopen, any thoughts on getting them to pick a creative idea?

You can encourage them to be very creative for the mini programming projects we do in class. But for the actual Create performance task, in order to earn the points and ensure a high-performing submission, they have to navigate the constraints carefully. I introduce the specific programming requirements that define the scope of the Create task: basically, you must have a list, your procedure must include a parameter, and you must demonstrate the required programming processes. Beyond that, they can do whatever they want.

The main takeaway from the readings, especially recent ones, is not to spend too much time on overcomplicating the creativity part of the Create task. I might sound like I'm countering the idea of pure creativity, but College Board is looking strictly for how the kids manage a collection of data and process it. That's it. The more complicated your program is, the harder it becomes to navigate and explain during the AP exam written response section. I give the kids a chance to do creative work on their own throughout the year, but for the official Create task, they must prioritize meeting the non-programming and programming requirements. Under that scope, they can still be creative—they can design a medicine tracker box, a spaghetti noodle recipe app, or many other things—but it absolutely must align with the list and procedural requirements.

I've worked with Chopen in many webinars and PLC sessions, and she always tells teachers: tell your students to keep it simple. Simple is the best way.

Otherwise, during the exam writing session, you are going to spend tons of time trying to explain an overly complex system. Especially if kids use AI to create a super complicated, sophisticated program, it becomes incredibly hard for them to navigate the written response prompts.

The College Board wants to see that the student understands the program logic; they are evaluating the structural requirements rather than how novel the application is. The simpler, the better.

All right. Well, this 90 minutes has gone incredibly fast. I have learned a lot, and I hope folks in attendance have too. We are here to wrap up now. I saw in the chat that Steve was providing links to some knowledge-base articles; that's a fantastic place to go. If you remember something next fall as you start planning for your CS Principles course and think, "Oh, Chopen said something about pair programming or the Sandbox. How do I do that?"—go to the knowledge base, search for Sandbox, and you will see a step-by-step guide on how to have students work collaboratively.

Also, please reach out to our support team. They are a fantastic group who are incredibly knowledgeable about our curriculum and platform tools, and if they don't know an answer immediately, they will reach out to the right specialist on our team to find an answer for you. Please never fear to reach out to our support team with your questions.

There are other ways for you to stay in contact; we are active on social media, so follow us there. I'll ask you to do two things as we come to our final minutes of this session. We would love to know how you liked the webinar today. We've gotten some great advice from Chopen, but if there was a topic you really wanted to know about and we missed it, please let us know on the survey so that we can plan for future webinars and ensure that you are getting the information and tools you need. We love feedback here at CodeHS. All of our teams gather it all the time and we take it very seriously, including updates to the platform. I actually see my pal James in the chat, and he suggested a new academic integrity feature recently, and our engineering team was able to implement it earlier this month. We do listen to teachers; we want to create the curriculum and the tools that make your teaching better and easier, so please complete the survey.

Lastly, we will get you a certificate of completion for being here with us today. We appreciate that you've taken 90 minutes out of your summer to learn more and improve your practice for your students, and I just can't thank you enough for being such a dedicated group of educators. We've had a fantastic chat happening; I haven't been able to catch all of it, but it looked like there was some great collaboration happening. If you liked that collaboration piece, I invite you to join our PLC—our professional learning community—that we run throughout the year. We meet quarterly and discuss all things AP CSP, so be on the lookout for information on how to join those sessions from CodeHS.

Finally, I'll do a shameless plug for additional PD that we have happening this summer. We're going to do a preview of the brand new AP Cyber Security course that the College Board is launching this fall, showcasing the curriculum that our team has been working really hard on. If you are interested in learning some AI skills, come join us next week. Thank you all so much for joining. Chopen, it is always a pleasure. We talk gardening, vacations, and foster kittens before we hop on here, but I always learn so much from you and I can't thank you enough. Thank you to Steve, thank you to Regita, and we will call it a day here. Thank you. Bye y'all.