Practice Debugging a Game

Loops are often a difficult concept to grasp at first, so don’t worry if you get stumped at some point while learning to code with them (but make sure to pay attention to the feeling of being “stuck” and also the feeling of accomplishment when it works!). Also, as the challenge level goes up, don’t forget that you have the logical problem solving process to help you think through the problem.

The game of Pig is a point-based dice game in which the first player to score at least 100 points is the winner. On a player’s turn, they roll two 6-sided dice:

• If the dice roll snake eyes, the player loses all their points for the game so far and their turn is over.
• If either dice roll is 1, the player loses the points gained on the current turn only, and the turn is over.
• For any other roll/die combination, the die roll contributes to the points accumulated for this turn.

The player can then decide to play again, risking the points earned this turn, or to "hold" — that is, keep the points for the turn and cede the turn.

Getting Started

• Download this zip file to your computer and move it to a folder on your computer where you want to keep your programs for this course
• Unzip/Unarchive the file if you need to by double-clicking on it (your computer may do this automatically when downloading)
• Open PyCharm, press the Open button (or select File → Open), navigate to where you saved the folder, and select it
• You will need to Trust the project before it can be opened

Resources

• Detective Debugging by Shannon Duvall
• Debugging Zen by Nick Parlante
• Rubberduck Debugging (originally coined by Andrew Hunt and David Thomas)
• Debug your first Python application from JetBrains

Play the Game

In the Project Explorer panel, click the arrow beside the lab_pig project to expand the folder and show the two Python files inside that represents the game of Pig:

• GameGraphics.py: determines how the game is drawn (dice, progress, messages to the players, etc.)
• PigRules.py: determines the rules and the winner of the game

Right-click on the file PigRules.py in the Project Explorer and select Run PigRules to play the game. The game will start playing automatically, prompting you to choose to roll again or hold as appropriate (but you may notice some things are not quite right).

We will be focusing on the file PigRules.py and its two functions that are already completed:

play_turn(player_total_score) - This function plays one turn for one player. It should let the player roll until they either choose to stop or they roll a one. Its input is the score for the player at the beginning of their turn. If they roll a single one, it should return 0. If they roll double ones, (snake eyes), it should return -1. Otherwise, it should return the sum of the rolls.

play_game() - This function plays the entire game until a player wins. It should play each player's turn until one of them reaches 100 points.

Here is a video discussing using a debugger and getting started on the project

Debugging

No matter how skilled a programmer is, no one programs perfectly the first time. Finding and fixing errors is as much a part of the programming process as typing in the program to start with! However, debugging often takes a different set of skills (observing and generating hypotheses) than does programming (problem solving) and, just like programming skills, debugging skills can be honed with some training and practice.

Just like we used a 7-step problem solving process to help get started programming, it can be useful to develop a debugging process (this one is based on a crime detective metaphor):

• Define the Crime. What makes you think the code does not work? Categorize the bug as a syntax error, runtime error, or logic error
• Identify the Victim. Generally speaking, when code does not work, there is something we can identify as wrong, e.g., the answer was supposed to be “100” but instead was “101”, so we refer to the answer as the victim
• Re-create the Crime Scene. In order to systematically debug the program we need to be able to reproduce it, so note the inputs or sequence of actions that cause the bug
• Identify the Suspects. Now that you have the crime and victim identified, you can identify the suspects: any code that had means and opportunity to cause the error?
• Use the Process of Elimination. At this point, we generally have in mind the nature of the bug but, before digging into the code, try to be strategic about it by narrowing down where you need to look.
• Follow the Trail of Evidence. Use a debugger or print statements to trace the code line by line, and at each step make sure the observed and expected behavior match.
• Formulate a Hypothesis and Test it. Once you have a guess at what might be occurring, test it out by making one change and re-running the program; making more than one change at a time or making unfounded changes just to see what works (known as “shotgun debugging”) is a really bad idea because you may not know which change made a difference

There are several bugs in the given code for you to find and fix. But before diving in:

• play the game a few times to understand how its behavior is different from the described way the game is supposed to work
• study the code to try to understand how it works and where in the code each part of the game is being handled

When debugging (or just trying to understand code), it can often be helpful to print the values of your variables or use PyCharm's debugger to step through the code. Also, make note of any error messages you see — they are important clues!