added content and exercises

Noer Paanakker · Noer Paanakker · commit 96b54c566c82 · 2019-08-27T16:24:50.000+02:00
diff --git a/Week1/MAKEME.md b/Week1/MAKEME.md
@@ -120,7 +120,7 @@ In the following tutorial you'll learn how to make a small web application that
 
 - [Build an Issue Tracker](https://www.youtube.com/watch?v=NYq9J-Eur9U)
 
-## **4. PROJECT: Random quote Generator**
+## **4. PROJECT: Random Quote Generator**
 
 > Every week ends with a project you have to build on your own. Instead of getting clear-cut instructions, you'll get a list of criteria that your project needs to measure up to.
 
diff --git a/Week2/README.md b/Week2/README.md
@@ -30,11 +30,11 @@ This is also how JavaScript by default operates. Only one operation can happen a
 
 ### Asynchronous
 
-Sometimes we want to do multiple things, without them being dependent on each other. Consider the following analogy:
+Sometimes we want to do multiple things, without each action to be dependent on each other. Consider the following analogy:
 
-> Wouter is feeling hungry so he decides to go to a restaurant. He arrives there and gets into the line to order food. After ordering he takes a seat and, while he waits, reads a book. Occassionally he looks around and sees different things happening: new people enter the restaurant, some people get their food served and others are just talking. After a short while Wouter's food arrives and it's time to dig in!
+> Wouter is feeling hungry, so he decides to go to a restaurant. He arrives there and gets into the line to order food. After ordering he takes a seat and, while he waits, reads a book. Occassionally he looks around and sees different things happening: new people enter the restaurant, some people get their food served and others are just talking. After a short while Wouter's food arrives and it's time to dig in!
 
-In this example Wouter reads a book, but that doesn't affect his meal from being prepared. Other
+In this example Wouter reads a book, but that doesn't affect his meal from being prepared. [TO BE CONTINUED]
 
 Take a look at the following diagram:
 
@@ -54,7 +54,7 @@ second();
 
 In this example, only after `first()` has been executed will `second()` be executed. Only one thing happens at a time, and the next thing will ONLY happen after the previous thing has finished. This synchronous execution happens predictably and sequentially, without exception.
 
-On the other hand we have
+On the other hand we have [TO BE CONTINUED]
 
 Executing each block of code (whether it's a line or a loop/function/etc.) after each other is called
 
@@ -66,9 +66,19 @@ Asynchronous execution avoids this bottleneck. You are essentially saying, “I
 
 Imagine the following situation:
 
-> It's 15.00 and you studying at home for an exam on the next day. Suddenly, your phone rings. You pick up and find it's your best friend! They ask if you'd like to hang out later. What do you do? On the one hand, you'd love to hang out have fun. On the other hand, you really should study some more. You don't know so tell your friend that you're going to call back later with your answer. You end the conversation and go back to studying. Maybe you take a short break and
+> It's 15.00 and you're studying at home for an exam on the next day. Suddenly, your phone rings. You pick up and find it's your best friend! They ask if you'd like to hang out later. What do you do? On the one hand, you'd love to hang out have fun. On the other hand, you really should study some more. You don't know so you tell your friend that you're going to _call back_ later with your answer. You end the conversation and go back to studying. Maybe you take a break or have a snack as well. On the other line your friend hangs up the phone and continues along with their day: they go out grocery shopping, cleaning the house and cooking dinner. After finishing your studies you call your friend and makes plans to go out together.
 
-By default JavaScript works **synchronously**, as we've learned in the previous section.
+In this example there is one process: life. In technical terms you could call it the program. Life contains many things, but in this example it only contains two things: you and your friend. Let's call them mini programs, or `functions`. The function called "You" does various things: studying,
+
+This example illustrates the concept of **asynchronicity**: there are multiple processes happening simultaneously, without any single thing being dependent upon another thing. Your friend is not waiting by the phone until you have the answer. Or in technical terms: until the callback (which is you) has the return value (the asnwer to your friend's request to hang out).
+
+As we've learned in the previous section, by default JavaScript works **synchronously**. In short this means that only one command gets executed (and finishes) until the next command gets executed.
+
+Take this insight to heart: **Synchronicity is the process, callbacks are the implementation**. Let's clarify that:
+
+- Saying that the proces is synchronous, is saying that there can only be an execution of commands in a single sequence. But this process can be changed to be asynchronous, which means that the process can handle
+
+to initiate that process change from synchronous to asynchronous.
 
 This is why callbacks are important: it allows us to introduce asynchronicity in the control flow of a program.
 
diff --git a/Week3/MAKEME.md b/Week3/MAKEME.md
@@ -9,23 +9,48 @@
 
 ## **1. Practice the concepts**
 
-## **2. JavaScript exercises**
+Let's get familiar with basic Javascript concepts, with interactive exercises! Check out the following resources:
+
+- [Introduction to JavaScript: Scope (Codecademy)](https://www.codecademy.com/courses/introduction-to-javascript/lessons/scope/exercises/scope)
 
-### Scope/closure exercises
+## **2. JavaScript exercises**
 
 **Exercise 1: Add six**
 
-Write a function that would allow you to do this:
+Declare a function called `createBase`. It should return a closure, that adds a number to the base number argument.
+
+Call the function three times. The return values should be:
+
+1. 15
+2. 24
+3. 36
+
+It should look a little like this:
 
 ```js
+function createBase() {
+  // Put here your logic...
+}
+
 const addSix = createBase(6);
-addSix(10); // returns 16
-addSix(21); // returns 27
+
+// Put here your function calls...
+addSix();
+```
+
+**Exercise 2: Take out the duplicates**
+
+Write a function called `removeDuplicates`, that takes in an array as an argument:
+
+```js
+const letters = ['a', 'b', 'c', 'd', 'a', 'e', 'f', 'c', 'b'];
 ```
 
-**Exercise 2: asds**
+The function should remove duplicate letters. So the result should be:
 
-Write a function takes this array `['a', 'b', 'c', 'd', 'a', 'e', 'f', 'c']` and returns an array which only has unique values in it (so it removes the duplicate ones). Make it a 'smart' algorithm that could do it for every array (only strings/number).
+```js
+letters === ['a', 'b', 'c', 'd', 'e', 'f'];
+```
 
 **Exercise 3: Guess the output**
 
@@ -80,39 +105,16 @@ Now spreading the soya magarine
 Spreading jam
 ```
 
-**Exercise 5**
+**Exercise 5: The lottery machine**
 
-We learned a little bit about callbacks in JS. A callback is simply a function passed to another function that gets executed (run) after a potentially long running operation has completed. There is another function called `setTimeout` that will wait a specified period of time and then execute a function. For example:
+Don't you just love the thrill of the lottery? What if I told you we can make our own lottery machine? Let's get started!
 
-```js
-function doIt() {
-  console.log('I am done');
-}
-setTimeout(doIt, 5000);
-```
-
-> If you run the above code it will wait 5 seconds and then print `I am done`. Please read something about setTimeout on MDN. The first argument to the `setTimeout` call is the callback (`doIt`).
-
-**2.1** We saw that we can pass functions as arguments to other functions. Your task is to write a function that takes another function as an argument and runs it.
-
-```js
-function foo(func) {
-  // What to do here?
-}
-
-function bar() {
-  console.log('Hello, I am bar!');
-}
-
-foo(bar);
-```
-
-**2.2** You must write a function that takes 4 arguments.
+Write a function that takes 4 arguments.
 
 - A start value
 - An end value
-- A callback to call if the number is divisible by 3
-- A callback to use if the number is divisible by 5
+- A callback that executes if the number is divisible by 3
+- A callback that executes if the number is divisible by 5
 
 The function should first generate an array containing values from start value to end value (inclusive).
 
@@ -133,9 +135,19 @@ threeFive(10, 15, sayThree, sayFive);
 
 // Should create an array [10,11,12,13,14,15]
 // and call sayFive, sayThree, sayThree, sayFive
-// please make sure you see why these calls are made before you start coding
 ```
 
+We learned a little bit about callbacks in JS. A callback is simply a function passed to another function that gets executed (run) after a potentially long running operation has completed. There is another function called `setTimeout` that will wait a specified period of time and then execute a function. For example:
+
+```js
+function doIt() {
+  console.log('I am done');
+}
+setTimeout(doIt, 5000);
+```
+
+**2.2**
+
 > Note: The following assignments include some problems from _freeCodeCamp_. Note that some _freeCodeCamp_ examples still mention `var`. However you can safely replace them with `let` and `const` as appropriate.
 
 **2.5** Nested loops
diff --git a/Week3/README.md b/Week3/README.md
@@ -18,11 +18,19 @@ These are the topics for week 3:
 
 On of the central concepts in programming is the idea of `context`: the meaning of any particular thing is only determined in relation to its direct surroundings. Let's take language for example. If I say the following sentence:
 
-> asdas
+> I never said she stole my money.
 
-Reading this it's not obvious how to interpret what's said. It depends on `context` for me to know how to look at it correctly.
+Reading this it's not obvious how to interpret what the situation is about. Depending on the emphasis of the words it could mean any of the following:
 
-In JavaScript, scope refers to the current context of your code.
+- _I_ never said she stole my money.
+- I _never_ said she stole my money.
+- I never _said_ she stole my money.
+- I never said _she_ stole my money.
+- I never said she _stole_ my money.
+- I never said she stole _my_ money.
+- I never said she stole my _money_.
+
+It depends on `context` for me to know what really happened. In programming, the term `scope` refers to the relevant variables that are involved in
 
 ### Global vs. local (function and block)
 
@@ -31,6 +39,15 @@ In JavaScript, scope refers to the current context of your code.
 
 ### Const and let
 
+Quick refresher: Variables are used to store information to be referenced and manipulated in a computer program. They also provide a way of labeling data with a descriptive name, so our programs can be understood more clearly by the reader and ourselves. It is helpful to think of variables as containers that hold information. Their sole purpose is to label and store data in memory. This data can then be used throughout your program.
+
+In JavaScript we define them using the keyword `var`:
+
+```js
+var
+
+```
+
 ## 2. Hoisting
 
 If you look up the term "hoisting" in any dictionary, you'll find something like this:
@@ -55,10 +72,13 @@ Hoisting happens during `compile-time`.
 
 ## 3. Closures
 
+Simply put, a closure is a function that is defined inside another function.
+
 For further study please check the following resources:
 
 - [The Ultimate Guide to Execution Contexts, Hoisting, Scoping and Closures in JavaScript](https://www.youtube.com/watch?v=Nt-qa_LlUH0)
 - [Understanding Closures](https://www.youtube.com/watch?v=rBBwrBRoOOY)
+- [Let's Learn JavaScript Closures](https://www.freecodecamp.org/news/lets-learn-javascript-closures-66feb44f6a44/)
 
 ## 4. Thinking like a programmer II
 
