What do you do if there isn’t quite enough time in a CS lesson or a CS conference session? What “cuts” do you make and why? What do you focus on and/or highlight? What do you downplay and/or skip? Would your decisions be different if the activity was for new-to-CS learners or experienced CS learners?
This is a dilemma Toni and I have faced on a number of occasions. One approach that we have found particularly helpful for these situations is what we call “Cooking Show CS”.
Consider a cooking show for a minute… Time is not spent equally on each part of the cooking experience. Rather, some parts—the really important parts—are slowed down and discussed and modeled in great detail. Other parts—the not-so-important parts—are sped up considerably or even skipped entirely. Like, seriously, when does a cooking show include “real-time footage” of a recipe baking second-by-second in the oven?? We don’t need to see that—we get it. We often do need to see the preparation and the active cooking and the tips and tricks and the cooking “theory” being applied to this particular recipe. So that’s where a cooking show spends its time.
What would the CS equivalent of this be? What would it look like for a CS “recipe”/program/project to slow down and focus deeply on the preparation and the active computational thinking and the tips and tricks and the computer science theory…while speeding up or skipping entirely the parts that we don’t need to see or do in their entirety?
Here are two vignettes of how Toni and I have tried to used “Cooking Show CS” in 1 hour conference sessions.
Side Note: We don’t think that this pedagogy is always effective or that it is necessarily the best approach in all instances. Rather, we contend that there are times (i.e. short conference sessions) where it might meet a need—allowing participants to “develop” (or co-develop) a program in one hour that otherwise might take them much longer.
Guess My Number
In this particular session, new-to-CS learners were learning about introductory CS control structures, including sequential, branching, and iterative pathways. Participant pairs worked together to make sense of block-based pseudocode for this particular program, then we collectively translated this pseudocode into the text-based language of the TI-84+CE (by hand — more on that decision later). (Toni or I will share more about the block-based pseudocode we used for this activity in a later post.)
We ended up with the following program coded by hand on paper:
:Disp “GUESS IS TOO HIGH”
:Send(“SET SOUND 1046.5 TIME 0.5”)
:Disp “GUESS IS TOO LOW”
:Send(“SET SOUND 65.41 TIME 0.5”)
:Input “GUESS? “,G
:Send(“SET SOUND 65.41 TIME 0.5”)
:Send(“SET SOUND 1046.5 TIME 0.5”)
:Input “GUESS? ”,G
:Disp “YOU WIN!”
Getting to this point took time, as we carefully constructed, deconstructed, and discussed the various computer science principles at play in our program. How were we possibly going to have time to code this program into the calculators, as well?
Here’s where “Cooking Show CS” came into play.
Toni and I created a partially pre-made version of the program (called NUMGAME) and uploaded it onto all of the handhelds in the room. Instead of starting from scratch, participants opened up NUMGAME to find the first 9 lines of code already coded into the program—specifically, the lines highlighted below:
We helped participants navigate through entering the remaining lines of code into the “pre-prepped” program. Most participants finished coding these commands into their handhelds in time to test and run their programs, but a few did not.
We had considered this possibility, so we also preloaded a program called NUMGAME2 onto all of the handheld calculators. This program included all of the lines of code we (as a group) had collectively coded by hand.
This, to us, was akin to the moment in a cooking show where the chef puts a “raw” dish in the oven, but then a few minutes later pulls out a “finished” dish that had already been cooking for the full amount of time. Our choice here was purposeful: We wanted all participants to experience success with the program that they had helped write, even if they didn’t have time to “type in” each line of the code.
We included two additional “pre-cooked” programs for participants to consider, as well—NUMGAME3, which added in additional context for the user, visual (LED) outputs, and a celebratory tone when the user guessed the correct number; and, NUMGAME4, which abstracted the program so the user determined the upper bound on the range of possible numbers and also included a counter that tracked and displayed the number of guesses the user needed to guess the number. Participants were given a few minutes to run each of these programs and then predict what the changes in the code might look like in order to result in these “enhanced” versions of the program.
Respect the Beep
Toni has written here about the “Respect the Beep” session we have led where we use the TI-Innovator and the Ultrasonic Ranger to model a vehicle’s back-up sensor. I discussed this same program (but through a pedagogical lens) in this post about Introducing CS with Flowcharts.
When we led this activity in a conference session earlier this summer, we had a sequence of three programs we were planning to write as a collective group.
Here is the finished code that we wanted to arrive at for the first program:
Toni and I decided to create and provide participants with a pre-made file with the following parts of the program already “cooked”:
Including these commands allowed us to: save a few minutes of coding time in the conference session; and, focus primarily on the theory and syntax of sending and receiving commands from the Ranger, rather than just the digital connections.
Wrapping a While loop around the data collection part of this program doesn’t take a lot of extra time, so that’s something we had participants do themselves, as well, resulting in a program of:
P.S. Highlighting text using the Shift button and then inserting a While…EndWhile loop from the Menu will insert the While loop around the highlighted text. Here’s a little GIF showing this tip:
— Michelle Rinehart (@HowWeTeach) July 4, 2017
However, we did run out of time for participants to code in the final branching structures that were to be housed inside the While loop. Here was our end goal:
How might we have used another “Cooking Show CS” program here to help us meet our instructional goal in the short amount of time we had with these learners? Toni and I have considered using an “almost done” version of the file that looks like this:
where participants would fill in the output commands (represented above by the highlighted blank lines) within the various branches of the program.
What are your thoughts? How might using a “cooking show” approach for a CS lesson/activity/presentation allow us to focus more on our CS instructional goal and less on aspects that participants perhaps don’t need to see or do in their entirety?