@@ -1,8 +1,7 @@
 # Introduction
 
-Nobody writes programs that are correct the first time around. Today we'll be
-talking about debugging: techniques for finding and fixing bugs in your code.
-
+Nobody writes programs that are correct the first time around. Today we'll learn
+about debugging: techniques and tools for finding and fixing bugs in your code.
 In your career as a programmer you will discover and fix many bugs and you will
 debug code by other programmers. Throughout the entire curriculum you will get
 homework/exercises that requires you to fix buggy programs.
@@ -11,17 +10,20 @@ So what is a bug? A bug lets a program do something it was not intended to do.
 But that definition is rather vague. Let's break it down. Actually a bug consist
 of three distinct parts:
 
-1. a **defect** - a piece of code that can cause an infection
-2. an **infection** - a program state that is different from the programmer's intention.
-3. a **failure** - externally observable effect of faulty program behavior caused by the
-infection.
-
-*TODO To help with the language barrier we first explain the English meaning of
-*the words defect, infection, and failure.*
+1. A **defect** - a piece of code that can cause an infection.<br/>
+*We can think of a **defect** as the source of a disease.*
+2. An **infection** - a program state that is different from the programmer's
+intention.<br/>
+*From the source an **infection** takes place. Someone will take ill and in turn
+that person will make more and more people ill.*
+3. A **failure** - externally observable effect of faulty program behavior
+caused by the infection.<br/>
+*When we notice someone took ill we know that there has been an infection and
+that there must have been a source somewhere.*
 
 # Hello wordl
 
-Let's look at this program. It has a bug in it:
+Let's look at this program. It has a defect in it:
 
 ```javascript
 // This program should print:
@@ -40,10 +42,10 @@ console.log(result);
 Debugging always starts by reading either some error message or look at
 something you didn't expect. Now, what a lot of people do is throw their hands
 in the air and say: "aahhhh, it's not working!". Don't do that. Something is not
-working, you don't know what, but you're gonna find out. Most likely most of your
-code is perfectly fine, but you just made a mistake somewhere. Reading the error
-is the absolute first step and the first clue to where your defect might be
-hiding.
+working, you don't know what, but you're gonna find out. Most likely most of
+your code is perfectly fine, but you just made a mistake somewhere. Reading the
+error is the absolute first step and the first clue to where your defect might
+be hiding.
 
 You have to detach yourself from your code, because your code is wrong. Instead
 you need to rely on the solution of the problem you have in your head.
@@ -66,11 +68,11 @@ i++;
 contents.)
 
 Remember that a defect will always result in an undesirable program state. So we
-need to look at our state to understand our program. To do this we add a
+need to look at our state to understand our bug. To do this we add a
 `console.log` line to our code where we let the program write down our state
 every time we do a lookup in the `elements` array. Our state is `i` and
-`elements`. I don't log `result` because `result` is derived from `i` and
-`elements` and I assume my defect is not in the lines `result += elements[i]`
+`elements`. We don't log `result` because `result` is derived from `i` and
+`elements` and we assume the defect is not in the lines `result += elements[i]`
 nor in `console.log(result)`. The defect must be somewhere before these lines.
 
 ```javascript
@@ -85,12 +87,12 @@ result += elements[i];
 "index i: 3 element: undefined"
 ```
 
-We see that at index `3` we do a lookup in our `elements` array the element is
-not there. `i++` is where the infection happens as  a result of our defect,
-whatever that may be.
+We see that at index `3` when we do a lookup in our `elements` array the element
+is not there and javascript gives us the `undefined` value. So `i++` is where
+the infection happens as a result of our defect, whatever the defect may be.
 
-Then `result += elements[i]` is where our initial infection of `i++` spreads
-into the `result` and now `result` is infected too.
+Then `result += elements[i]` is where our the infected `i` spreads into the
+`result` and now `result` is infected too.
 
 ## Defects