Debugging

This a problem set for you to work through

This is a problem set. Some of these are easy, others are far more difficult. The purpose of these problems sets are to HELP YOU THINK THROUGH problems. The solution is at the bottom of this page, but please don't look at it until you have tried (and failed) at least three or four times.

Terminology

In computers, debugging is the process of locating and fixing or bypassing bugs (errors) in computer program code or the engineering of a hardware device. To debug a program or hardware device is to start with a problem, isolate the source of the problem, and then fix it. A user of a program that does not know how to fix the problem may learn enough about the problem to be able to avoid it until it is permanently fixed. When someone says they've debugged a program or "worked the bugs out" of a program, they imply that they fixed it so that the bugs no longer exist.

Debugging is the process of finding and resolving of defects that prevent correct operation of computer software or a system. Debugging tends to be harder when various subsystems are tightly coupled, as changes in one may cause bugs to emerge in another.

A debugging process

7 Steps to fix a bug

The correct approach to debug is to follow a very structured procedure based on repeating the same steps for every bug, the reason for this is that bugs usually are symptoms of a much bigger problem going on, so in order for us to uncover the real nature of the error we have to make sure we do an exhaustive and systematic revision of it.

The degree of formality when following the steps may vary depending on the bug, for critical errors it is better to document every single step in a document. For minor errors, or bugs found while coding it is just enough to follow them as a mental guideline.

Step 1. Identify the error.

This is an obvious step but a tricky one, sometimes a bad identification of an error can cause lots of wasted developing time.

A few tips to make sure you identify the bug correctly:

1. See the error.
2. Reproduce the error.

You never should say that an error has been fixed if you were not able to reproduce it.

1. Understand what the expected behavior should be.
2. Validate the identification.

Ask yourself: is this expected behavior or an actual error?

Step 2. Find the error.

Once we have an error correctly identified, it is time to go through the code to find the exact spot where the error is located, at this stage we are not interested in understanding the big picture for the error, we are just focused on finding it. A few techniques that may help to find an error are:

1. Logging. It can be to the console, file… It should help you to trace the error in the code.
2. Debugging. Debugging in the most technical sense of the word, meaning turning on whatever the debugger you are using and stepping through the code.
3. Removing code.

    Take out half of the code from the action causing the machine to crash, and keep splitting the code until you find the error.

Step 3. Analyze the error

This is a critical step, use a bottom-up approach from the place the error was found and analyze the code so you can see the big picture of the error, analyzing a bug has two main goals: to check that around that error there aren’t any other errors to be found (the iceberg metaphor), and to make sure what are the risks of entering any collateral damage in the fix.

Step 4. Prove your analysis

This is a straight forward step, after analyzing the original bug you may have come with a few more errors that may appear on the application.

Step 5. Cover lateral damage

At this stage you are almost ready to start coding the fix. If you are working on a complex application, please document your fix in an error reporting database.

Step 6. Fix the error.

That’s it, finally you can fix the error!

Step 7. Validate the solution.

Run the program again and reproduce the same steps that you discovered in step 1.

What is this problem set trying to do

You are going to create errors when you code! Much of your work when you code is understanding where and error is in someone else's code. There is a process to follow when you are debugging. I expect EVERY student to follow the steps above when you are debugging. The purpose of this problem set is to encourage you to understand and apply your understanding of the debugging process to your code (and the code of a classmate).

The Problem

There is some broken code below Follow the debugging steps to make it work the way you think it should work. You must create a google document to track your steps. In order to meet the standard for this lesson:

1. you must resolve the error so the program runs.
2. you must answer the questions on this google template (please COPY the document, share it with me and then edit it)

Some Code to Get You Started

def hotel_cost(nights): 
	return 140 * nights 

def plane_ride_cost(city): 
	if city == "Charlotte": 
		return 183 
	elif city == "Tampa": 
		return 220 
	elif city == "Pittsburgh": 
		return 222 
	elif city == "Los Angeles": 
		return 475 

def rental_car_cost(days): 
	return 40 * days 
	if days >= 7: 
		rental_car_cost -= 50 
	elif days >= 3: 
		rental_car_cost -= 20

Take This Further

1. you can test for a @ and a . Could you also test for common misspellings?
2. if you can test for common misspellings, could you suggest the correct spelling?
3. we can check for common .com, .org, addresses but what about other top level domain names click here for a fairly scary list of them

How you will be assessed

Every problem set is a formative assignment. Please click here to see how you will be graded

See also

a short paper on the debugging process

A possible solution

Click the expand link to see one possible solution, but NOT before you have tried and failed at least three times

top_level_domains = ['com', 'org', 'pl', 'kz', 'edu']


while True:
    email = raw_input("Enter you email ")
    if '@' not in email:
        print("Error: you need an @ sign in your email.")
        break
    elif '.' not in email:
        print("Error: you need a . sign in your email. Please try again")    
        break
    # I am grateful to my student Sneha for this line below. It is a succinct way of capturing the characters AFTER the period.
    elif email[email.index('.')+1:] not in top_level_domains:
        print("Error: you need a valid domain name at the end")    
    else:
        print("Success: the email address you entered has passed our basic validation tests.") 
        break

Provide an answer from a number of possibilities. Recognize and state briefly a distinguishing fact or feature.

Provide an answer from a number of possibilities. Recognize and state briefly a distinguishing fact or feature.

Follow and record the action of an algorithm.

Break down in order to bring out the essential elements or structure. To identify parts and relationships, and to interpret information to reach conclusions.

Break down in order to bring out the essential elements or structure. To identify parts and relationships, and to interpret information to reach conclusions.

Use a sequence of logical steps to obtain the required result in a formal way.

Use an idea, equation, principle, theory or law in relation to a given problem or issue.

Propose a solution, hypothesis or other possible answer.