Robot Turtles: a formal introduction for educators

With standards alignment and recommendations for the classroom

Fast facts

Number of players: listed as 2–5, but can be played by 1 player or a large group

Recommended ages: 5–11 years old (K-6th grade)

URL: https://www.thinkfun.com/robot-turtles

Genre: puzzle board game

$25

Curricular connections: computer science

Skills the game aims to teach: algorithmic thinking, debugging, problem analysis and decomposition, testing, fault isolation, functions and abstraction

Standards alignment

Common Core State Standards for ELA/Literacy (2010):

• Science and Technical Subjects:
• RST.6–8.3 (precisely follow multi-step procedure)
• RST.6–8.7 (integration between verbal and visual solution)

Common Core State Standards for Mathematics (2010):

• Mathematical Practices (Grades K-8):
• MP1 (make sense of problems, persevere in solving them)
• MP2 (reason abstractly and quantitatively)
• MP3 (construct arguments, critique reasoning)
• MP6 (attend to precision)
• MP7 (make use of structure)

Next Generation Science Standards (2013):

• Engineering Design:
• 3–5-ETS1–1, MS-ETS1–1 (defining design problems)
• 3–5-ETS1–2, MS-ETS1–2 (generating/evaluating solutions per problem constraints)
• 3–5-ETS1–3, MS-ETS1–3 (testing solutions to identify improvements, combinations)

Type of game: tabletop

Appropriate audiences: The game is listed for ages 6–10, but can be used as low as Kindergarten with appropriate support, and can be relevant up to 9th grade, especially with focus on functions

Length of time needed: setup and cleanup: 5 minutes each; gameplay: 15–45 minutes (depending on number of puzzles, complexity)

Places to play: large table or floor

Gameplay

Robot Turtles has players create simple sequential “programs” to get their turtle to its goal.

Colorful cardboard tokens represent the turtles, and various obstacles. To begin, an experienced player or adult places obstacle tokens, a gem token, and a turtle token around the board’s grid. This player will act as the “computer”.

Now the “programmer” players create their programs. Using playing cards displaying several different instructions — ”go straight”, “turn left”, “turn right”, “shoot laser” — players assemble a sequence of cards. When they’re ready, the “computer” player carries out the sequence, step by step.

When something goes wrong — and it almost always does — it’s a bug! The “computer” player returns the turtle to its starting position, the programmer adjusts the program, and the “computer” carries out the revised sequence. Players are encouraged to understand that this “debugging” is a normal, expected part of programming. Programs aren’t supposed to start out perfect; the fun is in finding problems and fixing them!

As players move from simple, 3-card programs to long and complex ones, the teacher can introduce an additional card: the “frog function” card. A function is a core computer science concept: it is a set of steps that can be run at any time by other parts of the program.

Suppose you had a set of steps for tying a shoe; you could call this your “tie shoe” function. Then you could write a “put on shoes” program that “calls” your “tie shoe” function once for your left shoe, and then calls it again for your right shoe.

Similarly, students can create a second set of cards — their “frog function” — and then trigger that entire sequence whenever a “frog function” card appears in their main program.

How the game is used

Robot Turtles is an excellent early way to introduce students to computational thinking. Teachers find that students approach it eagerly as a game, and then are surprised to find their initial sequences don’t always result in the behavior they expect.

By overcoming the challenge of revising their program to reflect the behavior they observe when running it, students learn several core computational concepts firsthand: the precision with which computers carry out instructions; the cycle of testing and debugging; the framing of mistakes as a natural part of the process, rather than a “wrong” answer; and the distinction in computer architecture between code and the agent who runs the code.

Robot Turtles is flexible in that puzzles can be simple enough for kindergarteners (”go straight, go straight, go straight”) or complex enough for middle schoolers or even high schoolers. For students who master long sequences, introducing the “frog function” cards opens up much greater complexity, and teaches students the use of functions, a core computational concept. These cards can even be used to demonstrate recursion, a topic of computer science generally encountered at the high school or college level.

Teachers might progress as follows:

• Start with only a few types of tokens: turtles, walls, and gems. This keeps the initial game simple, so students can focus on understanding the game mechanics and the debugging process. Reserve the laser blast and function frog cards for later.
• Next, introduce ice walls (which can be melted into puddles with a laser blast, and then walked over)
• Then, introduce boxes, which can be pushed by turtles. These can create complex puzzles.
• Finally, introduce the function frog. A great way to do this:
• create a puzzle that requires several repetitions of the same sequence (e.g., “straight, right, straight, left”)
• then tell students they are limited to only using some number of cards (e.g., ten). When they conclude this is impossible, show that it can be done by placing the repeating steps in a “function”, and “calling” it using the function frog card.

Notes

A weakness of Robot Turtles is that it does not come with pre-existing puzzles. Teachers must create their own, or use a small library of examples that the publisher has provided on their website.

Creating puzzles is not difficult, but it does require that teachers get familiar with the game before introducing it to students, so they have a sense of the level of complexity their initial puzzles should have.

Teachers of older and more experienced students may wish to spend some time designing and recording puzzles that require repeating sets of steps, in order to make them appropriate for using “function frog” cards.

Tips

• The board isn’t necessary to write and run programs. Have the programs move people instead! Use linoleum squares, carpet squares, or masking tape on the floor as your grid. Students can move their teacher around the floor, or taking turns moving each other. (Robot voices are optional!)
• Early on, students will have trouble understanding why the left turn and right turn cards don’t always produce the behavior they expect. This is a great opportunity to talk about how programmers need to think from the robot/computer’s point of view. Encourage them to stand up, face the way the robot turtle is facing, and try turning to their left or right.
• The game can be “modded” with new tokens and new cards. What about a button that opens a door remotely? Battery packs required to fuel the lasers?

Further Resources

The Robot Turtles website includes:

• “Adventure Quests”, sample puzzles created by students (www.thinkfun.com/robot-turtles/library.php)
• List of computer science concepts that Robot Turtles teaches (www.thinkfun.com/robot-turtles/coding.php)

Related games or activities

Online coding platforms with step-by-step movement commands:

• Code.org (www.code.org): Simple, step-by-step coding lessons, themed with commercially popular and recognizable characters
• Scratch (www.scratch.org): coding platform that grew out of Logo and is widely flexible and powerful
• CodeHS (www.codehs.com): step-by-step coding lessons to move “Karel the dog” across the screen
• PencilCode (www.pencilcode.net): Simple coding platform where you navigate a turtle-like triangle across the screen

Apps:

• Scratch Jr. (iOS, Android): a simpler version of Scratch for tablets, intended for younger children
• Hopscotch (iOS): similar to Scratch Jr., with a library of existing creations and art

Related research

Papert, Seymour. (1980) Mindstorms: Children, Computers, and Powerful Ideas. New York: Basic Books.

Solomon, Cynthia. (1975). Leading a Child to a Computer Culture. ACM SIGCSE Bulletin, Volume 8 (Issue 1), February 1976, pp. 79–83.

Solomon, Cynthia. (1978). Teaching young children to program in a LOGO turtle computer culture. ACM SIGCUE Outlook, Volume 12 (Issue 3), July 1978, pp. 20–29