diff --git a/Advanced Functions Test .ipynb b/Advanced Functions Test.ipynb
similarity index 100%
rename from Advanced Functions Test .ipynb
rename to Advanced Functions Test.ipynb
diff --git a/Advanced Lists.ipynb b/Advanced Lists.ipynb
index c817435..6981ef3 100644
--- a/Advanced Lists.ipynb	
+++ b/Advanced Lists.ipynb	
@@ -357,7 +357,7 @@
    "metadata": {},
    "source": [
     "##remove\n",
-    "The remove() method removes the first occurence of a value. For example:"
+    "The remove() method removes the first occurrence of a value. For example:"
    ]
   },
   {
diff --git a/Advanced Numbers.ipynb b/Advanced Numbers.ipynb
index e092b98..790ce80 100644
--- a/Advanced Numbers.ipynb	
+++ b/Advanced Numbers.ipynb	
@@ -7,7 +7,7 @@
    },
    "source": [
     "#Advanced Numbers\n",
-    "In this lecture we will learn about a few more reperesentations of numbers in Python."
+    "In this lecture we will learn about a few more representations of numbers in Python."
    ]
   },
   {
diff --git a/Advanced Python Objects - Test .ipynb b/Advanced Python Objects - Test.ipynb
similarity index 100%
rename from Advanced Python Objects - Test .ipynb
rename to Advanced Python Objects - Test.ipynb
diff --git a/Advanced Sets.ipynb b/Advanced Sets.ipynb
index 7022197..b402a2c 100644
--- a/Advanced Sets.ipynb	
+++ b/Advanced Sets.ipynb	
@@ -825,7 +825,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Great! You should now have a compelte awareness of all the methods available to you for a set object type. This data strucutre is extremely useful and is underutilized by beginners, so try to keep it in mind!\n",
+    "Great! You should now have a complete awareness of all the methods available to you for a set object type. This data structure is extremely useful and is underutilized by beginners, so try to keep it in mind!\n",
     "\n",
     "Good Job!"
    ]
diff --git a/Advanced Strings.ipynb b/Advanced Strings.ipynb
index 7ad8ecb..0177c7e 100644
--- a/Advanced Strings.ipynb	
+++ b/Advanced Strings.ipynb	
@@ -7,7 +7,7 @@
    },
    "source": [
     "#Advanced Strings\n",
-    "String objects have a vareity of methods we can use to save time and add functionality. Lets explore some of them in this lecture:"
+    "String objects have a variety of methods we can use to save time and add functionality. Lets explore some of them in this lecture:"
    ]
   },
   {
@@ -346,7 +346,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "istitle() will return True if S is a titlecased string and there is at least one character in S, i.e. uppercase characters may only follow uncased characters and lowercase characters only cased ones. Return False otherwise."
+    "istitle() will return True if S is a title cased string and there is at least one character in S, i.e. uppercase characters may only follow uncased characters and lowercase characters only cased ones. Return False otherwise."
    ]
   },
   {
@@ -437,7 +437,7 @@
     "## Built-in Reg. Expressions\n",
     "Strings have some built-in methods that can resemble regular expression operations.\n",
     "We can use split() to split the string at a certain element and return a list of the result.\n",
-    "We can use partition to return a tuple that includes the seperator (the first occurence) and the first half and the end half."
+    "We can use partition to return a tuple that includes the separator (the first occurrence) and the first half and the end half."
    ]
   },
   {
diff --git a/All() and any() .ipynb b/All() and any().ipynb
similarity index 95%
rename from All() and any() .ipynb
rename to All() and any().ipynb
index e319a15..eb1cf01 100644
--- a/All() and any() .ipynb	
+++ b/All() and any().ipynb	
@@ -11,7 +11,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "all() and any() are built-in functions in Python that allow us to convienently check for boolean matching in an iterable. all() will return True if all elements in an iterable are True. It is the same as this function code:\n",
+    "all() and any() are built-in functions in Python that allow us to conveniently check for boolean matching in an iterable. all() will return True if all elements in an iterable are True. It is the same as this function code:\n",
     "\n",
     "    def all(iterable):\n",
     "        for element in iterable:\n",
@@ -19,7 +19,7 @@
     "                return False\n",
     "        return True\n",
     "        \n",
-    "any() will return True if any of the elements in the iterable are True. It is equivalent to the following funciton code:\n",
+    "any() will return True if any of the elements in the iterable are True. It is equivalent to the following function code:\n",
     "\n",
     "    def any(iterable):\n",
     "        for element in iterable:\n",
diff --git a/Chained Comparison Operators.ipynb b/Chained Comparison Operators.ipynb
index 1a28714..5cb471d 100644
--- a/Chained Comparison Operators.ipynb	
+++ b/Chained Comparison Operators.ipynb	
@@ -155,7 +155,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Note how it was true, this is beacuse with the **or** operator, we only need one *or* the other two be true. Let's see one more example to drive this home:"
+    "Note how it was true, this is because with the **or** operator, we only need one *or* the other two be true. Let's see one more example to drive this home:"
    ]
   },
   {
diff --git a/Collections Module.ipynb b/Collections Module.ipynb
index ea183de..54c5d80 100644
--- a/Collections Module.ipynb	
+++ b/Collections Module.ipynb	
@@ -6,13 +6,13 @@
    "source": [
     "#Collections Module\n",
     "\n",
-    "The collections module is a built-in module that implements specialized container datatypes providing alternatives to Python’s general purpose built-in containers. We've already gone over the basics: dict, list, set, and tuple.\n",
+    "The collections module is a built-in module that implements specialized container data types providing alternatives to Python’s general purpose built-in containers. We've already gone over the basics: dict, list, set, and tuple.\n",
     "\n",
     "Now we'll learn about the alternatives that the collections module provides.\n",
     "\n",
     "##Counter\n",
     "\n",
-    "*Counter* is a *dict* subclass which helps count hashable objects. Inside of it elements are stored as dictionary keys and the counts of the objects are stored as the value.\n",
+    "*Counter* is a *dict* subclass which helps count hash-able objects. Inside of it elements are stored as dictionary keys and the counts of the objects are stored as the value.\n",
     "\n",
     "Lets see how it can be used:"
    ]
@@ -286,7 +286,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Can also initilaize with default values:"
+    "Can also initialize with default values:"
    ]
   },
   {
diff --git a/Complex.ipynb b/Complex.ipynb
index 232c6a6..5aa4448 100644
--- a/Complex.ipynb
+++ b/Complex.ipynb
@@ -10,7 +10,7 @@
     "\n",
     "If the first parameter is a string, it will be interpreted as a complex number and the function must be called without a second parameter. The second parameter can never be a string. Each argument may be any numeric type (including complex). If imag is omitted, it defaults to zero and the constructor serves as a numeric conversion like int and float. If both arguments are omitted, returns 0j.\n",
     "\n",
-    "If you are doing math or engineering that requires complex numbers (such as dynamics,control systems, or impedence of a circuit) this is a useful tool to have in Python.\n",
+    "If you are doing math or engineering that requires complex numbers (such as dynamics,control systems, or impedance of a circuit) this is a useful tool to have in Python.\n",
     "\n",
     "Lets see some examples:"
    ]
diff --git a/Datetime.ipynb b/Datetime.ipynb
index 48a4fca..21f6103 100644
--- a/Datetime.ipynb
+++ b/Datetime.ipynb
@@ -9,7 +9,7 @@
     "Python has the datetime module to help deal with timestamps in your code. Time values are represented with the time class. Times have attributes for hour, minute, second, and microsecond. They can also include time zone information. The arguments to initialize a time instance are optional, but the default of 0 is unlikely to be what you want.\n",
     "\n",
     "##time\n",
-    "Lets take a look at how we can extract time information from the datetime module. We can create a timestamp by specifying datetime.time(hour,minute,second,microsecond)"
+    "Lets take a look at how we can extract time information from the datetime module. We can create a time-stamp by specifying datetime.time(hour,minute,second,microsecond)"
    ]
   },
   {
diff --git a/Decorators.ipynb b/Decorators.ipynb
index 1bad44f..48a0cdd 100644
--- a/Decorators.ipynb
+++ b/Decorators.ipynb
@@ -667,7 +667,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "So what just happened here? A decorator simple wrapped the function and modified its behaviour. Now lets understand how we can rewrite this code using the @ symbol, which is what Python uses for Decorators:"
+    "So what just happened here? A decorator simple wrapped the function and modified its behavior. Now lets understand how we can rewrite this code using the @ symbol, which is what Python uses for Decorators:"
    ]
   },
   {
diff --git a/Enumerate .ipynb b/Enumerate.ipynb
similarity index 100%
rename from Enumerate .ipynb
rename to Enumerate.ipynb
diff --git a/Errors and Exceptions Handling.ipynb b/Errors and Exceptions Handling.ipynb
index b766415..20381a5 100644
--- a/Errors and Exceptions Handling.ipynb	
+++ b/Errors and Exceptions Handling.ipynb	
@@ -6,7 +6,7 @@
    "source": [
     "#Errors and Exception Handling\n",
     "\n",
-    "In this lecture we will learn about Errors and Exception Handling in Python. You've definitely already encountered erros by this point in the course. For example:"
+    "In this lecture we will learn about Errors and Exception Handling in Python. You've definitely already encountered errors by this point in the course. For example:"
    ]
   },
   {
@@ -73,7 +73,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Content written succesfully\n"
+      "Content written successfully\n"
      ]
     }
    ],
@@ -82,10 +82,10 @@
     "    f = open('testfile','w')\n",
     "    f.write('Test write this')\n",
     "except IOError:\n",
-    "    # This will only check for an IOError exception and then excute this print statement\n",
+    "    # This will only check for an IOError exception and then execute this print statement\n",
     "   print \"Error: Could not find file or read data\"\n",
     "else:\n",
-    "   print \"Content written succesfully\"\n",
+    "   print \"Content written successfully\"\n",
     "   f.close()"
    ]
   },
@@ -116,10 +116,10 @@
     "    f = open('testfile','r')\n",
     "    f.write('Test write this')\n",
     "except IOError:\n",
-    "    # This will only check for an IOError exception and then excute this print statement\n",
+    "    # This will only check for an IOError exception and then execute this print statement\n",
     "   print \"Error: Could not find file or read data\"\n",
     "else:\n",
-    "   print \"Content written succesfully\"\n",
+    "   print \"Content written successfully\"\n",
     "   f.close()"
    ]
   },
@@ -152,10 +152,10 @@
     "    f = open('testfile','r')\n",
     "    f.write('Test write this')\n",
     "except:\n",
-    "    # This will check for any exception and then excute this print statement\n",
+    "    # This will check for any exception and then execute this print statement\n",
     "   print \"Error: Could not find file or read data\"\n",
     "else:\n",
-    "   print \"Content written succesfully\"\n",
+    "   print \"Content written successfully\"\n",
     "   f.close()"
    ]
   },
@@ -163,7 +163,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Great! Now we don't actually need to memorize that list of exception types! Now what if we kept wanting to run code after the exception occured? This is where **finally** comes in.\n",
+    "Great! Now we don't actually need to memorize that list of exception types! Now what if we kept wanting to run code after the exception occurred? This is where **finally** comes in.\n",
     "##finally\n",
     "The finally: block of code will always be run regardless if there was an exception in the try code block. The syntax is:\n",
     "\n",
@@ -404,7 +404,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "**Great! Now you know how to handle erros and exceptions in Python with the try, except, else, and finally notation!**"
+    "**Great! Now you know how to handle errors and exceptions in Python with the try, except, else, and finally notation!**"
    ]
   }
  ],
diff --git a/Errors and Exceptions Homework - Solution.ipynb b/Errors and Exceptions Homework - Solution.ipynb
index 69ae34e..06326ac 100644
--- a/Errors and Exceptions Homework - Solution.ipynb	
+++ b/Errors and Exceptions Homework - Solution.ipynb	
@@ -26,7 +26,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "An error ocurred!\n"
+      "An error occurred!\n"
      ]
     }
    ],
@@ -35,7 +35,7 @@
     "    for i in ['a','b','c']:\n",
     "        print i**2\n",
     "except:\n",
-    "    print \"An error ocurred!\""
+    "    print \"An error occurred!\""
    ]
   },
   {
@@ -95,7 +95,7 @@
     "        try:\n",
     "            n = input('Input an integer: ')\n",
     "        except:\n",
-    "            print 'An error occured! Please try again!'\n",
+    "            print 'An error occurred! Please try again!'\n",
     "            continue\n",
     "        else:\n",
     "            break\n",
@@ -116,7 +116,7 @@
      "output_type": "stream",
      "text": [
       "Input an integer: null\n",
-      "An error occured! Please try again!\n",
+      "An error occurred! Please try again!\n",
       "Input an integer: 2\n",
       "Thank you, you number squared is:  4\n"
      ]
diff --git a/Errors and Exceptions Homework .ipynb b/Errors and Exceptions Homework.ipynb
similarity index 98%
rename from Errors and Exceptions Homework .ipynb
rename to Errors and Exceptions Homework.ipynb
index 9d3e440..463032e 100644
--- a/Errors and Exceptions Homework .ipynb	
+++ b/Errors and Exceptions Homework.ipynb	
@@ -105,7 +105,7 @@
      "output_type": "stream",
      "text": [
       "Input an integer: null\n",
-      "An error occured! Please try again!\n",
+      "An error occurred! Please try again!\n",
       "Input an integer: 2\n",
       "Thank you, you number squared is:  4\n"
      ]
diff --git a/Files.ipynb b/Files.ipynb
index 8c135e4..829a7a4 100644
--- a/Files.ipynb
+++ b/Files.ipynb
@@ -146,7 +146,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "In order to not have to reset every time, we can also use the readlines method. Use this with caution ofr large files, since everything will be held in memory. We will learn how to iterate over large files later in the course."
+    "In order to not have to reset every time, we can also use the readlines method. Use caution with large files, since everything will be held in memory. We will learn how to iterate over large files later in the course."
    ]
   },
   {
diff --git a/Filter .ipynb b/Filter.ipynb
similarity index 97%
rename from Filter .ipynb
rename to Filter.ipynb
index 47f943c..da271ff 100644
--- a/Filter .ipynb	
+++ b/Filter.ipynb
@@ -91,7 +91,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Great! You hsould now have a solid understanding of filter() and how to apply it to your code!"
+    "Great! You should now have a solid understanding of filter() and how to apply it to your code!"
    ]
   }
  ],
diff --git a/For Loops .ipynb b/For Loops.ipynb
similarity index 93%
rename from For Loops .ipynb
rename to For Loops.ipynb
index fcdfd51..b99ef9e 100644
--- a/For Loops .ipynb	
+++ b/For Loops.ipynb	
@@ -6,7 +6,7 @@
    "source": [
     "#for Loops\n",
     "\n",
-    "A **for** loop acts as an iterator in Python, it goes through items that are in a *sequence* or any other iterable item. Objects that we've learned about that we can ietrate over include strings,lists,tuples, and even built in iterables for dictionaries, such as the keys or values.\n",
+    "A **for** loop acts as an iterator in Python, it goes through items that are in a *sequence* or any other iterable item. Objects that we've learned about that we can iterate over include strings,lists,tuples, and even built in iterables for dictionaries, such as the keys or values.\n",
     "\n",
     "We've already seen the **for** statement a little bit in past lectures but now lets formalize our understanding.\n",
     "\n",
@@ -21,9 +21,9 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The variable name used for the item is completely up to the coder, so use your best judgement for choosing a name that makes sense and you will be able to understand when revisiting your code. This item name can then be referenced inside you loop, for example if you wanted to use if statements to perform checks.\n",
+    "The variable name used for the item is completely up to the coder, so use your best judgment for choosing a name that makes sense and you will be able to understand when revisiting your code. This item name can then be referenced inside you loop, for example if you wanted to use if statements to perform checks.\n",
     "\n",
-    "Let's go ahead and work through several example of **for** loops using a varieyt of data object types. we'll start simple and build more complexity later on.\n",
+    "Let's go ahead and work through several example of **for** loops using a variety of data object types. we'll start simple and build more complexity later on.\n",
     "\n",
     "##Example 1\n",
     "Iterating through a list."
@@ -181,7 +181,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Notice that if a number is fuly divisble with no remainder, the result of the modulo call is 0. We can use this to test for even numbers, since if a number modulo 2 is equal to 0, that means it is an even number!\n",
+    "Notice that if a number is fully divisible with no remainder, the result of the modulo call is 0. We can use this to test for even numbers, since if a number modulo 2 is equal to 0, that means it is an even number!\n",
     "\n",
     "Back to the **for** loops!\n",
     "\n",
@@ -258,7 +258,7 @@
    "metadata": {},
    "source": [
     "## Example 3\n",
-    "Another common idea during a **for** loop is keeping some sort of running tally during the multiple loops. For exampl, lets create a for loop that sums up the list:"
+    "Another common idea during a **for** loop is keeping some sort of running tally during the multiple loops. For example, lets create a for loop that sums up the list:"
    ]
   },
   {
@@ -401,7 +401,7 @@
    "metadata": {},
    "source": [
     "## Example 6\n",
-    "Tuples have a special quality when it comes to **for** loops. If you are iterating through a seqeunce that contains tuples, the item can actually be the tuple itself, this is an example of *tuple unpacking*. During the **for** loop we will be unpacking the tuple inside of a sequence and we can access the individual items inside that tuple!"
+    "Tuples have a special quality when it comes to **for** loops. If you are iterating through a sequence that contains tuples, the item can actually be the tuple itself, this is an example of *tuple unpacking*. During the **for** loop we will be unpacking the tuple inside of a sequence and we can access the individual items inside that tuple!"
    ]
   },
   {
@@ -464,7 +464,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Cool! With tuples in a sequence we can access the items inside of them through unpacking! The reason this is important is beacause many object will deliver their iterables through tuples. Let's start exploring iterating through Dictionaries to explore this further!"
+    "Cool! With tuples in a sequence we can access the items inside of them through unpacking! The reason this is important is because many object will deliver their iterables through tuples. Let's start exploring iterating through Dictionaries to explore this further!"
    ]
   },
   {
@@ -617,7 +617,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "You might be wondering why this worked in Python 2. This is because of the introduction of generators to Python during its earlier years. (We will go over generators and what they are in a future section, but the basic notion is that generators don't store data in memory, but instead just yeild it to you as it goes through an iterable item).\n",
+    "You might be wondering why this worked in Python 2. This is because of the introduction of generators to Python during its earlier years. (We will go over generators and what they are in a future section, but the basic notion is that generators don't store data in memory, but instead just yield it to you as it goes through an iterable item).\n",
     "\n",
     "Originally, Python items() built a real list of tuples and returned that. That could potentially take a lot of extra memory.\n",
     "\n",
diff --git a/Functions.ipynb b/Functions.ipynb
index aedda2e..adc3776 100644
--- a/Functions.ipynb
+++ b/Functions.ipynb
@@ -38,7 +38,7 @@
    "source": [
     "def name_of_function(arg1,arg2):\n",
     "    '''\n",
-    "    This is where the function's Document String (docstring) goes\n",
+    "    This is where the function's Document String (doc-string) goes\n",
     "    '''\n",
     "    # Do stuff here\n",
     "    #return desired result"
@@ -50,11 +50,11 @@
    "source": [
     "We begin with def then a space followed by the name of the function. Try to keep names relevant, for example len() is a good name for a length() function. Also be careful with names, you wouldn't want to call a function the same name as a [built-in function in Python](https://docs.python.org/2/library/functions.html) (such as len).\n",
     "\n",
-    "Next come a pair of parenthesis with a number of arguments seperated by a comma. These arguments are the inputs for your function. You'll be able to use these inputs in your function and reference them. After this you put a colon.\n",
+    "Next come a pair of parenthesis with a number of arguments separated by a comma. These arguments are the inputs for your function. You'll be able to use these inputs in your function and reference them. After this you put a colon.\n",
     "\n",
     "Now here is the important step, you must indent to begin the code inside your function correctly. Python makes use of *whitespace* to organize code. Lots of other programing languages do not do this, so keep that in mind.\n",
     "\n",
-    "Next you'll see the docstring, this is where you write a basic description of the function. Using iPython and iPython Notebooks, you'll be ab;e to read these docstrings by pressing Shift+Tab after a function name. Doc strings are not necessary for simple functions, but its good practice to put them in so you or other people can easily understand the code you write.\n",
+    "Next you'll see the doc-string, this is where you write a basic description of the function. Using iPython and iPython Notebooks, you'll be ab;e to read these doc-strings by pressing Shift+Tab after a function name. Doc strings are not necessary for simple functions, but its good practice to put them in so you or other people can easily understand the code you write.\n",
     "\n",
     "After all this you begin writing the code you wish to execute.\n",
     "\n",
@@ -263,7 +263,7 @@
    "source": [
     "Finally lets go over a full example of creating a function to check if a number is prime ( a common interview exercise).\n",
     "\n",
-    "We know a number is prime if that number is only evenly divisble by 1 and itself. Let's write our first version of the function to check all the numbers from 1 to N and perform modulo checks."
+    "We know a number is prime if that number is only evenly divisible by 1 and itself. Let's write our first version of the function to check all the numbers from 1 to N and perform modulo checks."
    ]
   },
   {
@@ -309,7 +309,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Note how we break the code after the print statement! We can actually improve this by only checking to the square root of the target number, also we can disregard all even numbers after checking for 2. We'll also switch to returning a boolean value to get an exaple of using return statements:"
+    "Note how we break the code after the print statement! We can actually improve this by only checking to the square root of the target number, also we can disregard all even numbers after checking for 2. We'll also switch to returning a boolean value to get an example of using return statements:"
    ]
   },
   {
diff --git a/GUI/1 - Interact.ipynb b/GUI/1 - Interact.ipynb
index 9ecc48d..420f9d5 100644
--- a/GUI/1 - Interact.ipynb	
+++ b/GUI/1 - Interact.ipynb	
@@ -36,7 +36,7 @@
    "metadata": {},
    "source": [
     "<div class=\"alert alert-success\">\n",
-    "Please Note! The widgets in this notebook won't show up on NbViewer or GitHub renderings . To view the widgets and interact with them, you will need to download this notebook and run it with a Jupyter Notebook server.\n",
+    "Please Note! The widgets in this notebook won't show up on NbViewer or GitHub renderings. To view the widgets and interact with them, you will need to download this notebook and run it with a Jupyter Notebook server.\n",
     "\n",
     "</div>"
    ]
@@ -52,7 +52,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "At the most basic level, `interact` autogenerates UI controls for function arguments, and then calls the function with those arguments when you manipulate the controls interactively. To use `interact`, you need to define a function that you want to explore. Here is a function that prints its only argument `x`."
+    "At the most basic level, `interact` auto-generates UI controls for function arguments, and then calls the function with those arguments when you manipulate the controls interactively. To use `interact`, you need to define a function that you want to explore. Here is a function that prints its only argument `x`."
    ]
   },
   {
@@ -103,7 +103,7 @@
    "source": [
     "When you move the slider, the function is called, which prints the current value of `x`.\n",
     "\n",
-    "If you pass `True` or `False`, `interact` will generate a checkbox:"
+    "If you pass `True` or `False`, `interact` will generate a check-box:"
    ]
   },
   {
@@ -124,7 +124,7 @@
     }
    ],
    "source": [
-    "# Booleans generate checkboxes\n",
+    "# Booleans generate check-boxes\n",
     "interact(f, x=True);"
    ]
   },
@@ -296,7 +296,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "This examples clarifies how `interact` proceses its keyword arguments:\n",
+    "This examples clarifies how `interact` process its keyword arguments:\n",
     "\n",
     "1. If the keyword argument is a `Widget` instance with a `value` attribute, that widget is used. Any widget with a `value` attribute can be used, even custom ones.\n",
     "2. Otherwise, the value is treated as a *widget abbreviation* that is converted to a widget before it is used.\n",
@@ -317,7 +317,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "You have seen how the checkbox and textarea widgets work above. Here, more details about the different abbreviations for sliders and dropdowns are given.\n",
+    "You have seen how the check-box and text-area widgets work above. Here, more details about the different abbreviations for sliders and drop-downs are given.\n",
     "\n",
     "If a 2-tuple of integers is passed `(min,max)`, an integer-valued slider is produced with those minimum and maximum values (inclusively). In this case, the default step size of `1` is used."
    ]
@@ -463,7 +463,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Dropdown menus are constructed by passing a tuple of strings. In this case, the strings are both used as the names in the dropdown menu UI and passed to the underlying Python function."
+    "Dropdown menus are constructed by passing a tuple of strings. In this case, the strings are both used as the names in the drop-down menu UI and passed to the underlying Python function."
    ]
   },
   {
@@ -491,7 +491,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "If you want a dropdown menu that passes non-string values to the Python function, you can pass a dictionary. The keys in the dictionary are used for the names in the dropdown menu UI and the values are the arguments that are passed to the underlying Python function."
+    "If you want a drop-down menu that passes non-string values to the Python function, you can pass a dictionary. The keys in the dictionary are used for the names in the drop-down menu UI and the values are the arguments that are passed to the underlying Python function."
    ]
   },
   {
diff --git a/GUI/2 - Widget Basics.ipynb b/GUI/2 - Widget Basics.ipynb
index 291374c..e40bb1f 100644
--- a/GUI/2 - Widget Basics.ipynb	
+++ b/GUI/2 - Widget Basics.ipynb	
@@ -24,7 +24,7 @@
     }
    },
    "source": [
-    "Widgets are eventful python objects that have a representation in the browser, often as a control like a slider, textbox, etc."
+    "Widgets are eventful python objects that have a representation in the browser, often as a control like a slider, text-box, etc."
    ]
   },
   {
@@ -150,7 +150,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "If you display the same widget twice, the displayed instances in the front-end will remain in sync with each other.  Try dragging the slider below and watch the slider above."
+    "If you display the same widget twice, the displayed instances in the front-end will remain in sync with each other. Try dragging the slider below and watch the slider above."
    ]
   },
   {
@@ -219,7 +219,7 @@
     }
    },
    "source": [
-    "All of the IPython widgets share a similar naming scheme.  To read the value of a widget, you can query its `value` property."
+    "All of the IPython widgets share a similar naming scheme. To read the value of a widget, you can query its `value` property."
    ]
   },
   {
@@ -289,7 +289,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "In addition to `value`, most widgets share `keys`, `description`, `disabled`, and `visible`.  To see the entire list of synchronized, stateful properties of any specific widget, you can query the `keys` property."
+    "In addition to `value`, most widgets share `keys`, `description`, `disabled`, and `visible`. To see the entire list of synchronized, stateful properties of any specific widget, you can query the `keys` property."
    ]
   },
   {
@@ -390,7 +390,7 @@
     }
    },
    "source": [
-    "If you need to display the same value two different ways, you'll have to use two different widgets.  Instead of attempting to manually synchronize the values of the two widgets, you can use the `traitlet` `link` function to link two properties together.  Below, the values of two widgets are linked together."
+    "If you need to display the same value two different ways, you'll have to use two different widgets. Instead of attempting to manually synchronize the values of the two widgets, you can use the `traitlet` `link` function to link two properties together.  Below, the values of two widgets are linked together."
    ]
   },
   {
@@ -424,7 +424,7 @@
     }
    },
    "source": [
-    "Unlinking the widgets is simple.  All you have to do is call `.unlink` on the link object.  Try changing one of the widgets above after unlinking to see that they can be independently changed."
+    "Unlinking the widgets is simple.  All you have to do is call `.unlink` on the link object. Try changing one of the widgets above after unlinking to see that they can be independently changed."
    ]
   },
   {
@@ -444,7 +444,7 @@
    "source": [
     "# Conclusion\n",
     "\n",
-    "You should now be beginning to have an understanding of how Widgets can interact with eachother and how you can begin to specify widget details."
+    "You should now be beginning to have an understanding of how Widgets can interact with each other and how you can begin to specify widget details."
    ]
   }
  ],
diff --git a/GUI/3 - Widget Events.ipynb b/GUI/3 - Widget Events.ipynb
index 00643f1..fb69fff 100644
--- a/GUI/3 - Widget Events.ipynb	
+++ b/GUI/3 - Widget Events.ipynb	
@@ -35,7 +35,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The `Button` is not used to represent a data type.  Instead the button widget is used to handle mouse clicks.  The `on_click` method of the `Button` can be used to register function to be called when the button is clicked.  The doc string of the `on_click` can be seen below."
+    "The `Button` is not used to represent a data type. Instead the button widget is used to handle mouse clicks. The `on_click` method of the `Button` can be used to register function to be called when the button is clicked. The doc string of the `on_click` can be seen below."
    ]
   },
   {
@@ -81,7 +81,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Since button clicks are stateless, they are transmitted from the front-end to the back-end using custom messages.  By using the `on_click` method, a button that prints a message when it has been clicked is shown below."
+    "Since button clicks are stateless, they are transmitted from the front-end to the back-end using custom messages. By using the `on_click` method, a button that prints a message when it has been clicked is shown below."
    ]
   },
   {
@@ -130,7 +130,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The `Text` widget also has a special `on_submit` event.  The `on_submit` event fires when the user hits return."
+    "The `Text` widget also has a special `on_submit` event. The `on_submit` event fires when the user hits return."
    ]
   },
   {
@@ -174,7 +174,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Widget properties are IPython traitlets and traitlets are eventful.  To handle  changes, the `on_trait_change` method of the widget can be used to register a callback.  The doc string for `on_trait_change` can be seen below."
+    "Widget properties are IPython traitlets and traitlets are eventful. To handle changes, the `on_trait_change` method of the widget can be used to register a callback.  The doc string for `on_trait_change` can be seen below."
    ]
   },
   {
diff --git a/GUI/4 - Widget List.ipynb b/GUI/4 - Widget List.ipynb
index a356456..5819786 100644
--- a/GUI/4 - Widget List.ipynb	
+++ b/GUI/4 - Widget List.ipynb	
@@ -24,7 +24,7 @@
     }
    },
    "source": [
-    "For a complete list of the GUI widgets available to you, you can list the registered widget types.  `Widget` and `DOMWidget`, not listed below, are base classes."
+    "For a complete list of the GUI widgets available to you, you can list the registered widget types. `Widget` and `DOMWidget`, not listed below, are base classes."
    ]
   },
   {
@@ -99,7 +99,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "There are 8 widgets distributed with IPython that are designed to display numeric values.  Widgets exist for displaying integers and floats, both bounded and unbounded.  The integer widgets share a similar naming scheme to their floating point counterparts.  By replacing `Float` with `Int` in the widget name, you can find the Integer equivalent."
+    "There are 8 widgets distributed with IPython that are designed to display numeric values. Widgets exist for displaying integers and floats, both bounded and unbounded.  The integer widgets share a similar naming scheme to their floating point counterparts. By replacing `Float` with `Int` in the widget name, you can find the Integer equivalent."
    ]
   },
   {
@@ -336,7 +336,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "There are four widgets that can be used to display single selection lists, and one that can be used to display multiple selection lists.  All inherit from the same base class.  You can specify the **enumeration of selectable options by passing a list**.  You can **also specify the enumeration as a dictionary**, in which case the **keys will be used as the item displayed** in the list and the corresponding **value will be returned** when an item is selected."
+    "There are four widgets that can be used to display single selection lists, and one that can be used to display multiple selection lists. All inherit from the same base class. You can specify the **enumeration of selectable options by passing a list**. You can **also specify the enumeration as a dictionary**, in which case the **keys will be used as the item displayed** in the list and the corresponding **value will be returned** when an item is selected."
    ]
   },
   {
@@ -560,7 +560,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "There are 4 widgets that can be used to display a string value.  Of those, the `Text` and `Textarea` widgets accept input.  The `Latex` and `HTML` widgets display the string as either Latex or HTML respectively, but do not accept input."
+    "There are 4 widgets that can be used to display a string value. Of those, the `Text` and `Textarea` widgets accept input. The `Latex` and `HTML` widgets display the string as either Latex or HTML respectively, but do not accept input."
    ]
   },
   {
diff --git a/GUI/5 - Widget Styling.ipynb b/GUI/5 - Widget Styling.ipynb
index d4fda70..dbf40f5 100644
--- a/GUI/5 - Widget Styling.ipynb	
+++ b/GUI/5 - Widget Styling.ipynb	
@@ -118,7 +118,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "To display widget A inside widget B, widget A must be a child of widget B.  Widgets that can contain other widgets have a `children` attribute.  This attribute can be set via a keyword argument in the widget's constructor or after construction.  Calling display on an object with children automatically displays the children."
+    "To display widget A inside widget B, widget A must be a child of widget B. Widgets that can contain other widgets have a `children` attribute. This attribute can be set via a keyword argument in the widget's constructor or after construction. Calling display on an object with children automatically displays the children."
    ]
   },
   {
@@ -156,7 +156,7 @@
     }
    },
    "source": [
-    "Children can be added to parents after the parent has been displayed.  The parent is responsible for rendering its children."
+    "Children can be added to parents after the parent has been displayed. The parent is responsible for rendering its children."
    ]
   },
   {
@@ -192,7 +192,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "If you need to display a more complicated set of widgets, there are specialized containers that you can use.  To display multiple sets of widgets, you can use an `Accordion` or a `Tab` in combination with one `Box` per set of widgets (as seen below).  The \"pages\" of these widgets are their children.  To set the titles of the pages, use `set_title`."
+    "If you need to display a more complicated set of widgets, there are specialized containers that you can use. To display multiple sets of widgets, you can use an `Accordion` or a `Tab` in combination with one `Box` per set of widgets (as seen below). The \"pages\" of these widgets are their children.  To set the titles of the pages, use `set_title`."
    ]
   },
   {
@@ -435,7 +435,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The `visible` property of widgets can be used to hide or show widgets that have already been displayed (as seen below).  The `visible` property can be:\n",
+    "The `visible` property of widgets can be used to hide or show widgets that have already been displayed (as seen below). The `visible` property can be:\n",
     "* `True` - the widget is displayed\n",
     "* `False` - the widget is hidden, and the empty space where the widget would be is collapsed\n",
     "* `None` - the widget is hidden, and the empty space where the widget would be is shown"
@@ -503,7 +503,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "In the example below, a form is rendered, which conditionally displays widgets depending on the state of other widgets.  Try toggling the student checkbox."
+    "In the example below, a form is rendered, which conditionally displays widgets depending on the state of other widgets. Try toggling the student check-box."
    ]
   },
   {
diff --git a/If, elif, and else Statements .ipynb b/If, elif, and else Statements.ipynb
similarity index 97%
rename from If, elif, and else Statements .ipynb
rename to If, elif, and else Statements.ipynb
index 62abadd..6628e9e 100644
--- a/If, elif, and else Statements .ipynb	
+++ b/If, elif, and else Statements.ipynb	
@@ -94,7 +94,7 @@
     "\n",
     "Let's get a fuller picture of how far if, elif, and else can take us!\n",
     "\n",
-    "We write this out in a nested strucutre. Take note of how the if,elif,and else line up in the code. This can help you see what if is related to what elif or else statements.\n",
+    "We write this out in a nested structure. Take note of how the if,elif,and else line up in the code. This can help you see what if is related to what elif or else statements.\n",
     "\n",
     "We'll reintroduce a comparison syntax for Python."
    ]
@@ -190,7 +190,7 @@
    "source": [
     "##Indentation\n",
     "\n",
-    "It is important to keep a good understanding of how indentation works in Python to maintain the strucutre and order of your code. We will touch on this topic again when we start building out functions!"
+    "It is important to keep a good understanding of how indentation works in Python to maintain the structure and order of your code. We will touch on this topic again when we start building out functions!"
    ]
   },
   {
diff --git a/Introduction to Python Statements.ipynb b/Introduction to Python Statements.ipynb
index c8dc791..fbd6e13 100644
--- a/Introduction to Python Statements.ipynb	
+++ b/Introduction to Python Statements.ipynb	
@@ -63,7 +63,7 @@
     "\n",
     "## Indentation\n",
     "\n",
-    "Here is some pseudocode to indicate the use of whitespace and indentation in Python:\n",
+    "Here is some pseudo-code to indicate the use of whitespace and indentation in Python:\n",
     "\n",
     "**Other Languages**\n",
     "\n",
diff --git a/Iterators and Generators Homework - Solution.ipynb b/Iterators and Generators Homework - Solution.ipynb
index b7bd955..f95bb77 100644
--- a/Iterators and Generators Homework - Solution.ipynb	
+++ b/Iterators and Generators Homework - Solution.ipynb	
@@ -210,7 +210,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Hint google: generator comprehnsion is!\n",
+    "Hint google: generator comprehension is!\n",
     "\n",
     "#Great Job!"
    ]
diff --git a/Iterators and Generators Homework.ipynb b/Iterators and Generators Homework.ipynb
index 3d3250f..ac513f8 100644
--- a/Iterators and Generators Homework.ipynb	
+++ b/Iterators and Generators Homework.ipynb	
@@ -169,7 +169,7 @@
    "metadata": {},
    "source": [
     "### Extra Credit!\n",
-    "Can you explain what *gencomp* is in the code below? (Note: We never covered this in lecture! You will hve to do some googling/Stack Overflowing!)"
+    "Can you explain what *gencomp* is in the code below? (Note: We never covered this in lecture! You will have to do some googling/Stack Overflowing!)"
    ]
   },
   {
diff --git a/Lambda expressions .ipynb b/Lambda expressions.ipynb
similarity index 99%
rename from Lambda expressions .ipynb
rename to Lambda expressions.ipynb
index 9a3ab7b..8722288 100644
--- a/Lambda expressions .ipynb	
+++ b/Lambda expressions.ipynb	
@@ -355,7 +355,7 @@
    "metadata": {},
    "source": [
     "##Example 4\n",
-    "Just like a normal function, we can accept more than one function into a lambda expresssion:"
+    "Just like a normal function, we can accept more than one function into a lambda expression:"
    ]
   },
   {
diff --git a/List Comprehensions.ipynb b/List Comprehensions.ipynb
index f4c10df..bd61977 100644
--- a/List Comprehensions.ipynb	
+++ b/List Comprehensions.ipynb	
@@ -165,7 +165,7 @@
     "# Convert Celsius to Fahrenheit\n",
     "celsius = [0,10,20.1,34.5]\n",
     "\n",
-    "fahrenheit = [ ((float(9)/5)*temp + 32) for temp in celsius ]\n",
+    "fahrenheit = [ ((float(9)/5)*temp + 32) for temp in Celsius ]\n",
     "\n",
     "fahrenheit"
    ]
diff --git a/Lists.ipynb b/Lists.ipynb
index 633c406..94a5284 100644
--- a/Lists.ipynb
+++ b/Lists.ipynb
@@ -16,7 +16,7 @@
     "    4.) Nesting Lists\n",
     "    5.) Introduction to List Comprehensions\n",
     "\n",
-    "Lists are constructed with brackets [] and commas seperating every element in the list.\n",
+    "Lists are constructed with brackets [] and commas separating every element in the list.\n",
     "\n",
     "Let's go ahead and see how we can construct lists!"
    ]
@@ -55,7 +55,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Just like strings, the len() frunction will tell you how many items are in the sequence of the list."
+    "Just like strings, the len() function will tell you how many items are in the sequence of the list."
    ]
   },
   {
@@ -753,7 +753,7 @@
    "metadata": {},
    "source": [
     "# List Comprehensions\n",
-    "Python has an advanced feature called list comprehensions. They allow for quick construction of lists. To fully understand list comprehensions we need to understand for loops. So don't worry if you don't completely understand this section, and feel free to just skip it since we wil return to this topic later.\n",
+    "Python has an advanced feature called list comprehensions. They allow for quick construction of lists. To fully understand list comprehensions we need to understand for loops. So don't worry if you don't completely understand this section, and feel free to just skip it since we will return to this topic later.\n",
     "\n",
     "But in case you want to know now, here are a few examples!"
    ]
diff --git a/Map .ipynb b/Map.ipynb
similarity index 94%
rename from Map .ipynb
rename to Map.ipynb
index 96ed7bf..d376d2b 100644
--- a/Map .ipynb	
+++ b/Map.ipynb
@@ -11,7 +11,7 @@
     "    \n",
     "The first argument is the name of a function and the second a sequence (e.g. a list). map() applies the function to all the elements of the sequence. It returns a new list with the elements changed by function.\n",
     "\n",
-    "When we went over list copmrehension we created a small expression to convert fahrenheit to celcius. Let's do the same here but use map.\n",
+    "When we went over list comprehension we created a small expression to convert Fahrenheit to Celsius. Let's do the same here but use map.\n",
     "\n",
     "We'll start with two functions:"
    ]
@@ -58,7 +58,7 @@
     }
    ],
    "source": [
-    "F_temps = map(fahrenheit, temp)\n",
+    "F_temps = map(Fahrenheit, temp)\n",
     "\n",
     "#Show\n",
     "F_temps"
@@ -190,7 +190,7 @@
    "source": [
     "We can see in the example above that the parameter x gets its values from the list a, while y gets its values from b and z from list c. Go ahead and play with your own example to make sure you fully understand mapping to more than one iterable.\n",
     "\n",
-    "Great job! You should now have a bsic understanding of the map() function."
+    "Great job! You should now have a basic understanding of the map() function."
    ]
   }
  ],
diff --git a/Methods.ipynb b/Methods.ipynb
index d0292ee..e8ef8d5 100644
--- a/Methods.ipynb
+++ b/Methods.ipynb
@@ -8,7 +8,7 @@
     "\n",
     "We've already seen a few example of methods when learning about Object and Data Structure Types in Python. Methods are essentially functions built into objects. Later on in the course we will learn about how to create our own objects and methods using Object Oriented Programming (OOP) and classes.\n",
     "\n",
-    "Methods will perform specific actions on the object and can also take arguments, just like a function. This lecture will serve as just a bried introduction to methods and get you thinking about overall design methods that we will touch back upon when we reach OOP in the course.\n",
+    "Methods will perform specific actions on the object and can also take arguments, just like a function. This lecture will serve as just a brief introduction to methods and get you thinking about overall design methods that we will touch back upon when we reach OOP in the course.\n",
     "\n",
     "Methods are in the form:\n",
     "\n",
@@ -93,7 +93,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Great! Now how about count()? The count() method will count the number of occurences of an element in a list."
+    "Great! Now how about count()? The count() method will count the number of occurrences of an element in a list."
    ]
   },
   {
@@ -153,7 +153,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Feel free to play around with the rest of the methods for a list. Later on in this section your quiz will involve using help and google searching for methods of different types of objects!"
+    "Feel free to play around with the rest of the methods for a list. Later on in this section your quiz will involve using help and Google searching for methods of different types of objects!"
    ]
   },
   {
diff --git a/Milestone Project 1 - Advanced Solution.ipynb b/Milestone Project 1 - Advanced Solution.ipynb
index 0af4d2f..cb7e483 100644
--- a/Milestone Project 1 - Advanced Solution.ipynb	
+++ b/Milestone Project 1 - Advanced Solution.ipynb	
@@ -117,7 +117,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Define function to check if the board is already full in case of a tie. (This is straightfoward with our board stored as a list)\n",
+    "Define function to check if the board is already full in case of a tie. (This is straightforward with our board stored as a list)\n",
     "Just remember index 0 is always empty."
    ]
   },
diff --git a/Milestone Project 1- Assignment.ipynb b/Milestone Project 1- Assignment.ipynb
index afa47f3..8f62067 100644
--- a/Milestone Project 1- Assignment.ipynb	
+++ b/Milestone Project 1- Assignment.ipynb	
@@ -21,11 +21,11 @@
     "There are 4 Jupyter Notebooks related to this assignment:\n",
     "\n",
     "* This Assignment Notebook\n",
-    "* A \"Walkthrough Steps Workbook\" Notebook\n",
-    "* A \"Walkthrough Solution\" Notebook\n",
+    "* A \"Walk-through Steps Workbook\" Notebook\n",
+    "* A \"Walk-through Solution\" Notebook\n",
     "* An \"Advanced Solution\" Notebook\n",
     "\n",
-    "I encourage you to just try to start the project on your own without referencing any of the notebooks. If you get stuck, check out the next lecture which is a text lecture with helpful hints and steps. If you're still stuck after that, then check out the Walkthrough Steps Workbook, which breaks up the project in steps for you to solve. Still stuck? Then check out the walkthrough solution video for more help on approaching the project!"
+    "I encourage you to just try to start the project on your own without referencing any of the notebooks. If you get stuck, check out the next lecture which is a text lecture with helpful hints and steps. If you're still stuck after that, then check out the walk-through Steps Workbook, which breaks up the project in steps for you to solve. Still stuck? Then check out the walk-through solution video for more help on approaching the project!"
    ]
   },
   {
diff --git a/Milestone Project 1- Complete Walkthrough Solution.ipynb b/Milestone Project 1- Complete Walkthrough Solution.ipynb
index 740ce1b..83716d9 100644
--- a/Milestone Project 1- Complete Walkthrough Solution.ipynb	
+++ b/Milestone Project 1- Complete Walkthrough Solution.ipynb	
@@ -4,9 +4,9 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Milestone Project 1: Full Walkthrough Code Solution\n",
+    "# Milestone Project 1: Full Walk-through Code Solution\n",
     "\n",
-    "Below is the filled in code that goes along with the complete walkthrough video. Check out the corresponding lecture videos for more information on this code!"
+    "Below is the filled in code that goes along with the complete walk-through video. Check out the corresponding lecture videos for more information on this code!"
    ]
   },
   {
@@ -121,7 +121,7 @@
     "    return ((board[7] == mark and board[8] == mark and board[9] == mark) or # across the top\n",
     "    (board[4] == mark and board[5] == mark and board[6] == mark) or # across the middle\n",
     "    (board[1] == mark and board[2] == mark and board[3] == mark) or # across the bottom\n",
-    "    (board[7] == mark and board[4] == mark and board[1] == mark) or # down themarkft side\n",
+    "    (board[7] == mark and board[4] == mark and board[1] == mark) or # down the middle\n",
     "    (board[8] == mark and board[5] == mark and board[2] == mark) or # down the middle\n",
     "    (board[9] == mark and board[6] == mark and board[3] == mark) or # down the right side\n",
     "    (board[7] == mark and board[5] == mark and board[3] == mark) or # diagonal\n",
@@ -294,7 +294,7 @@
     "\n",
     "            if win_check(theBoard, player1_marker):\n",
     "                display_board(theBoard)\n",
-    "                print('Congratualtions! You have won the game!')\n",
+    "                print('Congratulations! You have won the game!')\n",
     "                game_on = False\n",
     "            else:\n",
     "                if full_board_check(theBoard):\n",
diff --git a/Milestone Project 1- Walkthrough Steps Workbook.ipynb b/Milestone Project 1- Walkthrough Steps Workbook.ipynb
index 900506b..0c48b91 100644
--- a/Milestone Project 1- Walkthrough Steps Workbook.ipynb	
+++ b/Milestone Project 1- Walkthrough Steps Workbook.ipynb	
@@ -4,7 +4,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Milestone Project 1: Walkthrough Steps Workbook\n",
+    "# Milestone Project 1: Walk-through Steps Workbook\n",
     "\n",
     "Below is a set of steps for you to follow to try to create the Tic Tac Toe Milestone Project game!"
    ]
diff --git a/Milestone Project 2 - Assignment.ipynb b/Milestone Project 2 - Assignment.ipynb
index 23a6b1a..94c9550 100644
--- a/Milestone Project 2 - Assignment.ipynb	
+++ b/Milestone Project 2 - Assignment.ipynb	
@@ -13,8 +13,8 @@
     "* The game needs to have one player versus an automated dealer.\n",
     "* The player can stand or hit.\n",
     "* The player must be able to pick their betting amount.\n",
-    "* You need to keep track fo the players total money.\n",
-    "* You need to alert the player of wins,losses, or busts, etc...\n",
+    "* You need to keep track of the players total money.\n",
+    "* You need to alert the player of wins, losses, or busts, etc...\n",
     "\n",
     "And most importantly:\n",
     "\n",
diff --git a/Modules and Packages.ipynb b/Modules and Packages.ipynb
index eda7844..5f9be2e 100644
--- a/Modules and Packages.ipynb	
+++ b/Modules and Packages.ipynb	
@@ -136,7 +136,7 @@
     "Writing Python modules is very simple. To create a module of your own, simply create a new .py file with the module name, and then import it using the Python file name (without the .py extension) using the import command.\n",
     "\n",
     "## Writing packages\n",
-    "Packages are namespaces which contain multiple packages and modules themselves. They are simply directories, but with a twist.\n",
+    "Packages are name-spaces which contain multiple packages and modules themselves. They are simply directories, but with a twist.\n",
     "\n",
     "Each package in Python is a directory which MUST contain a special file called **\\__init\\__.py**. This file can be empty, and it indicates that the directory it contains is a Python package, so it can be imported the same way a module can be imported.\n",
     "\n",
@@ -173,7 +173,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "In the first method, we must use the foo prefix whenever we access the module bar. In the second method, we don't, because we import the module to our module's namespace.\n",
+    "In the first method, we must use the foo prefix whenever we access the module bar. In the second method, we don't, because we import the module to our module's name-space.\n",
     "\n",
     "The **\\__init\\__.py** file can also decide which modules the package exports as the API, while keeping other modules internal, by overriding the **\\__all\\__** variable, like so:"
    ]
diff --git a/Nested Statements and Scope.ipynb b/Nested Statements and Scope.ipynb
index 38978d1..b06080e 100644
--- a/Nested Statements and Scope.ipynb	
+++ b/Nested Statements and Scope.ipynb	
@@ -6,7 +6,7 @@
    "source": [
     "#Nested Statements and Scope \n",
     "\n",
-    "Now that we have gone over on writing our own functions, its important to understand how Python deals with the variable names you assign. When you create a variable name in Python the name is stored in a *namespace*. Variable names also have a *scope*, the scope determines the visbility of that variable name to other parts of your code.\n",
+    "Now that we have gone over on writing our own functions, its important to understand how Python deals with the variable names you assign. When you create a variable name in Python the name is stored in a *name-space*. Variable names also have a *scope*, the scope determines the visibility of that variable name to other parts of your code.\n",
     "\n",
     "Lets start with a quick thought experiment, imagine the following code:"
    ]
@@ -78,7 +78,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Interesting! But how does Python know which **x** you're referring to in your code? This is where the idea of scope comes in. Python has a set of rules it follows to decide what variables (such as x in this case) you are refrencing in your code. Lets break down the rules:"
+    "Interesting! But how does Python know which **x** you're referring to in your code? This is where the idea of scope comes in. Python has a set of rules it follows to decide what variables (such as x in this case) you are referencing in your code. Lets break down the rules:"
    ]
   },
   {
diff --git a/Numbers.ipynb b/Numbers.ipynb
index b901e0d..eb0871e 100644
--- a/Numbers.ipynb
+++ b/Numbers.ipynb
@@ -155,7 +155,7 @@
    "source": [
     "### <font color='red'>Python 3 Alert!</font>\n",
     "\n",
-    "**Woah! What just happened? Last time I checked, 3 divided by 2 is equal 1.5 not 1!**\n",
+    "**Whoa! What just happened? Last time I checked, 3 divided by 2 is equal 1.5 not 1!**\n",
     "\n",
     "The reason we get this result is because we are using Python 2. In Python 2, the / symbol performs what is known as \"*classic*\" division, this means that the decimal points are truncated (cut off). In Python 3 however, a single / performs \"*true*\" division. So you would get 1.5 if you had inputed 3/2 in Python 3.\n",
     "\n",
@@ -280,7 +280,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "When you import division from the __future__ you won't need to worry about classic division occuring anymore anywhere in your code!"
+    "When you import division from the __future__ you won't need to worry about classic division occurring anymore anywhere in your code!"
    ]
   },
   {
diff --git a/Object Oriented Programming.ipynb b/Object Oriented Programming.ipynb
index 0812cac..43f523a 100644
--- a/Object Oriented Programming.ipynb	
+++ b/Object Oriented Programming.ipynb	
@@ -12,7 +12,7 @@
     "\n",
     "There are many,many tutorials and lessons covering OOP so feel free to Google search other lessons, and I have also put some links to other useful tutorials online at the bottom of this Notebook.\n",
     "\n",
-    "For this lesson we will construct our knowledege of OOP in Python by building on the following topics:\n",
+    "For this lesson we will construct our knowledge of OOP in Python by building on the following topics:\n",
     "\n",
     "* Objects\n",
     "* Using the *class* keyword\n",
@@ -140,7 +140,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "By convention we give classes a name that starts with a capital letter. Note how x is now the reference to our new instance of a Sample class. In other words, we **instanciate** the Sample class.\n",
+    "By convention we give classes a name that starts with a capital letter. Note how x is now the reference to our new instance of a Sample class. In other words, we **instantiate** the Sample class.\n",
     "\n",
     "Inside of the class we currently just have pass. But we can define class attributes and methods.\n",
     "\n",
@@ -367,7 +367,7 @@
     "class Circle(object):\n",
     "    pi = 3.14\n",
     "\n",
-    "    # Circle get instantiaed with a radius (default is 1)\n",
+    "    # Circle get instantiated with a radius (default is 1)\n",
     "    def __init__(self, radius=1):\n",
     "        self.radius = radius \n",
     "\n",
@@ -401,7 +401,7 @@
     "\n",
     "Inheritance is a way to form new classes using classes that have already been defined. The newly formed classes are called derived classes, the classes that we derive from are called base classes. Important benefits of inheritance are code reuse and reduction of complexity of a program. The derived classes (descendants) override or extend the functionality of base classes (ancestors).\n",
     "\n",
-    "Lets see an example by incorporating our rpevious work on the Dog class:"
+    "Lets see an example by incorporating our previous work on the Dog class:"
    ]
   },
   {
@@ -522,7 +522,7 @@
     "\n",
     "* It is shown by the eat() method. \n",
     "\n",
-    "The derived class modifies existing behaviour of the base class.\n",
+    "The derived class modifies existing behavior of the base class.\n",
     "\n",
     "* shown by the whoAmI() method. \n",
     "\n",
diff --git a/Objects and Data Structures Assessment Test-Solution.ipynb b/Objects and Data Structures Assessment Test-Solution.ipynb
index d24a688..5a469d3 100644
--- a/Objects and Data Structures Assessment Test-Solution.ipynb	
+++ b/Objects and Data Structures Assessment Test-Solution.ipynb	
@@ -13,7 +13,7 @@
     "collapsed": true
    },
    "source": [
-    "## Test your knowledege. \n",
+    "## Test your knowledge. \n",
     "\n",
     "** Answer the following questions **"
    ]
@@ -111,7 +111,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "**Answer: Because Python 2 performs classic division for integers. Use floats to perform true divsion. For example:\n",
+    "**Answer: Because Python 2 performs classic division for integers. Use floats to perform true division. For example:\n",
     "2.0/3**"
    ]
   },
@@ -270,7 +270,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Given the string 'hello' give an index commadn that returns 'e'. Use the code below:"
+    "Given the string 'hello' give an index command that returns 'e'. Use the code below:"
    ]
   },
   {
@@ -688,7 +688,7 @@
    "outputs": [],
    "source": [
     "# This will be hard and annoying!\n",
-    "d = {'k1':[1,2,{'k2':['this is tricky',{'toughie':[1,2,['hello']]}]}]}"
+    "d = {'k1':[1,2,{'k2':['this is tricky',{'tough':[1,2,['hello']]}]}]}"
    ]
   },
   {
@@ -711,7 +711,7 @@
    ],
    "source": [
     "# Phew\n",
-    "d['k1'][2]['k2'][1]['toughie'][2][0]"
+    "d['k1'][2]['k2'][1]['tough'][2][0]"
    ]
   },
   {
@@ -739,7 +739,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "What is the major difference betwen tuples and lists?"
+    "What is the major difference between tuples and lists?"
    ]
   },
   {
diff --git a/Objects and Data Structures Assessment Test.ipynb b/Objects and Data Structures Assessment Test.ipynb
index 36d77fd..f96a009 100644
--- a/Objects and Data Structures Assessment Test.ipynb	
+++ b/Objects and Data Structures Assessment Test.ipynb	
@@ -13,7 +13,7 @@
     "collapsed": true
    },
    "source": [
-    "## Test your knowledege. \n",
+    "## Test your knowledge. \n",
     "\n",
     "** Answer the following questions **"
    ]
@@ -141,7 +141,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Given the string 'hello' give an index commadn that returns 'e'. Use the code below:"
+    "Given the string 'hello' give an index command that returns 'e'. Use the code below:"
    ]
   },
   {
@@ -213,7 +213,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Build this list [0,0,0] two seperate ways."
+    "Build this list [0,0,0] two separate ways."
    ]
   },
   {
@@ -322,7 +322,7 @@
    "outputs": [],
    "source": [
     "# This will be hard and annoying!\n",
-    "d = {'k1':[1,2,{'k2':['this is tricky',{'toughie':[1,2,['hello']]}]}]}"
+    "d = {'k1':[1,2,{'k2':['this is tricky',{'tough':[1,2,['hello']]}]}]}"
    ]
   },
   {
@@ -348,7 +348,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "What is the major difference betwen tuples and lists?"
+    "What is the major difference between tuples and lists?"
    ]
   },
   {
diff --git a/Print Formatting.ipynb b/Print Formatting.ipynb
index 9360604..eddc812 100644
--- a/Print Formatting.ipynb	
+++ b/Print Formatting.ipynb	
@@ -166,7 +166,7 @@
    "metadata": {},
    "source": [
     "##Conversion Format methods.\n",
-    "It should be noted that two methods %s and %r actually convert any python object to a string using two seperate methods: str() and repr(). We will learn more about these functions later on in the course, but you should note you can actually pass almost any Python object with these two methods and it will work:\n"
+    "It should be noted that two methods %s and %r actually convert any python object to a string using two separate methods: str() and repr(). We will learn more about these functions later on in the course, but you should note you can actually pass almost any Python object with these two methods and it will work:\n"
    ]
   },
   {
diff --git a/Python Debugger (pdb).ipynb b/Python Debugger (pdb).ipynb
index 266332b..47e28fc 100644
--- a/Python Debugger (pdb).ipynb	
+++ b/Python Debugger (pdb).ipynb	
@@ -8,7 +8,7 @@
     "\n",
     "You've probably used a variety of print statements to try to find errors in your code. A better way of doing this is by using Python's built-in debugger module (pdb). The pdb module implements an interactive debugging environment for Python programs. It includes features to let you pause your program, look at the values of variables, and watch program execution step-by-step, so you can understand what your program actually does and find bugs in the logic.\n",
     "\n",
-    "This is a bit difficult to show since it requires creating an error on purpose, but hopefully this simple example illustrates the power of the pdb module. *Note: Keep in mind it would be pretty unsual to use pdb in an iPython Notebook setting.*\n",
+    "This is a bit difficult to show since it requires creating an error on purpose, but hopefully this simple example illustrates the power of the pdb module. *Note: Keep in mind it would be pretty unusual to use pdb in an iPython Notebook setting.*\n",
     "\n",
     "___\n",
     "Here we will create an error on purpose, trying to add a list to an integer"
diff --git a/Range() .ipynb b/Range().ipynb
similarity index 100%
rename from Range() .ipynb
rename to Range().ipynb
diff --git a/Reduce .ipynb b/Reduce.ipynb
similarity index 100%
rename from Reduce .ipynb
rename to Reduce.ipynb
diff --git a/Regular Expressions.ipynb b/Regular Expressions.ipynb
index c3f5969..9d77ead 100644
--- a/Regular Expressions.ipynb	
+++ b/Regular Expressions.ipynb	
@@ -249,7 +249,7 @@
     "\n",
     "We can use *metacharacters* along with re to find specific types of patterns. \n",
     "\n",
-    "Since we will be testing multiple re syntax forms, let's create a function that will print out recults given a list of various regular expressions and a phrase to parse:"
+    "Since we will be testing multiple re syntax forms, let's create a function that will print out results given a list of various regular expressions and a phrase to parse:"
    ]
   },
   {
@@ -279,7 +279,7 @@
     "\n",
     "There are five ways to express repetition in a pattern:\n",
     "\n",
-    "    1.) A pattern followed by the metacharacter * is repeated zero or more times. \n",
+    "    1.) A pattern followed by the meta-character * is repeated zero or more times. \n",
     "    2.) Replace the * with + and the pattern must appear at least once. \n",
     "    3.) Using ? means the pattern appears zero or one time. \n",
     "    4.) For a specific number of occurrences, use {m} after the pattern, where m is replaced with the number of times         the pattern should repeat. \n",
@@ -341,7 +341,7 @@
    "source": [
     "##Character Sets\n",
     "\n",
-    "Character sets are used when you wish to match any one of a group of characters at a point in the input. Brackets are used to construct character set inputs. For example: the input [ab] searches for occurences of either a or b.\n",
+    "Character sets are used when you wish to match any one of a group of characters at a point in the input. Brackets are used to construct character set inputs. For example: the input [ab] searches for occurrences of either a or b.\n",
     "Let's see some examples:"
    ]
   },
@@ -401,14 +401,14 @@
    },
    "outputs": [],
    "source": [
-    "test_phrase = 'This is a string! But it has punctutation. How can we remove it?'"
+    "test_phrase = 'This is a string! But it has punctuation. How can we remove it?'"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Use [^!.? ] to check for matches that are not a !,.,?, or space. Add the + to check that the match appears at least once, this basicaly translate into finding the words."
+    "Use [^!.? ] to check for matches that are not a !,.,?, or space. Add the + to check that the match appears at least once, this basically translate into finding the words."
    ]
   },
   {
diff --git a/Statements Assessment Test - Solutions.ipynb b/Statements Assessment Test - Solutions.ipynb
index e2143d6..bdabfab 100644
--- a/Statements Assessment Test - Solutions.ipynb	
+++ b/Statements Assessment Test - Solutions.ipynb	
@@ -86,7 +86,7 @@
    "metadata": {},
    "source": [
     "___\n",
-    "**Use List comprehension to create a list of all numbers between 1 and 50 that are divisble by 3.**"
+    "**Use List comprehension to create a list of all numbers between 1 and 50 that are divisible by 3.**"
    ]
   },
   {
diff --git a/Statements Assessment Test.ipynb b/Statements Assessment Test.ipynb
index 866c6e4..f95e9d2 100644
--- a/Statements Assessment Test.ipynb	
+++ b/Statements Assessment Test.ipynb	
@@ -64,7 +64,7 @@
    "metadata": {},
    "source": [
     "___\n",
-    "**Use List comprehension to create a list of all numbers between 1 and 50 that are divisble by 3.**"
+    "**Use List comprehension to create a list of all numbers between 1 and 50 that are divisible by 3.**"
    ]
   },
   {
diff --git a/Timing your code - timeit.ipynb b/Timing your code - timeit.ipynb
index 71df8ea..a77f2f1 100644
--- a/Timing your code - timeit.ipynb	
+++ b/Timing your code - timeit.ipynb	
@@ -29,7 +29,7 @@
    "source": [
     "Lets use time it to time various methods of creating the string '0-1-2-3-.....-99'\n",
     "\n",
-    "We'll pass two arguments the actual line we want to test encapsulated as a string and the number of times we wish to run it. Here we'll choose 10,000 runs to get some high enough numbers to comapre various methods."
+    "We'll pass two arguments the actual line we want to test encapsulated as a string and the number of times we wish to run it. Here we'll choose 10,000 runs to get some high enough numbers to compare various methods."
    ]
   },
   {
@@ -105,7 +105,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Great! We see a significant time difference by using map()! This is good to know and we shuold keep this in mind.\n",
+    "Great! We see a significant time difference by using map()! This is good to know and we should keep this in mind.\n",
     "\n",
     "Now lets introduce iPython's magic function %timeit\n",
     "\n",
diff --git a/Tuples.ipynb b/Tuples.ipynb
index 9beff43..0947c18 100644
--- a/Tuples.ipynb
+++ b/Tuples.ipynb
@@ -19,7 +19,7 @@
     "\n",
     "## Constructing Tuples\n",
     "\n",
-    "The construction of a tuples use () with elements seperated by commas. For example:"
+    "The construction of a tuples use () with elements separated by commas. For example:"
    ]
   },
   {
diff --git a/While loops .ipynb b/While loops.ipynb
similarity index 96%
rename from While loops .ipynb
rename to While loops.ipynb
index a4f1e83..ab61725 100644
--- a/While loops .ipynb	
+++ b/While loops.ipynb	
@@ -67,7 +67,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Notice how many times the print statements occured and how the while loop kept going until the True condition was met, which occured once x==10. Its important to note that once this occured the code stopped. Lets see how we could add an else statement:"
+    "Notice how many times the print statements occurred and how the while loop kept going until the True condition was met, which occurred once x==10. Its important to note that once this occurred the code stopped. Lets see how we could add an else statement:"
    ]
   },
   {
@@ -140,7 +140,7 @@
     "            continue \n",
     "    else:\n",
     "\n",
-    "**break** and **continue** statements can appear anywhere inside the loop’s body,but we will usually put them furhter nested in conjunction with an **if** statement to perform an action based on some condition.\n",
+    "**break** and **continue** statements can appear anywhere inside the loop’s body,but we will usually put them further nested in conjunction with an **if** statement to perform an action based on some condition.\n",
     "\n",
     "Lets go ahead and look at some examples!"
    ]
diff --git a/Zip.ipynb b/Zip.ipynb
index accdc27..0cb1c2c 100644
--- a/Zip.ipynb
+++ b/Zip.ipynb
@@ -63,7 +63,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Note how tuples are returned. What if one iterabel is longer than the other?"
+    "Note how tuples are returned. What if one iterable is longer than the other?"
    ]
   },
   {
@@ -96,7 +96,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Note how the zip is defined by the shortest iterable length. Its generally advised not to zip uneqal length iterables unless your very sure you only need partial tuple pairings.\n",
+    "Note how the zip is defined by the shortest iterable length. Its generally advised not to zip unequal length iterables unless your very sure you only need partial tuple pairings.\n",
     "\n",
     "What happens if we try to zip together dictionaries?"
    ]