Reflecting on Teaching CT/CS to Grad Students

Sharing is caring!

I am in the midst of teaching a class on using technology in education with some really terrific and interesting graduate students.

Last night, we began our exploration of Computational Thinking and Computer Science. Most of the students reported themselves as novices in both areas, and so I planned to do an introduction using one of my favorite platforms, TurtleBlocks.

turtte blocks program to draw a square

TurtleBlocks in a successor to LOGO, one of the first coding tools designed for children. It allows users to create art by programming one or more turtles. Here is an example of a simple program that produces a square with a randomly generated color on each side.

computational thinking diagram

So, we started with an introduction to Jeannette Wing and the key concepts of Computational Thinking (CT). [Note: this last link connects to Wing’s original paper, which is very worth reading]

After this introduction to each of those four key concepts, decomposition, pattern recognition, algorithmic design, and abstraction, we started to play around with Turtle Blocks.

I have done this kind of introduction with students in grades 4 to graduate school, and usually do a quick intro to the tool (e.g., you “write” a program by clicking blocks together) then work on the first challenge, namely creating a square with the fewest numbers of bricks.

So, we start by thinking about (and ideally acting out) moving in the square with our bodies and what that would take. Then, we try to give the same instructions to the turtle. When we do that successfully, our program looks something like this:

drawing a square
Turtle Blocks program that draws a square

We can then play with choosing the colors for one or more sides, which adds a layer of abstraction: namely, that by default and invisibly, a pen is already down and a color is pre-selected (and matches the color of the turtle itself). So, adding colors of choice requires the set color block, like this:

Turtle Blocks program depicting color picker

And dealing with color introduces another abstraction, that our turtle understands colors as numbers. Working with this abstraction is aided by the presence of the color wheel which makes the connection between colors and their associated numbers. A simple program which sets a new color for each side of our square would look like this:

color square program
Turtle Blocks program that draws a square with a different color on each side

We added one more abstraction, which was to try to simplify the program. To do this, one has to recognize that our program to draw a square has a pattern – the forward 100 and right 90 blocks are the building blocks of a square. So asking the turtle to repeat them without our actually repeating the blocks themselves would simplify things, like this:

Turtle Block program drawing a square using a repeat block

The repeat block becomes the last level of abstraction in this sequence of exploration with Turtle Blocks.

This was the first time I had this type of lesson remotely and it was hard to simulate the experience of being able to look around physical classroom at the students’ computer screens to quickly assess and support what they are doing, encourage collaboration and sharing, and other facilitate their explorations. Via Zoom, I was able to ask these students to share their screen, which was helpful in being able to publicly troubleshoot and guide their work. However, I quickly noticed that individual work was public and I am not entirely sure this was the most effective method. I need to think on this.

I also left the class feeling that the students had done a great job diving in, but a little discouraged that some of them found the tasks as challenging as they did. To be clear, I was discouraged by myself and NOT them. I felt that I had blown the lesson in some way. This blog post is an attempt to reflect and understand and then to share my reflections and understandings.

Having written this, I can now see that I underestimated the degree to which much of these apparently simple activities, as well as the tool itself and its conventions, added much more layers of abstraction than I had anticipated, and that I did a less good job than I would have liked negotiating these very levels of abstraction and/or supporting them in negotiating these levels of abstraction for themselves. The biggest take away for me is working to be present to how much abstraction there is in a seemingly concrete task.

Hmm. I wonder if this is true for these students.