Resources | Math Talks: Adapting the Number Talks Structure for Secondary Mathematics Classrooms

Recently I led a conference session at the TRC Annual Meeting exploring how the Number Talks structure can be adapted for secondary mathematics classrooms.

Here’s the description for this session:

How can effective Number Talk routines be adapted to meet the needs of secondary classrooms? Explore strategies and resources for implementing Math Talks in Gr. 6-Algebra. See how Math Talks can provide opportunities for students to communicate and justify mathematical ideas, reasoning, and arguments within a concise, organized classroom structure.

Here are the mathematical goals for this particular session:

Look familiar? These are excerpts from two of our Mathematical Process Standards here in Texas (the Texas equivalent of the CCSS’ Standards for Mathematical Practice (SMPs)).

Our pedagogical and instructional objectives for this session included:

Here is the participant handout from this session and here is the card sort with samples of secondary Math Talks.

I’ll unpack this conference session further in future blog posts. Just sharing the resources to start the conversation…!


Interested in joining this conversation live? Come join in this session live at CAMT 2017 in Fort Worth, TX or NCTM Regionals 2017 in Orlando, FL!

Math Talk: ¼ of a Square (Part 2)

How might we use a Math Talk to help students connect fractions and a host of two-dimensional geometry concepts? How might this same Math Talk take learners into “a broad mathematical terrain of interconnected concepts, procedures, representations, and explanations”? (Kazemi & Hintz, 2014) How might a Why? Let’s Justify discussion routine overlaid on an extension Math Talk help deepen our understanding of why a particular geometric sketch is accurate? Let’s explore these ideas further…!

[Part 1 of this blog post discussed the original Math Talk and an Open Strategy Share discussion structure.]

Here is a “spin-off” Math Talk that emerged from the Open Strategy Share discussed in Part 1.

The group was presented with this sketch from one of their peers and asked to consider whether this image represented ¼ shaded. Note that the learner used a dot to mark the intended midpoint of the bottom of the square.

Triangle 1

Does the image above represent ¼ of the square shaded? How do you know?

We discussed this representation in pairs and small groups, then we shared some of our thinking whole group. For this particular Math Talk, we were using a Why? Let’s Justify discussion structure. Instead of trying to generate multiple solution pathways, we were considering one particular (potential) solution and working on justifying why this was or was not a solution.

Kazemi & Hintz (2014) summarize the goal of this structure as “to generate justifications for why a particular mathematical strategy works” (p. 3). Kazemi & Hintz continue: “During a Why? Let’s Justify discussion, the talk narrows upon a general claim in order to closely examine the mathematics and generate a discussion for it.” (p. 74).

The following justifications emerged from the group:

B suggested that the shaded triangle did represent ¼ of the square, since the base was half of the square’s side length and the height of the triangle was equal to the side of the square.

This verbal description resonated with some learners in the group, but others were unconvinced.

S suggested that so long as the bottom vertices of the triangle remain unchanged the top vertex of the triangle could actually lie anywhere along the top side of the square — and the triangle would always have ¼ of the area of the square. We sketched out some examples of S’s idea:

Triangle 2

S contended that all three of the triangles shown above represent ¼ of the square shaded in. The group agreed that the yellow triangle (a right triangle with its top vertex at the midpoint of the upper side of the square) definitely represented ¼ of the square, but some learners remained unconvinced about the other two examples.

A suggested that we draw in an altitude for each of the triangles we had sketched as a group. Our diagrams now looked like this:

Triangle 3

Adding in this additional structure (the altitudes) revealed something that wasn’t yet visible for all learners — namely, S’s contention that all three triangles had the same base and height, so must have the same area.

[Side note: This is a great example of what Jill Gough and Jennifer Wilson describe as “adding in an auxiliary line…to make what isn’t pictured visible” from their learning progression for SMP 7: I can look for and make use of structure. Check out their fabulous and thoughtful work on their blogs linked above.]

Consider how this Math Talk feels different than the Open Strategy Share version shared in Part 1 of this post. The Why? Let’s Justify discussion structure took us into another part of the mathematics — not merely considering a wealth of different approaches, but deeply considering one approach and focusing on creating convincing explanations to justify the mathematics used in that strategy.

In discussing the Why? Let’s Justify structure, Kazemi & Hintz (2014) contend: “Certain types of mathematical ideas lend themselves to a discussion that generates a justification for that idea” (p. 74). Not every problem or prompt is innately geared towards this particular discussion structure.

So what made this particular mathematical idea (specifically that the green triangle shown above does or does not represent ¼ of the square) a good fit for a Why? Let’s Justify discussion structure?

First, this particular representation did not look like ¼ of the square at first glance. A deeper analysis of the shape was required in order to determine whether or not it represented ¼ of the square–and deeper still to justify why.

Second, during the Open Strategy Share for the preceding Math Talk, most of the group’s sketches of ¼-shaded involved only congruent shapes. The approach used in this Why? Let’s Justify discussion did not subdivide the square into congruent shapes/pieces. Learners would have to rely on different reasoning (beyond subdividing a shape into congruent pieces and shading ¼ of the congruent pieces) to justify whether or not this specific triangle represented ¼ of the square.

Third, this particular triangle exposed that we (as learners) lose some of our intuition about triangles when they are obtuse triangles. We don’t often “see” the altitude of an obtuse triangle in the way that we see (and reason with) the heights of acute and right triangles. This drawing exposed some of that loss of intuition and made us dig deeper into why something was true.

For these three reasons (and perhaps others?), this prompt providing a meaningful task for learners to engage in a Why? Let’s Justify discussion routine.

Side Note: Kazemi & Hintz (2014) challenge that “During the discussion, we need to listen for procedural descriptions that students might give and be sure not to have the conversation stop there. When we press beyond procedural explanations into explanations that include reasoning, we are supporting students in justifying their ideas” (p. 56).

This paragraph still convicts me. Did I press far enough in the justification discussion outlined above? Why does any triangle with a base half the width of the square and a height of the square have an area of ¼ of the square? Maybe I should have pushed our thinking a little bit further here…

How does the Why? Let’s Justify discussion structure compare to the Open Strategy Share structure? In what ways does it open up a different part of the mathematics? What additional considerations might a teacher attend to when planning a Math Talk like this?

(See Elham Kazemi & Allison Hintz’s book Intentional Talk: How to Structure and Lead Productive Mathematical Discussions for more information on the Open Strategy Share and Why? Let’s Justify discussion structures.)

Math Talk | ¼ of a Square (Part 1)

How might we use a Math Talk to help students connect fractions and a host of two-dimensional geometry concepts? How might this same Math Talk take learners into “a broad mathematical terrain of interconnected concepts, procedures, representations, and explanations”? (Kazemi & Hintz, 2014) How might an Open Strategy Share discussion structure overlaid on this Math Talk help students see a range of possibilities within this interconnected landscape? Let’s explore these ideas further…!

Consider the following Math Talk:

Take a few minutes (say, time yourself for 3 minutes) and sketch squares where ¼ of each square is shaded in a different way. One ground rule first… Let’s say that the following two depictions represent the same “way” to shade ¼ of a square. Instead of sketching different iterations of the same “type” of ¼…can you shade ¼ in a different way? How many different ways? Set your timer and see where your brain takes you…!

Where did your brain take you? How many different ways of shading ¼ of a square did you generate?

After working on this task individually for 2-3 minutes, learners share their thinking with their tablemates. In so doing, they consider and discuss Did we all approach this task the same way? and What additional approaches did my peers use? and What additional ideas do we now have as a group because of discussing each other’s work?

We have led this Math Talk with multiple groups of adult learners. Here is a sample of the collective work that has come out of this individual think time followed by small group discussion time:

What would you do with this work? What is the benefit of orchestrating an Open Strategy Share Math Talk over some of these examples?

Kazemi & Hintz (2014) suggest:

“Open strategy sharing is typically the first way to get mathematical discussions going in classrooms. It’s like having a good, basic recipe for a soup from which you can make all kinds of variations. Open strategy sharing allows you to nurture the norms needed for a productive math-talk community. And you can use this discussion structure to model how students should talk with one another.” (p. 17)

I particularly like how the Open Strategy Share discussion structure provides an initial access point for teachers looking to introduce or enhance math talk in their classrooms. Also, as Kazemi & Hintz discuss, these structures provide wonderful opportunities for students to learn how to talk about mathematics.

But, if this is the “basic recipe for soup,” what would your variation be? What would you choose to highlight or spin off from for a follow-up Math Talk at some later time? Where else instructionally might this Math Talk go?

Check out Part 2 of this blog post to see a sample follow-up Math Talk that utilizes the Why? Let’s Justify discussion structure.

(See Elham Kazemi & Allison Hintz’s book Intentional Talk: How to Structure and Lead Productive Mathematical Discussions for more information on the Open Strategy Share discussion structure.)

“Cooking Show” CS Lessons / Presentations

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:

:Wait 0.5
:Send(“SET SOUND 1046.5 TIME 0.5”)
:Wait 0.6
:Wait 0.5
:Send(“SET SOUND 65.41 TIME 0.5”)
:Wait 0.6
:Input “GUESS? “,G
:While N≠G
:If G<N
:Send(“SET SOUND 65.41 TIME 0.5”)
:Wait 0.6
:Send(“SET SOUND 1046.5 TIME 0.5”)
:Wait 0.6
: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:


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?

Math Talk: Solving Equations Visually

How might we use a Math Talk to help students sense-make about solving equations? How might this same Math Talk help students work on showing what they know and making their thinking visible? How might a Compare & Connect discussion routine overlaid on this Math Talk help deepen our understanding of strategies for solving equations? Let’s explore these ideas further…!

Here is one of my favourite Math Talks:

(Note: The idea for this particular Math Talk came from a session I attended at NCSM 2016 led by Crystal Lancour & Jennifer Trievel of Delaware. Thanks, y’all!)

Take a minute and think about how you would respond to this prompt. Can you solve this problem without first “translating” it into algebraic notation and solving via algebraic manipulation? Rather, can you solve this problem visually?

Also, can you (as Jill Gough and Jennifer Wilson encourage us to do) “show your work so that a reader understands without having to ask [you] a question”? (See more on Jill & Jennifer’s #ShowYourWork progressions here.)

How might we make our thinking visible for how we solved this problem?

Here is how S, a recent conference session participant, made her thinking visible:

Elephants 1 Final

She explained her thinking aloud as:

I removed 4 horses from each side. Then I was left with the fact that 2 elephants were as strong as 8 horses. I divided these 8 horses into two equal groups showing me that each elephant is as strong as 4 horses.

When asked “Did anyone else solve the problem this way?” the majority of the participants indicated that they solved this problem the same way as S had.

L, however, had a different approach. Here is how she made her thinking visible:

Elephants 2 Final.png

Can you understand what L did without asking her any questions? How is her approach similar to and different from S’s approach?

L explained her thinking to the group in this way:

I started by dividing the problem in half. I knew that if 2 elephants and 4 horses were as strong as 12 horses, then 1 elephant and 2 horses must be as strong as 6 horses. Knowing that 1 elephant and 2 horses were as strong as 6 horses, I removed 2 horses from both sides of this situation, leaving me with the fact that 1 elephant is as strong as 4 horses.

How did L look for and make use of structure? And, does her method work all the time?

We quickly considered what the corresponding algebraic manipulation might have looked like for S and L’s approaches. We decided to represent the strength of an elephant with the variable e and the strength of a horse with the numerical value of 1. Here is what we came up with for the corresponding algebraic methods for these two visual solution pathways:

S’s Method

Elephants 1 with Algebra Final.png

L’s Method

Elephants 2 with Algebra Final.png

Do both of these methods work every time? When might S’s method be advantageous? When might L’s method be advantageous?

Why might it be important for students to Compare & Connect these two methods in a Math Talk? (See Elham Kazemi & Allison Hintz’s book Intentional Talk: How to Structure and Lead Productive Mathematical Discussions for more information on the Compare & Connect discussion structure.)

Also consider:

How does L’s method push back on well-intentioned but over-structured “procedures” we might teach our students for solving equations?

More on this idea in an upcoming blog post on Sense-Making for Solving Equations.

Abstracting SET COLOR — and Connecting to Prior Learning

Have you ever had one of those learning experiences where you thought you knew something going in (and knew it pretty well)…but then someone looked at a problem/task/question in a different way…and their approach broadened and deepened your understanding of what you thought you “knew”…? Those are some of my favourite learning experiences! Where I add connections and understanding to my knowledge by learning from others who think differently and/or who approached a task in a different way.

Here’s an example of just such a learning experience where a fellow educator recently deepened and broadened my understanding of the SET COLOR command on the TI-Innovator.

First, some background. Earlier this month, during a Teaching Computer Science with TI-Nspire workshop, we spent lots of time exploring different data types (including strings, floats, ints, etc.) and working with input and output commands related to these data types.

We learned how to Display output to the program’s user, including output made of different data types such as in the hypotenuse program shown below:

Running the hypotenuse program with actual parameters of 3 and 4 yields:

We informally called this use of the comma (,) in the Disp command concatenation, but then we were challenged to think more deeply about our use of this term later on. For now, we realized that the Disp command had syntax of:

Disp __, __, __, …

where any given blank could contain a string (in quotes) or a variable (string variable or numeric variable).

We later realized that the comma wasn’t our only (or even best?) way to concatenate, as we discovered when we ran into a program like this:

In this case, with the Request statement, we couldn’t use the comma to “concatenate” as we had done before with the Disp statement. We realized that this was due to the syntax of the Request statement, which looks something like this:

Request “[message to user]”,variable_to_store_response

The comma wouldn’t work to “concatenate”/connect output together here, since the Request statement was only expecting one comma in its syntax. (Side note: Request can actually receive a second comma followed by a 0 to suppress the user input, but that’s another story…! :))

Instead, we used the ampersand (&) to concatenate within the Request statement shown above.

From there, we wondered whether the comma (,) really had been concatenating for us earlier. We set off to investigate this further.

What do you think the output of this program would be?

Notice how the numeric variable age displays without a problem when using the comma (,) to separate Disp elements, but must be converted into a string (using the string() command) in order to be displayed using the ampersand (&) for concatenation. We had many interesting discussions about these details…!

Here is the output from running this program:

Notice anything interesting…?

We noticed some spacing issues. Namely, that the Disp __,__,__ approach inserted a space between each __ element, while the Disp [string]&[string]&[string] approach did not insert spaces between the various strings (as is true of typical concatenation).

Interesting… We were stretching our thinking and making connections about data types, output formatting, and concatenation methods.

Then, came this activity late in the second day…

We were learning how to code output to the RGB LED that is built into the TI-Innovator. We quickly learned that the syntax for sending colours to the RGB LED is:

Send “SET COLOR # # #”

where each of the three #’s is an integer from 0 to 255. We explored the effects of changing these numbers in order to determine what each of the three numbers controlled and how it controlled it.

Here is a screenshot of a program that turns on the red LED within the RGB LED at full intensity:

However, we had a problem. Our program, as currently written, wasn’t all that helpful. Specifically, our program coded only one particular colour — and if we wanted to display another colour, we had to go into the code for the program and make changes there. This wasn’t very user-friendly!

We decided to abstract our program so that the user could display whatever colour they wanted by entering three values for the red, green, and blue intensities.

For the sake of expediency in coding (at the sake of user-friendliness for users who didn’t write the program), we decided to pass these values into the program as formal parameters (i.e. via colour(r,g,b)). We updated our three colour intensity values in the Send “SET COLOR…” line with the variables that represented these colour intensities (r, g, and b)…and quickly figured out that our program didn’t work. Hmmm…

We had a great discussion about what was going on and going wrong here… Specifically, we were sending a string to the Innovator to be translated into visual output. The r, g, and b variables were being read as r, g, and b characters within the string — rather than reading the values these variables actually represented!

No worries, as I knew where this was going. (This is that “knew” thing I was talking about earlier…) I swooped in and saved the day by introducing the eval() command, which evaluates the value of the variable and pastes that into the Innovator string output/send command, instead. Our code now looked like this and worked as intended:

But then…the magic. Someone looked at this problem differently…

T, one of the participants in the room, piped up with “I found another way to do it…! An even more efficient way!” We pulled T’s screen up on the Navigator system and considered his code:

Discussion abounded.

“Wait — doesn’t Send “SET COLOR…” need three values in it?”

“Oh, he’s concatenating with the commas!”

“Don’t we need spaces between the numbers?”

“Could you use ampersands instead?”

“This is like how we used the Disp statement!”

“Wait — does that work?!”

I was surprised by T’s discovery (I had never seen this approach before!) and delighted (of course that works! How fun!). It was a wonderful moment of learning that cemented many ideas we had considered over the course of two days — and provided us with additional flexibility for coding a new command we were just learning to use.

What are your thoughts?

What might the value be in using syntax of Send “SET COLOR eval(r) eval(g) eval(b)” for a program like this?

What might the value be in using syntax of Send “SET COLOR ”,r,g,b ?

What does each method add to our coding arsenal and/or to our understanding of CS topics?

And…is there another way?

Introducing CS with Flowcharts

Toni and I have spent a lot of time over the past year thinking about pedagogical approaches that are effective for introducing CS topics to learners who are new to CS. Also, we’ve thought a lot about how to do this within relatively short learning episodes, such as a 60-minute conference presentation.

Our goal for the end of a 60-minute conference presentation is usually to have participants code out (on a calculator and also (usually) by hand) a rather complicated program — but, more importantly, to have made sense of said program.

In a recent conference session, our goal was for participants to code a program that modeled a back-up sensor on a car, complete with audio feedback based on how far the “car” was away from an object. This particular program (see Toni’s post here for more information) included sequential, branching, and iterative elements, as well as commands related to connecting to, collecting data from, and disconnecting from an actuator (or peripheral device). These are a lot of different elements for someone who is new to CS to integrate!

How might we design learning experiences to support sense-making around these varied commands/structures…in a way that is accessible for new-to-CS learners?

One approach that we have found particularly effective for this work is using flowcharts — specifically, using flowcharts that develop over time. Rather than just jumping right into this rather complicated flowchart (again, complicated for a new-to-CS learner!):

we instead provided the following blank flowchart and had participant pairs brainstorm what commands might need to go into this flowchart (and in what order) in order to read and display a distance measurement from an Ultrasonic Ranger attached to the Innovator.

Note that the task of collecting and displaying a distance measurement is not our end goal, which is to model a back-up sensor — but we deliberately wanted to decompose this program/situation into simpler situations first. In this case, before we model a full-on sensor, how might we code the Innovator just to collect and display a data measurement?

A quick debrief of ideas from the whole group (plus some information from us on what these commands look like for the Innovator) led to this filled-in flowchart:

With a completed flowchart, we quickly “translated” the pseudocode in this flowchart into the programming language of the TI-Nspire and TI-Innovator. Participants checked that their programs collected and displayed a valid distance measurement as intended.

Next, we asked participants to consider, What if we wanted to collect data measurements repeatedly, instead of just once? We provided the following blank flowchart and had participant pairs consider what commands might go in each element of the flowchart.

Participants talked through lots of important ideas here, including: What should go in the “decision diamond”? What commands should happen “outside” of the loop structure? What commands should happen again and again (i.e. inside the loop structure)?

Debriefing these ideas whole-group led to the following completed flowchart:

We quickly coded these additional commands/structures into the program we had started earlier and tested our new programs.

Now, our program collected distance measurements again and again until the distance was less than 0.01 meters. For the sake of our model, we said that this value represented the back-up sensor turning off after a collision — whoops! 🙂

However, our sensor wasn’t giving us very helpful feedback! It was displaying the distances, but who would be reading that display while backing up?! We wanted to add in audio feedback (beeps!) that alerted us if we were nearing an obstacle. Specifically, we wanted there to be two “levels” of audio feedback — warning beeps if we were nearing an object, but then a more urgent set of warning beeps when we got really close to an object.

We provided the following flowchart for participant pairs to discuss:

which led to a final debrief and this filled-in flowchart:

Here we were, finally, at our programmatic goal! We had collectively developed a program (in flowchart form and in coded form in our calculators) that modelled a back-up sensor.

Yes, it took a while to get there, but the time spent sense-making about the earlier situations and flowcharts helped participants develop and use appropriate CS structures and logic while creating this more complex program. We were thrilled with the engagement, discussions, and explanations from our participants, many of whom were new-to-CS learners!

Side Note: When leading this conference session, we ran out of time during the calculator coding of the final part of the program. 😦 We have discussed some time solutions for this for future presentations of this conference session including having participants code the first program on the calculator, but providing “almost complete” versions of parts 2 and 3 already on the calculator. This will cut time out of the session without losing any of the time that focuses on sense-making about the code.

To create these flowcharts we used the LucidCharts Diagrams Chrome extension, which allowed us to create and store these flowcharts in GoogleDrive.

Here’s a copy of our handout from the conference session; we wanted participants to leave with copies of the completed flowcharts so that they could later replicate this work on their own devices.

How else have you used flowcharts to introduce CS topics to new-to-CS learners? What other pedagogical or instructional approaches have been effective for making CS accessible to all?

Michelle Signature