Tag Archives: technoturtle

Teach Debugging to Beginners to Build Confidence

It is important to teach debugging to beginners right away. Debugging is when a programmer finds “bugs” or errors in their code and fixes them to improve the program. This is an essential programming skill. So much so, that it should be taught at the beginning of a coding unit.

Where Were the Debugging Strategies in the Instructional Materials and Python Courses?

When I was asked to develop Python materials for TechnoKids Inc. I jumped at the chance. I began to read books about Python. They had titles emphasizing that the instructions inside were for “absolute beginners”. I noticed that none had activities or advice on debugging. Instead, if the code I was copying from the page didn’t work I was left guessing why. It was frustrating!

My reaction was one that I knew students would feel. I worried that young programmers might begin to think “I am not good at programming” when they encountered an error they could not fix. This belief might turn them away from learning more about coding. I knew it was necessary to reframe how students respond to mistakes in their programs. They needed to feel empowered, not defeated.

The books were helpful in understanding the types of instructional materials available to teachers on teaching Python – but I needed to learn more!

I wanted to understand the difference between what young children and young adults were learning about Python. I signed up for a first year course at the university where I did my undergraduate degree. This course did have a section on debugging, but it was at the end of the course. I asked the professor why it was introduced so late and was told it was because beginners could not understand the error messages until they had learned how to code. As a result, I spent a good portion of the course inefficiently applying debugging strategies. I knew there had to be a better way!

When it came time to create the TechnoKids Python STEM projects I had reached a decision…debugging needed to be taught right away. I wanted students to be able to understand the meaning of the errors they would see. More importantly, I knew they needed simple strategies to fix their code.

Teach debugging to beginners.

What Happens When the Program Keeps Shouting ‘You Are Wrong’…But You Don’t Know How to Make it Right?

When Students Lack Debugging Strategies, Red X’s Tell the Learner They Can’t Code

During my investigation of Python programming with kids I noticed that there were common errors made. These mistakes would trigger several responses by the IDLE Python program. The Python Editor Window, which is where programmers build the code, will display a box with a red x on Windows devices. Those are for syntax or indent errors. In this case, there might be a forgotten bracket or # in front of a comment: simple to fix, but not without knowledge of debugging.

The angry red x’s that show up on the screen mock a novice. Unintentionally they seem to say “you can’t code”. To prevent students from becoming discouraged, teachers should provide strategies for decoding error messages. This will build confidence and promote independence.

When a student lacks debugging strategies the Python error messages can be a source of frustration.

When Students Lack Debugging Strategies, They Can’t Find the Problem

Another technique the IDLE Python program uses to assist programmers is to identify a spot within the code where there is an issue. This is accomplished with a reddish-pink box around text. The skilled programmer knows to look BEFORE the highlight.

However, those without debugging strategies can stare at the code forever and never know what is wrong. This is because children and young adults are literal. They look at the reddish-pink text and say “Oh, the problem is right HERE”. Beginners lack sufficient knowledge to locate the error. This shortcoming can easily be overcome by explicitly teaching debugging strategies.

The word highlighted is not the error. It is the missing bracket BEFORE shape.

When Students Lack Debugging Strategies, Red Text Tells a Beginner They Do Not Understand How to Program

The error response by the IDLE Python program is to show a message in the Python Shell. The text is red. It often tells the programmer there is a name or type error. These errors can occur if a library is not imported, a command is spelled wrong, a variable is not used properly in the code, or a sentence does not use the correct punctuation for joining text with variables. The Python message identifies the line number and reason for the problem. However, with no debugging strategies it can seem like gibberish.

The red text in the Python Shell is the equivalent of using a red pen to grade student work. Many educators have given up this practice as it promotes self-esteem issues, which can turn students away from wanting to learn. Studies have show that for many learners red pen is like ALL CAPS. It yells “You are wrong!” When red text is the method for highlighting errors, it can make a student feel angry or sad. This is avoidable when educators teach debugging to beginners at the start of a coding unit.

Python error messages can seem like gibberish to beginners.

Teach Debugging to Beginners at the Start of a Coding Unit

To avoid making students feel bad about themselves, why not just give students perfect code to copy? Then when they run the program, no errors will happen. Or if they do, they can quickly refer to their sample to find the typo. Problem solved!

No. Not really.

The limitation to this instructional approach is that it restricts learning. One of the goals of teaching a STEM project should be to support students so they produce their own original creations. Aside from developing programming skills, the learning objectives in a programming unit should include: fostering an interest in programming, developing computational thinking skills, and applying logic and reasoning to solve a problem. The aim should not be improving typing skills.

Spark an ongoing interest in programming. Teach debugging strategies at the beginning of a coding unit. This will build confidence and promote independence.

Python Lessons that Explicitly Teach Debugging to Beginners

Teachers need to deliberately teach debugging strategies at the start of a programming unit. This empowers students. Using this instructional approach, the TechnoTurtle STEM project includes activities that teach students about common errors and how to fix the code.

TechnoTurtle has 30 coding assignments. Elementary and middle students solve mazes, create artwork, and build games. Several of the lessons emphasize debugging strategies. They are interwoven throughout the project to introduce or reinforce computer science concepts:

Edit a Python Program: Modify values to understand the purpose of code.
Bug Zapper: Add mistakes to a program to learn how to debug Python.
Clean Up the Code: Fix coding errors by selecting from the list of choices.
Trial and Error: Test different ideas to move a Turtle through a maze.
Draw a Robot: Write one line of code at a time and make corrections as you go.
Edit an Invitation: Change code to discover how to join text with variables.

Techniques to Teach Debugging Strategies

When designing a Python programming unit, include lessons with techniques to teach debugging strategies. Debugging is the ability to find and fix errors in code. It is a vital skill for young programmers to master.

Don’t hope that students will discover these strategies on their own. Instead, guide them through proven methods.

Explicit Strategy Instruction and Debugging Strategies

STEM classes emphasize writing code to animate objects, create artwork, or build games. In the push to build a program, the ability to edit the code may not be a focus of instruction. In this learning environment, identifying mistakes and correcting them becomes an implicit process.

During programming lessons, students need to decipher the meaning of error codes independently. They must spontaneously determine how to solve the problem. The young programmer can be left feeling inadequate as they struggle to get their programs to run.

Frustration is an integral part of the learning process. It fosters persistence, which is an admirable quality in a programmer. However, for many beginners, the challenges can seem insurmountable and they give up – telling themselves, “I am not good at programming”.

There is a better way!

Explicitly teaching debugging strategies empowers learners. No longer will they feel defeat when an error message appears. Instead, they have techniques to competently debug the Python program. This builds confidence and promotes a positive attitude towards STEM.

4 Techniques to Teach Debugging Strategies

1. Break It, Repair It

There are many techniques to teach debugging strategies. One that is very effective is to intentionally break code, then run the program to notice the result. This type of STEM lesson takes very little instructional time, yet quickly improves debugging skills.

To start, provide students with a Python file. Using direct instruction, have them systematically delete parts of the code to generate common errors. When the program is run, the instant feedback forms a connection between bugs, error messages, and how to fix the problem.

Some suggestions for breaking the code include:

remove vital lines such as the import of a library to note how commands are no longer recognized
add or delete punctuation such as quotes, brackets, colons, and commas to explore their purpose
adjust the indent level of a block of instructions to see how it influences the program
alter symbols such as ==, !=, <, and > then study how they alter the output
misspell a command to highlight the importance of accuracy when typing code
turn an equal sign == into = to notice how the code no longer works

Using these techniques to teach debugging strategies will enhance your students’ programming skills. If you are looking for a ready-made Python lesson, TechnoTurtle has a Bug Zapper exercise. Students follow instructions to produce bugs and then repair the code. This activity is ideal for beginners in Grades 3-9.

Intentionally break the code. This provides instant feedback when the program runs forming a connection between bugs, error messages, and how to fix the problem.

2. Code and Correct

Another debugging lesson is one that guides students through the development of a program. Using direct instruction, the teacher outlines the goal of the programming task. Line by line, the teacher types the code that the students copy. After each line, students run the program to study the output. When a mistake occurs, the teacher highlights the issue and explains how to troubleshoot the code. Slowly, the program takes shape.

This technique best suits students that are familiar with syntax and name errors. Instead of focusing on typos, this lesson emphasizes the quality of the output. It studies the outcome and provides solutions on how to improve the code. The sample program should be short. It must have common pitfalls to resolve as a class.

TechnoTurtle, a Python programming project for beginners, has several lessons that are ideal for a Code and Correct lesson. For example, students follow steps to draw a robot. Throughout the learning process, problems are intentionally generated. This provides an opportunity for beginners to think about the code and how to improve the program’s design.

TechnoTurtle includes techniques to teach debugging strategies. Follow the guided instructions to fix the code.

3. Explore and Investigate

Invite exploration into your STEM lessons to promote a positive attitude towards debugging. Often troubleshooting a program’s output can be a source of frustration. However, in this activity it is fun. Encourage students to play with different values to notice how they change the outcome. Investigate by making a number higher or lower. Or, replace a string with another option.

Explore and Investigate is meaningful. Active discovery demonstrates why one value is better suited to the program than another. It transforms mistakes into happy surprises.

Sparking a life-long interest in STEM is one of the goals of programming lessons. In TechnoTurtle, there are many activities in which students modify the values within a program to achieve a unique outcome. This makes learning enjoyable, which hopefully promotes an on-going interest in programming.

Invite exploration into your STEM lessons to promote a positive attitude towards debugging.

4. Pick the Correct Code

Another technique to improve debugging skills is to provide students with snippets. Rather than mindlessly copying code they are presented with two options. One snippet is correct, the other has a bug. By making choices, the young programmers write the program.

This type of programming lesson actively engages students. They must study the code and think about the choice they will make. If they are incorrect, the feedback is instant. They can then use the other option instead. This activity cultivates a learning environment where it is safe to make mistakes.

An example of a similar programming activity is Clean Up the Code in TechnoTurtle. Young programmers determine how to debug the code. The program they are editing should stamp turtles on the canvas. However, it has four errors. For each error, they are given two choices. This activity builds debugging skills.

Cultivate a learning environment where it is safe to make mistakes.

Apply Multiple Techniques to Teach Debugging Strategies

When teaching your next programming unit, design lessons that explicitly teach debugging strategies. This will build competence in your students and support independent learning. As well, this instructional approach has the potential to transform how students feel about errors. Turn your STEM classroom into a safe place to make mistakes.

Python Variables and Offline Coding Exercise

Young programmers need to understand the purpose of Python variables. In a program, variables store values that can change. They are very powerful. They can be used to count, create lists, store user input, report information, personalize the user experience, trigger an action, calculate amounts, and more!

One of the best ways to learn about computer science concepts is hands-on learning. In other words, writing programs that use variables. Talking about variables will generate a limited understanding. Having said that, before jumping into Python programming, it is worthwhile to begin instruction about variables with an offline coding exercise.

Variables can seem a bit abstract to a child. It is worthwhile to make the concept tangible. A quick activity that connects variables to daily life will help elementary and middle school students to form an understanding of their use.

Have your students apply computational thinking to think about the world around them as a set of variables that store and direct events. This knowledge can then be transferred to programming activities. Refer to the connections below as a way to create an offline coding exercise about Python variables.

The Value of a Variable Changes

Just like the weather, a variable is a value that changes. It could be sunny in the morning and then rainy in the afternoon. What is the weather?

Complete the value of the variable weather. For example: weather="sunny"
weather=" "

A Variable Stores Different Types of Information

A variable can be text, a number, or a list. In the above example, the value stored was a word. However, you can also store numbers as variables. Temperature is a numbered variable that changes. It could be 5°C (41°F) at night and then 15°C (59°F) in the afternoon.

Write the value of the variable temperature. For example: temperature="15"
temperature=" "

The Value of a Variable Can Trigger an Event

The value of a variable can cause an action to occur. For example, if it is hot outside you might wear shorts. Or if it is rainy you might use an umbrella.

Complete the script using weather as the variable. What will you wear?

if weather=="snowy":
what will you wear?

An Event Can Trigger the Value of a Variable to Change

When a program starts, a variable has a specific value. However, an event may occur that changes the value. This event could make a number higher or lower. Or, it could assign a new word to a text variable.

When making a decision you might change your mind depending on what is happening. Programs do the same thing! Pretend you are getting dressed for school. What piece of clothing do you want to wear?

Complete the value of the variable clothing
clothing=" "

The item is in the laundry. What piece of clothing will you wear now?
clothing=" "

A Variable Is Stored in a Numbered Location

The value of a variable is saved in a spot that is like a numbered storage bin. When the program needs the value in the variable it takes it from the bin. The computer knows where to find the value because it has a unique location.

Labeling a location to store things is done everyday at school. For example, your school locker may have a number. Or the library may have a numbered bin of books.

Look around your classroom. What bins are used to store things? Are they labelled?

Write your discovery as a variable. For example: mylocker="1215" or period1bin="homework"

bin="item"

A Variable Is an Efficient Way to Refer to Information

A variable is like a container that stores information. The label on the outside is the name. The item you put inside is the value. When giving an instruction, the program uses the variable name, not the data stored in it. This is done to save time and keep things simple.

Imagine it is recess time. The teacher needs to tell the students what to do. The teacher gives the instruction, “Please go and get your snack”. The teacher does not say, “Please go and get your apple, crackers, cookies, carrots, chips, or banana.”

The word “snack” is used to refer to many values. It also allows the values to be unknown. The teacher cannot know what you or your classmates brought for a snack. Using one word that is meaningful is an efficient way to refer to information.

People often use one word to quickly refer to many things. Turn the word lunch into a variable. What is in your lunch today? Make a list of the values in your lunch. For example:

lunch=("orange juice", "ham sandwich", "apple", "blueberry muffin")

lunch=

A Variable Can Store User Information

Sometimes the programmer assigns the value of a variable. Other times, the user inputs a value. This can be done by prompting the user to enter data by displaying a text box or question on the screen. The program can then use this information to sign into an account, customize the settings of an app, or pick a selection.

Think about a game you play on a device. What information does it ask you to input? Each of the pieces of information is a variable.

List two pieces of information you must enter into a game before you could play it. For example:

playername="technokid"

playermode="single player"

Python Variables and Fun Programming Activities for Kids

If you are looking for some fun programming activities for kids that use variables, take a look at TechnoTurtle. This STEM project introduces beginners to Python variables in a way that is easy to understand. Students develop programs that have players play Mad Libs, a Carnival Game, and a Guess the Number Game. Each uses variables to trigger action. These coding activities are a great way to make Python variables meaningful to kids. The lessons provide a foundation for further learning.

Teach children about Python variables using the STEM project TechnoTurtle.

Teach Python Using the Turtle Library

Teach Python using the Turtle Library to ignite an interest in STEM. Python is a popular text-based programming language. It is used every day by programmers.

The Turtle Library is a collection of functions used to control a robotic Turtle. The commands can be combined with Python to build programs that create stunning artwork and original games. The use of the The Turtle Library is a fun way to introduce students to programming.

You may think that using the Turtle Library to teach Python is a waste of time. Shouldn’t students be learning ‘real code’ instead of functions that they won’t use in the workplace? How useful is it for young programmers to move a Turtle through a maze using forward(100) or draw using pendown()? The answer is….very useful!!!

The skills acquired from building programs using Python and the Turtle Library provide a foundation for further learning. By knowing the basics, young programmers can extend their knowledge to more complicated tasks in the future. Discover the 7 reasons you will want to use the Turtle Library with your students.

7 Reasons to Teach Python Using the Turtle Library

1. Produce a Wide Range of Coding Projects

The use of the Turtle Library is not limited to moving a Turtle around the canvas or making artwork. Although this is really fun to do, it can be used for so much more! Want to hook students’ interest in STEM? Then teach Python using the Turtle Library. Consider programming these games using the Turtle Library:

Etch-a-Sketch: Invent a drawing game that uses arrow keys to draw lines to create artwork.
Carnival Game: Design a game using conditional logic that awards a prize to players based on the option they pick.
Mad Lib: Create a word game that stores players’ answers as variables to form silly sentences.
Guess the Number: Combine the Random Library with the Turtle Library to build a game that has players pick a number between 1 and 10. Will they guess correctly?

2. Develop the Computational Thinking Skills to Sequence Instructions

Programming requires each line of code to be in the correct order to achieve a goal. When writing code with the Turtle Library of commands, students must apply computational thinking to determine what comes first, second, and third. This ability to sequence instructions will be helpful later when programs are longer and more complex.

3. Effectively Apply Debugging Strategies

No matter whether a programmer is using Python or has code that includes commands from the Turtle Library, the errors are the same. Mistakes in coding generate the identical name and syntax errors. For example, if a : (colon) is missing at the end of a loop, there will be an indent error. Understanding how to identify the problem and fix it is transferable to new programming tasks.

4. Understand How to Organize Scripts

No matter the programming language, programmers add comments to describe each section in a program. A comment is a brief description that acts as a summary. It explains the purpose of the code. Comments are used by programmers to communicate with others about the intent of the code. As well, they can act as markers to identify each part of a program. This makes it easier to locate a specific section for writing new code or debugging errors.

In Python a comment begins with a hashtag #. The symbol tells the interpreter to skip the line as it does not contain an instruction. For example, #store a word list is a useful descriptor that explains the purpose of the following lines of code. It is important for young programmers to get in the habit of using comments as it is good programming practice used by professionals.

5. Import Libraries to Build Programs

The Python programming language uses special words to tell the computer what to do. A function is a word that does a specific task by executing a stored set of instructions. Many Python functions are stored into libraries. Professional programmers use Python libraries to create responsive graphs, display the time, or grab information from a web page. The ability to import the Turtle Library is similar to importing any Python Library, making it a useful programming skill.

The ability to import libraries is an important reason to use the Turtle Library to teach programming skills. Programs that use the Turtle Library to create artwork and build games can include other Python libraries. For example, students can use the Random Library to pick a random number or item from a list. This is a fun way to make surprising geometric patterns or a Guess the Number game. As well, students can use the Time library to set the timing of events. This is very useful when flashing the word “WINNER” across the canvas in Carnival game. The programming skills that are introduced when using the Turtle library can be transferred to more complicated or work-related tasks in the future.

6. Appreciate the Importance of Accuracy When Writing Lines of Code

When students are writing programs using Python and the Turtle Library, they quickly learn the importance of accuracy. A reader can understand a story or report that has a few spelling or grammar mistakes. A computer cannot. If a program has a command spelled incorrectly it will not run. Moreover, if the code is missing a bracket, colon, or indent than an error will display. The emphasis on precision when coding is best taught early, as it is required by all programmers. Teach Python using the Turtle Library to support STEM.

7. Instant Feedback Develops Confidence

The Turtle canvas instantly shows the result of the code. This visual is helpful during program development. Nothing is more frustrating then trying to figure out why the code does not work the way it is supposed to when the program runs. Young programmers can quickly become frustrated. With a lack of immediate success, they can start to believe that they are not good at programming. Since the Turtle Library displays the output on a canvas, the programmer can see what they need to change to improve their program. For example, they might notice that the Turtle moves in the wrong direction, the pen needs be picked up to stop drawing a line, or the game title is too small to read. Seeing what needs to be fixed helps young programmers understand how to improve their code.

Support STEM. Teach Python using the Turtle Library. Spark an interest in programming.

TechnoTurtle Has Lessons to Create Artwork and Build Games

TechnoTurtle is a technology project, by TechnoKids Inc. that has lesson plans to teach Python using the Turtle Library. It has over 30 assignments that gradually introduce programming skills to elementary and middle school students. The instructions guide students to build programs, with additional open-ended challenges to spark creative exploration of code.

TechnoTurtle has lessons that introduce programming skills in a fun way.