diff --git a/00/Hello.js b/00/Hello.js
new file mode 100644
index 0000000..5a1baa2
--- /dev/null
+++ b/00/Hello.js
@@ -0,0 +1,8 @@
+function hello(name){
+	if(typeof name === "undefined"){
+		return "Hello!";
+	} else {
+		return "Hello, " + name + "!";
+	}
+}
+//
diff --git a/00/HelloSpec.js b/00/HelloSpec.js
new file mode 100644
index 0000000..224cf8c
--- /dev/null
+++ b/00/HelloSpec.js
@@ -0,0 +1,10 @@
+// talk about function
+describe("Hello", function() {
+  it("says hello", function() {
+    expect(hello()).toEqual("Hello!");
+  });
+
+  it("says hello to someone", function() {
+    expect(hello("Fred")).toEqual("Hello, Fred!");
+  });
+});
diff --git a/01/properties.js b/01/properties.js
new file mode 100644
index 0000000..eb8097d
--- /dev/null
+++ b/01/properties.js
@@ -0,0 +1,28 @@
+function setPropertiesOnObjLiteral(obj) {
+	obj.x = 7;
+	obj.y = 8;
+	obj.onePlus = function(addToMe) {
+		return addToMe + 1;
+	};
+}
+
+function setPropertiesOnArrayObj(obj) {
+	obj.hello = function() {
+		return "Hello!";
+	};
+	obj['full'] = "stack";
+	obj[0] = 5;
+	obj.twoTimes = function(doubleMe) {
+		return doubleMe * 2;
+	};
+}
+
+function setPropertiesOnFunctionObj(obj) {
+	obj.year = 2015;
+	obj.divideByTwo = function(halveMe) {
+		return halveMe / 2;
+	};
+	obj.prototype.helloWorld = function() {
+		return "Hello World";
+	};
+}
\ No newline at end of file
diff --git a/01/propertiesSpec.js b/01/propertiesSpec.js
new file mode 100644
index 0000000..27c1fe9
--- /dev/null
+++ b/01/propertiesSpec.js
@@ -0,0 +1,107 @@
+describe("Properties on Object Literal", function() {
+  var object;
+
+  // beforeEach is a Jasmine helper that runs 
+  // the code inside the passed function before each test below
+  // It's helpful for not having to repeat yourself constantly
+  // in your test specs
+  beforeEach(function() {
+
+    // for each test, create a new empty object
+    object = {};
+
+    // then run the setPropertiesOnObjLiteral function that you've written in properties.js
+    setPropertiesOnObjLiteral(object);
+  });
+
+  describe("setPropertiesOnObjLiteral", function() {
+    it("sets x to 7", function() {
+      expect(object.x).toEqual(7);
+    });
+
+    it("sets y to 8 (and we can use a string to access it)", function() {
+      expect(object['y']).toEqual(8);
+    });
+
+    it("sets the property 'onePlus' to a function that adds one to its parameter", function() {
+      expect(object.onePlus(4)).toEqual(5);
+      expect(object['onePlus'](123)).toEqual(124);
+    });
+  });
+});
+
+
+// Now let's explore the idea of using Arrays instead of Objects.
+// One of the coolest things about JavaScript is that Arrays are just 
+// a specific type of Object that has more features.  Everything that you can do
+// with objects, you can also do with arrays.
+describe("Properties on an Array Object", function() {
+  var arrayObject;
+
+  beforeEach(function() {
+    arrayObject = [];
+    setPropertiesOnArrayObj(arrayObject);
+  });
+
+  describe("setPropertiesOnArrayObj", function() {
+    it("sets the property `hello` to a function that returns the string `Hello!`", function() {
+      expect(arrayObject.hello()).toEqual("Hello!");
+    });
+
+    it("sets the property `full` to stack (and we can use a string to access it)", function() {
+      expect(arrayObject['full']).toEqual("stack");
+    });
+
+    it("accesses the zeroth index value in the array", function() {
+      expect(arrayObject[0]).toEqual(5);
+    });
+
+    it("sets the property 'twoTimes' to a function that multiplies its parameter by 1", function() {
+      expect(arrayObject.twoTimes(4)).toEqual(8);
+      expect(arrayObject['twoTimes'](123)).toEqual(246);
+    });
+
+  });
+});
+
+
+// It's the same with functions, they're also Objects.
+// 
+// This is an idea that we'll explore a lot more when we get to inheritance in the
+// Mammals exercise.
+describe("Properties on a Function Object", function() {
+  var functionObject;
+
+  beforeEach(function() {
+    functionObject = function() {
+      return "I am a function object, all functions are objects! Function can have their own properties too!";
+    };
+    setPropertiesOnFunctionObj(functionObject);
+  });
+
+  describe("`functionObject` function", function() {
+    it("returns the proper string the `functionObject` function returns declared in the beforeEach Function above", function() {
+      expect(functionObject()).toEqual("I am a function object, all functions are objects! Function can have their own properties too!");
+    });
+  });
+
+  describe("setPropertiesOnFunctionObj", function() {
+    it("sets year to 2015", function() {
+      expect(functionObject.year).toEqual(2015);
+    });
+
+    it("sets `divideByTwo` to a function that accepts a number and returns the value divided by two ", function() {
+      expect(functionObject.divideByTwo(6)).toEqual(3);
+    })
+
+    // Whenever you define a function in JavaScript, that "function object" also has a built-in property
+    // similar to `Array.length`.  This property is called `prototype` and it has some special behavior
+    // when used in conjunction with the `new` keyword.  We'll cover this later in _Mammals_
+    // 
+    // However, just like any other object, we can do whatever we want to this `prototype` object 
+    it("adds a property to the existing prototype object only on Function Objects", function() {
+      expect(functionObject.prototype.helloWorld()).toEqual("Hello World");
+    });
+  });
+
+});
diff --git a/02/calculator.js b/02/calculator.js
new file mode 100644
index 0000000..5f129e3
--- /dev/null
+++ b/02/calculator.js
@@ -0,0 +1,14 @@
+var createCalculator = function() {
+	var returnMe = {};
+	returnMe.myValue = 0;
+	returnMe.value = function() {
+			return this.myValue;
+		};
+	returnMe.add = function(addValue) {
+		this.myValue += addValue;
+	};
+	returnMe.subtract = function(minusValue) {
+		this.myValue -= minusValue;
+	}
+	return returnMe;
+}
\ No newline at end of file
diff --git a/02/calculatorSpec.js b/02/calculatorSpec.js
new file mode 100644
index 0000000..4a67f75
--- /dev/null
+++ b/02/calculatorSpec.js
@@ -0,0 +1,49 @@
+// In this exercise we're going to create a calculator object
+// that can perform certain basic mathematic operations.
+// 
+// We'll be using a pattern called the factory pattern where
+// our function creates an object tailored to our needs.  This function
+// is just like the one we built in *01_properties*, except now we're
+// creating some useful functions add
+describe("Create a Calculator", function() {
+  var calculator;
+
+  // Here we're just calling the `createCalculator` function, it returns
+  // a calculator object.
+  beforeEach(function() {
+    calculator = createCalculator();
+  });
+
+  it("initially has 0", function() {
+    expect(calculator.value()).toEqual(0);
+  });
+
+  it("can add a number", function() {
+    calculator.add(2);
+    expect(calculator.value()).toEqual(2);
+  });
+
+  it("can add two numbers", function() {
+    calculator.add(2);
+    calculator.add(3);
+    expect(calculator.value()).toEqual(5);
+  });
+
+  it("can add many numbers", function() {
+    calculator.add(2);
+    calculator.add(3);
+    calculator.add(4);
+    expect(calculator.value()).toEqual(9);
+  });
+
+  it("can subtract a number", function() {
+    calculator.subtract(2);
+    expect(calculator.value()).toEqual(-2);
+  });
+
+  it("can add and subtract", function() {
+    calculator.add(3);
+    calculator.subtract(2);
+    expect(calculator.value()).toEqual(1);
+  });
+});
diff --git a/03/RPNCalculator.js b/03/RPNCalculator.js
new file mode 100644
index 0000000..49221b0
--- /dev/null
+++ b/03/RPNCalculator.js
@@ -0,0 +1,55 @@
+var RPNCalculator = function() {
+	this.stack = new Array();
+}
+
+RPNCalculator.prototype.value = function() {
+	return this.stack[this.stack.length - 1];
+};
+
+RPNCalculator.prototype.push = function(pushMe) {
+	this.stack.push(pushMe);
+}
+
+RPNCalculator.prototype.plus = function() {
+	if(this.stack.length >= 2) {
+		var temp1 = this.stack.pop();
+		var temp2 = this.stack.pop();
+		var temp3 = temp1+temp2;
+		this.stack.push(temp3);
+	} else {
+		throw "rpnCalculator is empty";
+	}
+}
+
+RPNCalculator.prototype.minus = function() {
+	if(this.stack.length >= 2) {
+		var temp1 = this.stack.pop();
+		var temp2 = this.stack.pop();
+		var temp3 = temp2-temp1;
+		this.stack.push(temp3);
+	} else {
+		throw "rpnCalculator is empty";	
+	}
+}
+
+RPNCalculator.prototype.divide = function() {
+	if(this.stack.length >= 2) {
+		var temp1 = this.stack.pop();
+		var temp2 = this.stack.pop();
+		var temp3 = temp2/temp1;
+		this.stack.push(temp3);
+	} else {
+		throw "rpnCalculator is empty";
+	}
+}
+
+RPNCalculator.prototype.times = function() {
+	if(this.stack.length >= 2) {
+		var temp1 = this.stack.pop();
+		var temp2 = this.stack.pop();
+		var temp3 = temp1*temp2;
+		this.stack.push(temp3);
+	} else {
+		throw "rpnCalculator is empty";
+	}
+}
\ No newline at end of file
diff --git a/03/rpnCalculatorSpec.js b/03/rpnCalculatorSpec.js
new file mode 100644
index 0000000..0013e78
--- /dev/null
+++ b/03/rpnCalculatorSpec.js
@@ -0,0 +1,81 @@
+// See http://en.wikipedia.org/wiki/Reverse_Polish_notation
+// 
+// constructor functions, new keyword, how it relates to this
+describe("Calculator using reverse polish notation", function() {
+  var rpnCalculator;
+
+  beforeEach(function() {
+    rpnCalculator = new RPNCalculator();
+  });
+
+  it("adds two numbers", function() {
+    rpnCalculator.push(2);
+    rpnCalculator.push(3);
+    rpnCalculator.plus();
+    expect(rpnCalculator.value()).toEqual(5);
+  });
+
+  it("adds three numbers", function() {
+    rpnCalculator.push(2);
+    rpnCalculator.push(3);
+    rpnCalculator.push(4);
+    rpnCalculator.plus();
+    expect(rpnCalculator.value()).toEqual(7);
+    rpnCalculator.plus();
+    expect(rpnCalculator.value()).toEqual(9);
+  });
+
+  it("adds and subtracts", function() {
+    rpnCalculator.push(2);
+    rpnCalculator.push(3);
+    rpnCalculator.push(4);
+    rpnCalculator.minus();
+    expect(rpnCalculator.value()).toEqual(-1);
+    rpnCalculator.plus();
+    expect(rpnCalculator.value()).toEqual(1);
+  });
+
+  it("multiplies and divides", function() {
+    rpnCalculator.push(2);
+    rpnCalculator.push(3);
+    rpnCalculator.push(4);
+    rpnCalculator.divide();
+    expect(rpnCalculator.value()).toEqual(0.75);
+    rpnCalculator.times();
+    expect(rpnCalculator.value()).toEqual(1.5);
+  });
+
+  it("fails informatively when there's not enough values stashed away", function() {
+    expect(function() {
+      rpnCalculator.plus();
+    }).toThrow("rpnCalculator is empty");
+
+    expect(function() {
+      rpnCalculator.minus();
+    }).toThrow("rpnCalculator is empty");
+
+    expect(function() {
+      rpnCalculator.times();
+    }).toThrow("rpnCalculator is empty");
+
+    expect(function() {
+      rpnCalculator.divide();
+    }).toThrow("rpnCalculator is empty");
+  });
+
+  it("All methods should be on the RPNCalculator.prototype", function() {
+    expect(typeof RPNCalculator.prototype.plus).toEqual("function");
+    expect(typeof RPNCalculator.prototype.minus).toEqual("function");
+    expect(typeof RPNCalculator.prototype.divide).toEqual("function");
+    expect(typeof RPNCalculator.prototype.value).toEqual("function");
+  });
+
+  // Here we're using the `instanceof` keyword in JS so see if `rpnCalculator` is 
+  // an "instance" of capital RPNCalculator.  `instanceof` tests to see if 
+  // an 'internal prototype' (`__proto__`) in the chain of `rpnCalculator` matches the `RPNCalculator.prototype` object.
+  it("the rpnCalculator object should be an instance of the RPNCalculator Constructor", function() {
+    expect(rpnCalculator instanceof RPNCalculator).toEqual(true);
+  });
+
+
+});
diff --git a/04/loops.js b/04/loops.js
new file mode 100644
index 0000000..1463438
--- /dev/null
+++ b/04/loops.js
@@ -0,0 +1,104 @@
+var repeat = function(repeatMe, num) {
+	var returnMe = "";
+	for(; num; num--) {
+		returnMe+=repeatMe;
+	}
+	return returnMe;
+};
+
+var sum = function(sumMe) {
+	var returnMe = 0;
+	for(var i = 0; i<sumMe.length; i++) {
+		returnMe += sumMe[i];
+	}
+	return returnMe;
+};
+
+var gridGenerator = function(num) {
+	var returnMe = "";
+	for(var i = 0; i<num; i++) {
+		for(var j = 0; j<num; j++) {
+			if((i+j)%2) {
+				returnMe+=" ";
+			} else {
+				returnMe+="#";
+			}
+		}
+		returnMe+="\n";
+	}
+	return returnMe;
+}
+
+var largestTriplet = function(num) {
+	for(var c = num; c; c--) {
+		for(var b = c - 1; b; b--) {
+			for(var a = 1; a <= b; a++) {
+				if(a*a + b*b === c*c) {
+				 	var returnMe = new Array();
+				 	returnMe[0] = a;
+				 	returnMe[1] = b;
+				 	returnMe[2] = c;
+				 	return returnMe;
+				}
+			}
+		}
+	}
+}
+
+var join = function(joinThese, separators) {
+	var returnMe = "";
+	for(var i = 0; i<joinThese.length; i++) {
+		returnMe+=joinThese[i];
+		if(i !== joinThese.length-1) {
+			if(separators!==undefined) {
+				returnMe+=separators;
+			}
+		}
+	}
+	return returnMe;
+}
+
+var paramify = function(myObj) {
+	var returnMe = new Array();
+	for(var key in myObj) {
+		if(Object.prototype.hasOwnProperty.call(myObj, key)) {
+			var temp = key+"="+myObj[key];
+			returnMe.push(temp);
+		}
+	}
+	//if mergeSort worked, I would just do the commented out lines...
+	//but then I found out javascript has a built in sort!
+	//returnMe2 = mergeSort(returnMe);
+	//return join(returnMe2,"&");
+	returnMe.sort();
+	return join(returnMe,"&");
+}
+
+//mergeSort breaks testem...
+//the formatting changes in safari
+//the number of tested specs changes to 21/21
+// var mergeSort = function(sortMe) {
+// 	if(sortMe.length < 2) {
+// 		return sortMe;
+// 	}
+// 	var middle = Math.floor(sortMe.length/2);
+// 	var left = sortMe.slice(0,middle);
+// 	var right = sortMe.slice(middle);
+
+// 	return merge(mergeSort(left), mergeSort(right));
+// }
+
+// var merge = function(left, right) {
+// 	var returnMe = [];
+// 	leftIndex = 0;
+// 	rightIndex = 0;
+// 	while(leftIndex<left.length && rightIndex<right.length) {
+// 		if(left[leftIndex] < right[rightIndex]) {
+// 			returnMe.push(left[leftIndex]);
+// 		} else {
+// 			returnMe.push(right[rightIndex]);
+// 		}
+// 	}
+// 	return returnMe.concat(left.slice(leftIndex)).concat(right.slice(rightIndex));
+// }
+
diff --git a/04/loopsSpec.js b/04/loopsSpec.js
new file mode 100644
index 0000000..4c39679
--- /dev/null
+++ b/04/loopsSpec.js
@@ -0,0 +1,158 @@
+describe("Loops", function() {
+
+  // Let's repeat ourselves several times
+  describe("repeat", function() {
+    it("is empty with 0 repeats", function() {
+      expect(repeat("yo", 0)).toEqual("");
+    });
+    it("repeats its argument once", function() {
+      expect(repeat("yo", 1)).toEqual("yo");
+    });
+    it("repeats its argument twice", function() {
+      expect(repeat("yo", 2)).toEqual("yoyo");
+    });
+      it("repeats its argument many times", function() {
+      expect(repeat("yo", 10)).toEqual("yoyoyoyoyoyoyoyoyoyo");
+    });
+  });
+
+  // Let's iterate over all the elements of an array
+  describe("sum", function() {
+    it("computes the sum of an empty array", function() {
+      expect(sum([])).toEqual(0);
+    });
+
+    it("computes the sum of an array of one number", function() {
+      expect(sum([7])).toEqual(7);
+    });
+
+    it("computes the sum of an array of two numbers", function() {
+      expect(sum([7, 11])).toEqual(18);
+    });
+
+    it("computes the sum of an array of many numbers", function() {
+      expect(sum([1, 3, 5, 7, 9])).toEqual(25);
+    });
+  });
+});
+
+describe("Looping over nested Loops", function(){
+  it("returns an empty string when input is 0", function(){
+    expect(gridGenerator(0)).toEqual("");
+  });
+  // all characters (even whitespaces) are values of the grid
+  it("creates a grid with 3 columns and rows when input is 3", function(){
+    expect(gridGenerator(3)).toEqual("# #\n # \n# #\n");
+  });
+  it("creates a grid with 2 columns and rows when input is 2", function(){
+    expect(gridGenerator(2)).toEqual("# \n #\n")
+  });
+
+  // Research what a Pythagorean Triplet is.  What would make a PT larger than another?
+  it("finds the largest Pythagorean Triplet of a given value and returns an array of the Triplet", function(){
+    expect(largestTriplet(25)).toEqual([7,24,25]); // [15,20,25] Is smaller based on its b value
+  });
+  it("finds the largest Pythagorean Triplet of a given value", function(){
+    expect(largestTriplet(65)).toEqual([16,63,65]);
+  });
+  it("finds the largets Pythagorean Triplet within 'n' (aka the number argument passed)", function(){
+    expect(largestTriplet(66)).toEqual([16,63,65]);
+  })
+});
+
+describe("More looping over arrays", function() {
+
+  // try to implement this join() function without using the built-in String#join function
+  describe("join", function() {
+    it("turns an empty array into an empty string", function() {
+      expect(join([])).toEqual("");
+    });
+
+    it("turns an array with one element into a string", function() {
+      expect(join(['a'])).toEqual("a");
+    });
+
+    it("turns an array with many elements into a string", function() {
+      expect(join(['apple', 'banana', 'cherry'])).toEqual("applebananacherry");
+    });
+
+    it("inserts a delimiter between elements", function() {
+      expect(join(['apple', 'banana', 'cherry'], '/')).toEqual("apple/banana/cherry");
+    });
+
+    // This test is to make sure you don't use "for (var i in a)" on an array
+    // Remember how we can add any type of key/value to an array object
+    // since it's just like a regular object?
+    it("ignores non-indexed properties set on the array object", function() {
+      var array = ['apple', 'banana', 'cherry'];
+
+      array.type = 'fruits';
+      expect(array.type).toEqual('fruits');
+
+      array.first = function() {
+        return this[0];
+      };
+
+      expect(array.first()).toEqual('apple');
+
+      expect(join(array)).toEqual("applebananacherry");
+    });
+
+  });
+});
+
+
+// Let's practice looping over objects using the for(var i in obj) since
+// Here we have to also be aware of the `__proto__` relationship
+describe("looping over objects", function() {
+  describe("paramify", function() {
+    it("works on an empty object", function() {
+      expect(paramify({})).toEqual("");
+    });
+
+    it("converts an object with one element", function() {
+      expect(paramify({
+        size: 14
+      })).toEqual("size=14");
+    });
+
+    it("converts an object with two elements", function() {
+      expect(paramify({
+        height: 74,
+        width: 12
+      })).toEqual("height=74&width=12");
+    });
+
+    it("converts an object with many elements", function() {
+      var object = {a: 1, b: 2, c: 3, d: 4, e: 5, f: 6 };
+      expect(paramify(object)).toEqual("a=1&b=2&c=3&d=4&e=5&f=6");
+    });
+
+    // this one might be a bit tricky ;-)
+    it("outputs the parameters in alphabetical order", function() {
+      var object = {f: 6, e: 5, d: 4, c: 3, b: 2, a: 1 };
+      expect(paramify(object)).toEqual("a=1&b=2&c=3&d=4&e=5&f=6");
+    });
+
+    // This one is also tricky, here we want you to only `paramify` the properties 
+    // of the object and avoid any that are on the object's 'internal prototype' (__proto__) object.
+    // To do that, use the `hasOwnProperty` method of `sObject`
+    it("skips properties of the object's prototype", function() {
+
+      // Alphabet is a constructor function that will use the `new` method of
+      // object creation
+      var Alphabet = function() {
+        this.a = 1;
+        this.b = 2;
+      };
+
+      Alphabet.prototype = {
+        c: 3
+      };
+
+      var alphabet = new Alphabet();
+      // see how we're skipping `c` ?
+      expect(paramify(alphabet)).toEqual("a=1&b=2");
+    });
+  });
+});