Show What You Know: Reviewing and Applying Knowledge with Debugging Activities

Toni and I led a number of 4-day Teaching Computer Science with TI-Nspire Technology workshops across the state of Texas this summer. Many of the sites offered days 1 and 2 consecutively, followed by days 3 and 4 at a later date. Sometimes day 3 of the PD happened months after day 2. In these instances, how might we structure an activity that helps participant review key computer science ideas from previous learning episodes, while also applying these ideas in new situations? One strategy that we found particularly helpful in this situation was a set of debugging activities.

Side note #1: The first two days of learning delved into most of the topics from the first four units of the 10 Minutes of Code activities, including user input (via parameters or Request statements), output (Disp, Text), variables, data types, conditionals (If, If…Else), and loops (For, While, and DoWhile). Additionally, we applied many of these same concepts to tasks with the Innovator through the first two units of the 10 Minutes of Code for the TI-Innovator Hub activities.

Side note #2: Our use of debugging activities was inspired by the work of Amin Lalani & Georgia Stuart at UT Dallas.

We started Day 3 with a Debugging Problems TNS file. The file was composed of 10 Problems. Each Problem contains a Program Editor page, like this one:

with a corresponding Calculator page, like this one, on which to run/execute the program:

Each program (named debug_1, debug_2, etc.) contained at least one error. Participants worked in pairs to debug/fix each program. In so doing, participants reviewed, applied, and discussed:

  • How to compile a program in the Program Editor (using Check Syntax & Store)
  • How to run/execute a program in a Calculator page (including the use of the var button to summon program names)
  • Syntax for the TI-Nspire programming language
  • Variable naming conventions
  • Data type considerations (including concatenation)
  • Control structures, including conditional statements and loops
  • Logic and conditional statements
  • User input mechanisms (including parameters and Request statements)
  • Error types (including compilation errors & execution errors) and error messages
  • …and more!

Some of the programs involved minor errors. For example, the debug_1 program shown above—participants determined that the string in the Disp statement should have been in double quotes (“) and not single quotes (‘). Here’s a quick GIF of troubleshooting this program:

Debug_1

Here are two other programs from the TNS file. What errors do you see? How might we debug these programs? What important CS topics connect to these errors and/or fixes?

It was incredibly valuable for participants to troubleshoot and debug these programs dynamically on the handheld calculators. They could fix errors as they found them and then compile and execute the edited program right away to test their “fixes”. On numerous occasions participants fixed one or more parts of the program, but then discovered another error when they ran the edited program.

Our brains often “fix the code for us,” helping us read the intention of the code, but perhaps missing some of the subtle errors specific to the coding language. This activity helped us review and apply programming skills specific to the TI-Nspire language, while also discussing larger computer science topics and content applicable across languages.

Additionally, we experienced the cognitive difference between writing a program from scratch and debugging an already written program. It feels different to debug–to find and correct errors in already written code–than to “code from scratch”; there was important learning to be had in this space.

Give it a try yourself! Here’s a copy of the TNS file with all 10 debugging programs in it. Each program does not necessarily have a unique solution—there may well be more than one way to “fix” the program so that it runs as intended, but with different code structures under the hood.

Also, Toni and I wonder…what would similar debugging programs look like that included TI-Innovator commands/components? What sort of errors would be helpful for learners to confront, discuss, and debug in regards to Innovator programs?

Here are some rough draft ideas for possible Innovator debug programs:

What other programs and/or lines of code might be valuable to include in a set of TI-Innovator debugging problems?

What other value do these debugging activities bring to the learning experience?

Foldables in Computer Science: Consolidating Our Learning

How might we help learners synthesize important computer science topics (including vocabulary, structures, and techniques) using Foldables? How might these three-dimensional graphic organizers help learners consolidate their learning, while also providing effective notes for later reference?

In designing learning experiences for new-to-CS educators, Toni and I considered how Foldables might dovetail nicely with the 10 Minutes of Code activities provided by Texas Instruments. The 10 Minutes of Code activities do a phenomenal job of crafting short learning episodes that provide students with bite-sized instructional episodes (see the Skill Builders) followed by opportunities to apply their new learning (see the Applications).

Toni and I wanted to build on these 10 Minutes of Code activities by layering additional content connections that deliberately drew out and discussed some of the computer science topics that are operating within the 10 Minutes of Code activities. Specifically, we were working to develop Foldables that formalized CS topics that were important for a beginning teacher of CS to know (as defined by the TExES Computer Science 8-12 certification requirements in Texas).

Our Foldable work is inspired by the top-notch work of Dinah Zike and her crew from Comfort, Texas. If you are new to the world of Foldables, be sure to check out Dinah’s site. Dinah has a ton of resources that support Foldable use and creation in all grade levels and subject areas. Here are some of my favourites: Notebook Foldables, Big Book of Math for MS and HS, and her Notebooking Central resources for Math.

Toni and I wondered: What would Foldables look like in computer science? This led us on a fun journey…! Here are some of the highlights.

Here is a Three-Tab Foldable that overviews introductory Program Protocols, including how to Create (using the Program Editor), Compile (using the Check Syntax & Store command), and Run (using a Calculator page) a program on the TI-Nspire handheld. These ideas connect to the work done in the Unit 1: Program Basics—Skill Builder 1: Introducing the Program Editor 10 Minutes of Code activity.

 

 

Here’s another example of a Foldable that uses a screenshot of a program and its output for a given set of actual parameters. This Shutterfold Foldable (with an inlaid screenshot) was used to annotate some details about Formal and Actual Parameters after we wrote our first program that used parameters (in the Unit 1: Program Basics—Skill Builder 2: Arguments & Expressions 10 Minutes of Code activity).

 

 

Here’s one of my favourites: a Matchbook Foldable that outlines how a For Loop operates. We used this Foldable to identify the four parts of a For loop, as well to practice tracing out a loop using a table. Notice the inclusion and annotation of a screenshot of the program. This Foldable formalized ideas from the Unit 4: Loops—Skill Builder 1: For Loops 10 Minutes of Code activity.

 

Here’s an awesome tweet from a learner in one of Toni’s workshops and his work with this exact Foldable! Love it!

We created similar Matchbook Foldables for While Loops and Do While Loops, but then also created this Three-Tab Foldable to compare and contrast the three types of loops (For, While, and Do While). This Foldable helped learners step back and consider the important similarities and differences across the three loop types that were studied throughout the Unit 4: Loops 10 Minutes of Code activities.

Here’s an example of using a Shutterfold Foldable to document and analyze two Computer Science techniques (specifically, using Counters and Accumulators). This builds on the ideas used in the Unit 4: Loops—Application: Bank Notices 10 Minutes of Code activity. Consider how a Foldable like this serves as a way to consolidate new information, but also as a helpful resource for later reference and use.

 

We have received really positive feedback about how these Foldables helped learners step back from the coding experiences and synthesize the ideas they were learning about and experimenting with in a meaningful way. The Foldables helped to organize and chunk the main ideas and were also really handy for revisiting ideas throughout the learning episodes.

The examples above are a sampling of the Foldables that Toni and I have created for formalizing CS topics. We love doing this work!

What other topics from computer science might be a good fit for Foldables? What other strategies might be effective for creating powerful Foldables for CS topics? How might Foldables dovetail into work with the TI-Innovator Hub and those 10 Minutes of Code activities?