Blue-Bots are fantastic tools for teaching young children about basic programming concepts. They are colourful, child-friendly robots that are specifically designed for use by younger learners.
Here’s an overview of the Blue-Bot’s features and functionalities:
- Simple Control Buttons: Blue-Bots have seven buttons on top: Forward, Backward, Turn Left, Turn Right, Go, Clear, and Pause. These controls are designed to be as straightforward and intuitive as possible, making them accessible to young children.
- Step-by-step Programming: Blue-Bots follow instructions in sequences, which children can program in steps. The robot moves one ‘step’ per command, with each step being about 15cm, equivalent to the Blue-Bot’s length.
- Memory Function: Blue-Bots can remember up to 200 commands, allowing children to experiment with longer sequences of instructions.
- Sound and Light Indicators: Blue-Bots make sounds and flashlights to confirm each action. This provides immediate feedback to children about what the Blue-Bot is doing.
- Robust Design: Blue-Bots are built to withstand the rigours of a classroom environment. They are designed to be resilient to dropping and rough handling, ensuring they can survive the enthusiastic use of younger children.
In the classroom, Blue-Bots can be used in a variety of ways to teach basic coding and computational thinking concepts:
Teaching Sequence and Algorithm Development
The most basic computational concept taught by Blue-Bots is the sequence or algorithm. Children can create their own basic algorithms by programming the Blue-Bot to move forward, turn, and move again. This helps children understand that computers follow instructions in sequence and that the order of instructions matters.
Debugging and Problem-Solving
When a Blue-Bot doesn’t end up where a learner intended, they are encouraged to figure out what went wrong. This is a basic introduction to debugging. Learners have to look at their sequence of commands, figure out where the error is, and correct it.
Logical and Computational Thinking
Blue-Bots can also be used to teach more advanced concepts like loops and conditionals, foundational pillars of computational thinking. For example, learners might be tasked with getting the Blue-Bot from one point to another in the least number of moves possible, requiring them to think logically and strategically.
Interdisciplinary Learning
You can also use Blue-Bots to integrate coding with other subjects. For example, you could use Blue-Bots in a geography lesson by creating a map with landmarks that learners must navigate the Blue-Bot around. Or you could integrate them into a language arts lesson by having learners tell a story using the Blue-Bot’s movements.
Blue-Bot Maps
Blue-Bot sells various floor-matts that can be used in the class. However it is quick and easy to create your own by drawing a series of 15cm x 15cm squares on the floor or a large piece of cardboard.
Blue-Bots provide an interactive and engaging way to introduce younger learners to basic programming and computational thinking concepts. Starting this education early can help children become more comfortable with technology and better prepared for a digital future.
Some activities I’ve taken taken directly from the CAPS Foundation Phase Coding and Robotics curriculum to get you thinking how you can use the Blue-bots in your classroom.
Sample Lesson Plan: Introduction to Coding and Algorithms with Blue-bots
- Grade: 1
- Coverage: Week 4 Lesson 1
- Duration: 40 minutes
Introduction/Review – 5 minutes
- A quick recap of previous lessons about memory, numbers, sequencing, shapes, and colours.
- Introduction to the Blue-bots and a brief discussion about what they can do.
- Explain what coding and algorithms are using simple language.
New Material – 15 minutes
- Explain the structure of a program and its sequences.
- Using the Blue-bots, demonstrate the block movement commands (forward, back, turn right, turn left).
- Illustrate how an algorithm works using a simple everyday task (like brushing your teeth or making a sandwich).
Guided Practice – 10 minutes
- Divide the class into four groups of six learners each.
- Each group gets a Blue-bot and a set of code cards.
- Demonstrate a simple coding task on the board and have each group try to duplicate it with their Blue-bot using the code cards.
- Walk around to each group, offering guidance and assistance as necessary.
Individual Practice/Activity – 5 minutes
- Provide each group with a simple problem or task for their Blue-bot to perform using the code cards.
- The task should include specific movements (e.g., moving forward two spaces, turning left, moving forward one space).
- The learners should work together to use the code cards to sequence the movements correctly to accomplish the task.
Evaluation/Reflection – 3 minutes
- Each group presents their solution and reflects on how they achieved it.
- The class as a whole can offer feedback and discuss alternative solutions.
- Prompt the class to think about why different groups might have different solutions and what this means regarding coding.
Debugging – 2 minutes
- Discuss what it means to debug a program.
- Use any mistakes made during the group activities as examples to illustrate debugging in real time.
Homework/Extension – Create your project: Learners will develop a sequence of commands for a task of their choice using a paper replica of the Blue-bot and paper code cards.
Materials – Blue-bots (6) – Code cards (24 sets) – Large open space or mat with grid lines for the Blue-bots to move
Note – Ensure every learner can interact with the Blue-bot and code cards. This may mean taking turns within groups. – Continually relate coding concepts to real-life scenarios to help learners understand. – Keep the environment collaborative and positive. Mistakes are a part of learning in coding!
Curriculum Activities
Activity 1: Making Blue-Bot Move-in Steps
In this activity, learners will learn the basics of coding sequences and algorithms by giving step-by-step instructions to a Blue-Bot.
Materials:
- Blue-Bot
- Mat (a grid mat that matches the Blue-Bot’s step size). You can use any 15 cm grid or make your own if unavailable.
Procedure:
- Place the Blue-Bot at a starting point on the left side of the mat.
- Explain that each button press will make the Blue-Bot move one step in the indicated direction.
- Ask learners to plan how they can move the Blue-Bot three steps forward. This plan is their algorithm.
- Once they’ve made their plan, have learners input the instructions into the Blue-Bot using the forward buttons. (Remember to hit the clear button before entering a new sequence).
- After the Blue-Bot has been programmed to move three steps forward, ask the learners to plan an algorithm to move the Blue-Bot four steps to the right.
- Have the learners input the next sequence into the Blue-Bot.
- Test the program. If the Blue-Bot ends where the learners expected, they’ve correctly executed their plan. If not, they can work on debugging the problem.
This activity aims to introduce the concept of sequences and algorithms in a hands-on, engaging way while promoting problem-solving skills when learners have to debug their instructions.
Activity 2: Blue-Bot Step-by-Step Instructions
This activity takes the learner through the process of thinking through steps, understanding sequence and directions, and solving problems – all critical aspects of computational thinking and coding.
For this activity, you’ll need a Blue-Bot and a Blue-Bot mat. You can use any square grid mat that matches the Blue-Bot’s step size (about 15cm). For a more engaging experience, consider customizing the mat to include pictures of a ‘tin’ and ‘bin’ at appropriate locations, or you can use actual small objects to represent these.
Here’s how to conduct the activity:
- Place the Blue-Bot on the starting point on the mat.
- Explain to the learners that each button press will make the Blue-Bot move one step in the indicated direction or turn 90 degrees.
- Begin to translate the instructions for the Blue-Bot:
- Move three steps forward: Press the forward button three times.
- Turn right: Press the right turn button once.
- Move two steps forward: Press the forward button two times.
- “Pick up the tin”: At this point, explain to learners that Blue-Bot cannot physically pick up objects, but we can pretend that it has by stopping at the “tin” location.
- Move one step forward: Press the forward button once.
- Turn left: Press the left turn button once.
- Move one step forward: Press the forward button once.
- “Drop the tin into the bin”: Again, we pretend that the Blue-Bot has dropped the tin when it stops at the “bin” location.
- After inputting the instructions, press the ‘Go’ button and watch the Blue-Bot perform the sequence.
- Discuss the results. Did the Blue-Bot end up where it was expected to? If not, try to figure out what went wrong and correct it. This helps introduce the concept of debugging in programming. Remember, this activity is not just about getting the right answer!
Activity 3: Blue-Bot Maze Challenge
This activity can be a fun, engaging, and instructive exercise using the Blue-Bot. You’ll need a Blue-Bot and a Blue-Bot mat. You can use any square grid mat that matches the Blue-Bot’s step size (about 15cm). Additionally, you’ll need to create a maze on the mat, which could be as simple as marking the “walls” using strips of coloured tape. Also, place a toy or an object at a specific location in the maze and a ‘basket’ at another location where the toy needs to be moved.
Here’s how to conduct the activity:
- Setup: Divide the class into pairs. In each team, one learner is the ‘controller’, and the other is the ‘observer.’ The controller will input commands into the Blue-Bot, while the observer will watch the Blue-Bot’s movements to ensure it follows the instructions correctly.
- The Challenge: The challenge for each pair is to navigate the Blue-Bot through the maze, pick up the toy (by reaching its location), and drop it off in the basket (by reaching the basket’s location). The controller cannot touch the Blue-Bot once it starts moving.
- Planning: Before beginning, both learners should look at the maze and plan their moves, similar to creating an algorithm in programming. This encourages strategic thinking and problem-solving.
- Execution: Once they have a plan, the controller begins to input the commands into the Blue-Bot:
- Move forward: Press the forward button. Each press equals one step.
- Turn left: Press the left turn button.
- Turn right: Press the right turn button.
- “Pick up” the toy: Once the Blue-Bot reaches the toy’s location, pause and acknowledge that the Blue-Bot has “picked up” the toy.
- “Drop” the toy: Once the Blue-Bot reaches the basket’s location, pause and acknowledge that the Blue-Bot has “dropped” the toy into the basket.
- Review: If the Blue-Bot successfully navigates the maze and completes the task, the pair should swap roles and try a different maze. If the Blue-Bot doesn’t meet the task as expected, the learners need to “debug” their plan. Where did things go wrong? Was there an error in the commands, or did something unexpected happen in the execution? How can they fix the issue?
This activity enhances teamwork, strategic planning, problem-solving, and debugging and gives a hands-on experience in coding in real-world applications.
Activity 4: Simulating a Loop
We can simulate the concept of loops or repeating a block of instructions using Blue-Bots. While Blue-Bots doesn’t natively support loops, we can manually simulate this by entering the same sequence of instructions multiple times. This will still effectively demonstrate the concept of repetition in coding.
Materials:
- Blue-Bot
- Mat (a grid mat that matches the Blue-Bot’s step size).
Procedure:
- Place the Blue-Bot at a starting point on the mat.
- Ask learners to plan how to make the Blue-Bot move three steps to the left. This plan is their algorithm.
- Once they’ve made their plan, have learners input the instructions into the Blue-Bot using the forward and turn buttons. Remember to hit the clear button before entering a new sequence.
- Next, have them plan how to make the Blue-Bot turn right and move three steps back to where it started. Again, have them input these instructions into the Blue-Bot.
- To simulate the “Repeat” block, ask the learners to enter the same sequence of instructions four times in total.
- After the instructions are input, press the ‘Go’ button and watch the Blue-Bot perform the sequence.
- Discuss the results. Did the Blue-Bot end up where it was expected to? If not, try to figure out what went wrong and correct it. This helps introduce the concept of debugging in programming.
Although the Blue-Bot lacks an explicit repeat function like e.g. Scratch Jr., this activity still introduces the principle of repetition (or looping) in a tangible, hands-on way. The learners create a ‘manual’ loop by inputting the same sequence of commands multiple times. So while the Blue-Bot doesn’t have a repeat function, we can create a “manual loop” by entering a sequence of commands multiple times and then asking learners to debug it.
Activity 5: Debugging a Blue-Bot Sequence
Materials:
- Blue-Bot
- Mat (a grid mat that matches the Blue-Bot’s step size).
Procedure:
- As the teacher, input a series of commands into the Blue-Bot, which forms a sequence. For example, move forward two steps, turn right, and move forward three steps. Repeat this sequence three times to create a “manual loop”.
- Run the sequence by pressing the ‘Go’ button on the Blue-Bot.
- Then, tell the learners what the sequence was supposed to achieve – for example, the Blue-Bot should have ended up on a specific spot on the mat.
- If the Blue-Bot did not end up in the correct spot, present this to the learners as a “bug” in the code. Explain that a “bug” is an error in a program that causes it to produce an incorrect or unexpected result.
- Ask the learners to “debug” the sequence – that is, to figure out what went wrong with the sequence and how to fix it. They should consider questions like, “Did the Blue-Bot turn in the correct direction?”, “Did it move the correct number of steps?”, “Was the sequence repeated the correct number of times?”.
- Once they’ve come up with a solution, clear the Blue-Bot’s memory by pressing the ‘X’ button and have the learners input the corrected sequence.
- Run the new sequence by pressing ‘Go’. If the Blue-Bot is in the correct spot, the learners have successfully debugged the sequence.
This activity introduces learners to debugging in a tangible, hands-on way, helping them understand that coding involves creating sequences and troubleshooting and problem-solving when those sequences don’t produce the expected results.
Activity 6: Blue-Bot Maze Challenge
For this activity, we’ll transfer the concept of debugging a maze program in e.g. Scratch to a physical maze navigated by the Blue-Bot.
Materials:
- Blue-Bot
- Mat (a grid mat that matches the Blue-Bot’s step size)
- A small object or cutout to represent the “dot” (starting point)
- A small object or cutout to represent the “flowers” (endpoint)
- Obstacles to creating a maze (these can be anything that fits onto the mat, such as blocks or books)
Procedure:
- Set Up the Maze: Arrange the obstacles on the mat to create a maze. Place the “dot” at the starting point and the “flowers” at the endpoint of the maze.
- Plan the Path: Provide the learners three instructions (a, b, and c) to navigate the maze. These should be presented as sequences of commands, like “Forward 2, Right Turn, Forward 3,” etc. At least one of these sequences should not lead to the flowers correctly.
- Choose and Test: Ask the learners which program will successfully navigate the Blue-Bot through the maze to the flowers. They should choose one, input the commands into the Blue-Bot, and press ‘Go’ to test their choice.
- Debug the Incorrect Program: After testing all sequences, the learners should identify which program didn’t lead the Blue-Bot to the flowers. They should debug this program by figuring out where the instructions went wrong and coming up with the correct sequence of commands to navigate the maze successfully.
This activity provides hands-on experience with debugging in a physical environment, emphasizing that finding and correcting errors is a crucial part of coding. It also reinforces the concept of algorithm planning, as learners must plan and adjust the sequences of instructions for the Blue-Bot to navigate the maze.
Activity 7: Blue-Bot Step-by-step Instruction
In this activity, learners will use Blue-Bot as their ‘robot’, providing step-by-step instructions to pick up items and put them in a designated area.
Materials:
- Blue-Bot
- Mat (a grid mat that matches the Blue-Bot’s step size)
- Small objects to represent the items to pick up (learners will pretend Blue-Bot can pick up these items)
- A designated area on the mat to serve as the basket
Procedure:
- Pair Work: Pair the learners up. They will take turns being the “controller” (the one giving instructions) and the “observer” (the one checking the correctness of the instructions).
- Direction Cards: The learners already have physical buttons on the Blue-Bot to represent forward, back, turn left, and turn right. You can create simple paper cards for ‘Pick Up’ and ‘Drop’.
- Setting Up the Activity: Scatter the items (which can be paper-based) around the Blue-Bot mat. The designated basket area should be marked.
- Giving Instructions: The controller will give step-by-step instructions to the Blue-Bot to navigate to each item, “pick it up”, and then “drop” it in the basket. Each action must be entered into the Blue-Bot as the controller announces it. For the ‘Pick Up’ and ‘Drop’ commands, the controller can place the corresponding card next to the Blue-Bot to indicate these actions.
- Switch Roles: Once all items have been collected, learners should switch roles and repeat the activity. This allows both learners to command the Blue-Bot and understand the programming thought process.
This activity helps learners understand how sequences of commands can achieve a specific goal. It encourages spatial thinking and planning, as learners must determine the most efficient way to collect all items.