From accf7f3b7017f5d31de5cd048b2b22319d9b24ec Mon Sep 17 00:00:00 2001
From: Noer Paanakker <noer@hackyourfuture.net>
Date: Wed, 8 Apr 2020 17:51:44 +0200
Subject: [PATCH 1/3] rewrote readings and homework all weeks

---
 README.md                 | 10 ++++++
 Week1/MAKEME.md           | 41 ++++++++++++++----------
 Week1/README.md           | 50 +++++++++++++++++++----------
 Week2/MAKEME.md           | 66 +++++++++++++++++++++++++--------------
 Week2/README.md           | 18 ++++++-----
 Week3/MAKEME.md           | 56 +++++++++++++++++----------------
 Week3/README.md           | 35 ++++++++++++++++-----
 hand-in-homework-guide.md |  4 +--
 8 files changed, 178 insertions(+), 102 deletions(-)

diff --git a/README.md b/README.md
index 7e90c241d..f4756ba31 100644
--- a/README.md
+++ b/README.md
@@ -30,6 +30,16 @@ This repository consists of 3 essential parts:
 
 After your first class you should start off with checking the `reading materials` for that week. At the beginning that would be the [Week 1 Reading](/Week1/README.md). Study all the concepts and try to get the gist of everything. After, you can get started with the `homework` for that week.
 
+Before you start with the homework, make sure you've made a `fork` of the right repository: [HackYourHomework/JavaScript2](https://www.github.com/hackyourhomework/javascript2). Once you've cloned it to your computer you can proceed by making `GIT` branches for each week. Start at the `master` branch and execute the following (note that they're 3 different commands):
+
+```console
+foo@bar:~$ git branch week1-YOURNAME
+foo@bar:~$ git branch week2-YOURNAME
+foo@bar:~$ git branch week3-YOURNAME
+```
+
+Then execute `git checkout week1-YOURNAME` and you can get started!
+
 If you have any questions or if something is not entirely clear ¯\\\_(ツ)\_/¯, please ask/comment on Slack!
 
 ## Planning
diff --git a/Week1/MAKEME.md b/Week1/MAKEME.md
index 01621ec96..42b39863b 100644
--- a/Week1/MAKEME.md
+++ b/Week1/MAKEME.md
@@ -26,28 +26,30 @@ const books = [
   {
     title: 'The Design of Everyday Things',
     author: 'Don Norman',
-    alreadyRead: false
+    alreadyRead: false,
   },
   {
     title: 'The Most Human Human',
     author: 'Brian Christian',
-    alreadyRead: true
+    alreadyRead: true,
   },
   {
     title: 'The Pragmatic Programmer',
     author: 'Andrew Hunt',
-    alreadyRead: true
-  }
+    alreadyRead: true,
+  },
 ];
 ```
 
+Follow the steps:
+
 1. Iterate through the array of books.
 2. For each book, create a `<p>` element with the book title and author and append it to the page.
 3. Use a `<ul>` and `<li>` to display the books.
 4. Add an `<img>` to each book that links to a URL of the book cover.
 5. Change the style of the book depending on whether you have read it (green) or not (red).
 
-The end result should look something like this:
+Expected output:
 https://hyf-js2-week1-makeme-ex1-demo.herokuapp.com/
 
 **Exercise 2: About me**
@@ -73,6 +75,8 @@ Given this HTML:
 </html>
 ```
 
+Follow the steps:
+
 1. Add a script tag to the bottom of the HTML body.
 2. (In the JavaScript) Change the body tag's style so it has a font-family of "Arial, sans-serif".
 3. (In the JavaScript) Replace each of the spans (nickname, fav-food, hometown) with your own information.
@@ -82,20 +86,22 @@ Given this HTML:
 
 **Exercise 3: The logo hijack**
 
-No homepage is safe from the logo bandit! Everytime he sees a Google Logo he replaces it with a logo from HackYourfuture instead: https://www.hackyourfuture.dk/static/logo-dark.svg.
+No homepage is safe from the logo bandit! Every time he sees a Google Logo he replaces it with a logo from HackYourFuture instead: https://www.hackyourfuture.dk/static/logo-dark.svg.
 
-In this exercise you're expected to write a JavaScript function that can be executed in the console of the [Google website](https://www.google.com).
+In this exercise you're expected to write a JavaScript `function` that can be executed in the console of the [Google website](https://www.google.com).
 
-1. Find out how to select the element that contains the Google logo, and store it in a variable
-2. Modify the source and sourceset of the logo so that it's replaced by the HackYourFuture logo instead
+1. Find out how to `select` the element that contains the Google logo, and store it in a `variable`
+2. Modify the `source` and `sourceset` of the logo so that it's replaced by the HackYourFuture logo instead
 
 **Exercise 4: What's the time?**
 
 Why wear a watch when you can check the time, live in your webpage?
 
+Follow the steps:
+
 1. Create a basic HTML file
 2. Include a script tag and link the JavaScript file
-3. Inside the JS file, write a function that adds the current time to the webpage. Make sure it's written in the HH:MM:SS notation (hour, minute, second). Hint: use `setInterval()` to make sure the time stays current
+3. Inside the JS file, write a function that adds the current time to the webpage. You have to find out how to access the time first. Once you've done so, make sure it's written in the HH:MM:SS notation (hour, minute, second). Hint: use `setInterval()` to make sure the time stays current
 4. Have the function execute when it's loading in the browser
 
 **Exercise 5: The cat walk**
@@ -115,18 +121,19 @@ Start with this webpage, which has a single img tag of an animated GIF of a cat
 </html>
 ```
 
-1. Create a variable to store a reference to the img.
-2. Change the style of the img to have a "left" of "0px", so that it starts at the left hand of the screens.
+1. Create a variable to store a reference to the `<img>`.
+2. Change the style of the `<img>` to have a "left" of "0px", so that it starts at the left hand of the screens.
 3. Create a function called catWalk() that moves the cat 10 pixels to the right of where it started, by changing the "left" style property.
-4. Call that function every 50 milliseconds. Your cat should now be moving across the screen from left to right. Hurrah!
+4. Call that function every 50 milliseconds. Your cat should now be moving across the screen from left to right.
 5. When the cat reaches the right-hand of the screen, restart them at the left hand side ("0px"). So they should keep walking from left to right across the screen, forever and ever.
-6. When the cat reaches the middle of the screen, replace the img with an image of a cat dancing (use this URL: https://tenor.com/StFI.gif), keep it dancing for 5 seconds, and then replace the img with the original image and have it continue the walk.
-
+6. When the cat reaches the middle of the screen, replace the `<img>` with an image of a cat dancing (use this URL: https://tenor.com/StFI.gif), keep it dancing for 5 seconds, and then replace the `<img>` with the original image and have it continue the walk.
 
-The end result should look and behave similar to [https://dancingcat-sandbox.mxapps.io](https://dancingcat-sandbox.mxapps.io)
+Expected result should look and behave similar to [https://dancingcat-sandbox.mxapps.io](https://dancingcat-sandbox.mxapps.io)
 
 ## **3. Code along**
 
+> Create a new GitHub repository for this project. You can add it to your portfolio!
+
 In the following tutorial you'll learn how to make a small web application that allows a user to add new issues to a board. Included is practice with [Bootstrap](https://getbootstrap.com/).
 
 Enjoy!
@@ -156,7 +163,7 @@ Good luck!
 
 ## **SUBMIT YOUR HOMEWORK!**
 
-After you've finished your todo list it's time to show us what you got! Upload all your files to a forked repository (a copy from the original, which in this case is the [JavaScript2](https://www.github.com/HackYourFuture/JavaScript2) repository) using GIT. Then make a pull request to the original.
+After you've finished your todo list it's time to show us what you got! Upload both to your JavaScript2 repository forked to your personal account in GitHub. Make a pull request to the [HackYourHomework/JavaScript2](https://www.github.com/hackyourhomework/javascript2).
 
 If you need a refresher, take a look at the following [guide](../hand-in-homework-guide.md) to see how it's done.
 
diff --git a/Week1/README.md b/Week1/README.md
index 942dcc007..f74389f5d 100644
--- a/Week1/README.md
+++ b/Week1/README.md
@@ -19,20 +19,24 @@ These are the topics for week 1:
 
 ## 1. What is a web browser?
 
-A web browser is software that allows you to access websites.
+A web browser is software that allows you to access websites. If you've ever visited a website, you've used a browser. They allow us to connect to the internet and go places we otherwise never could using our computer.
 
 ### How a browser works
 
-In your journey into becomeing a web developer it's important to know the tools you'll be using intimately. One such is the browser, which will be used to display your websites. In the following resources you'll learn about the many parts any web browser consists of and what their use is:
+In your journey into becoming a web developer it's important to know the tools you'll be using intimately. One such tool is the browser, which will be used to navigate to and display websites.
+
+In the following resources you'll learn about the many parts any web browser consists of and what their use is:
 
 - [How a web browser functions](https://www.youtube.com/watch?v=z0HN-fG6oT4)
 - [How do web browsers work?](https://medium.com/@monica1109/how-does-web-browsers-work-c95ad628a509)
 
 ### Different browsers work differently
 
-A website, ultimately is a set of instructions describing how a series of webpages should look. It's up to the browser to render it by reading the code from your HTML/CSS and JavaScript files. There are, however, differences in the code interpretation of the different browsers, thus making the output look differently.
+A website is a collection of webpages. It's up to the browser to render it by reading the code from your HTML/CSS and JavaScript files. There are, however, differences in the code interpretation of the different browsers, thus making the output look differently.
+
+> Try it out for yourself: open a website you visit frequently into different browsers and see how it looks differently.
 
-That's why you should check the way your website looks on different browsers during the development of your website. This is called making it **cross browser compatible**>
+Having a website display differently across browsers is NOT a good thing. As a developer your job is to make the user experience of a website as consistent as possible. That's why you should check the way your website looks on different browsers during the development of your website. This is called making your website **cross browser compatible**>
 
 You can use the following online tool in order see how your pages look on multiple browsers:
 
@@ -40,9 +44,11 @@ You can use the following online tool in order see how your pages look on multip
 
 A good website should look and function the same in any browser.
 
-Unfortunately, there is no easy solution for that. You should check the specificities of each browser that fails to display your website correctly and make the necessary adjustments to your code. Such compatibility issues may occur not only in different browsers but because of an old browser version which does not support completely the latest standards.
+Unfortunately, there is no easy solution for that. You should check the specificities of each browser that fails to display your website correctly and make the necessary adjustments to your code. Such compatibility issues may occur not only in different browsers but because of an old browser version which does not support completely the latest standards of HTML/CSS/JavaScript.
 
-This is because browser development doesn't go at the same speed as programming language development. More often than not, the web technologies you're using will have more features you as a developer can make use of than the browser can currently handle. This is important to keep in mind.
+The reason is simple: browser development doesn't go at the same speed as programming language development. That's right, both browsers and programming languages are also works in progress. They're software, just like the websites you build!
+
+More often than not, the web technologies you're using will have more features you as a developer can make use of than the browser can currently handle. This is important to keep in mind.
 
 When you do your styling, especially, it's important to know if a certain browser (and browser version) is even able to understand it. A helpful tool in identifying this is a website called **caniuse.com**:
 
@@ -62,13 +68,13 @@ For more research, check out the following resources:
 
 As we've learned in the previous module, JavaScript is a programming language. It allows you to write logical rules that the computer can execute in order to solve a problem. However, saying that the 'computer' executes it is actually inaccurate. There are two specific softwares that execute JavaScript: **the browser** and **Node.js**. We'll talk about the latter in a different module.
 
-The browser is software that has been build to understand JavaScript ((and HTML/CSS)). Each different browser (Chrome, Firefox, Safari, etc.) has, behind the scenes, a **JavaScript engine** that works to transform the JavaScript code that you write into code that the computer understands.
+The browser is software that has been build to understand JavaScript (and HTML/CSS). Each different browser (Chrome, Firefox, Safari, etc.) has, behind the scenes, a **JavaScript engine** that works to transform the JavaScript code that you write into code that your operating system understands.
 
 - [How the JavaScript engine works](https://www.youtube.com/watch?v=KM9coMpy5sQ)
 
-Every programming language sits at a certain level of abstraction, relative to the only real language a computer understands: machine code (which is only 0's and 1's). For more information on this, check out the following [video](https://www.youtube.com/watch?v=bUWCD45qniA)
+Every programming language sits at a certain level of abstraction, relative to the only real language a computer understands: machine code (which are only 0's and 1's). For more information on this, check out the following [video](https://www.youtube.com/watch?v=bUWCD45qniA)
 
-For our purposes, it's only important to understand that the browser looks at JavaScript and then does what it's instructed to do: add elements, modify text or media files, etc. That's the purpose of JavaScript in the browser: to add interactivity based off of the user's behavior.
+For our purposes, it's only important to understand that the browser looks at the JavaScript code and then does what it's instructed to do: add elements, modify text or media files, etc. That's the purpose of JavaScript in the browser: to add interactivity to a webpage, so that a user can interact with it.
 
 - [JavaScript, the Browser, and the DOM](https://www.youtube.com/watch?v=31ViueuIXGE)
 
@@ -78,7 +84,7 @@ The Document-Object Model (DOM) is a tree-like representation of the structure o
 
 ![Simple DOM](./../assets/simple-dom.png)
 
-JavaScript is made accessible to the DOM by embedding it into an HTML file. You might've seen the `<script></script>` before; well, this is how the browser becomes aware of JavaScript.
+JavaScript is made accessible to the DOM by embedding it into an HTML file. You might've seen the `<script src="script.js"></script>` before. This tag `<script>` and attribute `src="script.js"` is how the browser becomes aware of JavaScript!
 
 - [What exactly is the DOM](https://bitsofco.de/what-exactly-is-the-dom/)
 - [JavaScript and the browser](https://eloquentjavascript.net/13_browser.html)
@@ -88,20 +94,30 @@ JavaScript is made accessible to the DOM by embedding it into an HTML file. You
 
 The actual process of transforming HTML, CSS and JavaScript into a user-viewable version of a webpage is called **the Critical Rendering Path**.
 
+You don't need to know the full details of how the rendering process goes. However, it is important to know that it doesn't just "magically" happen. Look through the following to learn more about the Critical Rendering Path:
+
 - [Understanding the Critical Rendering Path](https://bitsofco.de/understanding-the-critical-rendering-path/)
 
 ## 3. What is DOM Manipulation?
 
-**DOM manipulation** refers to the activity of selecting and modifying DOM elements. The main reason why this is done is that **you want to show the user different things depending their activity**, for example if you click on a [hamburger menu icon](https://bit.ly/2Yr4O7Z) and a navigation menu slides in.
+**DOM manipulation** refers to the activity of selecting and modifying DOM elements. The main reason why this is done is that **you want to show the user different things depending their activity**, for example if you click on a [hamburger menu icon](https://bit.ly/2Yr4O7Z) a navigation menu slides in.
 
-Finding the right elements is called **traversing the DOM**. Traversing the DOM essential means: using JavaScript to select certain elements within the DOM in order to modify them (change color, size or make them disappear, for example).
+Finding the right elements using JavaScript is called **traversing the DOM**. Traversing the DOM essential means: we can select certain elements within the DOM in order to modify them (change color, size or make them disappear, for example).
+
+We can do so using various `functions`:
+
+```js
+document.querySelector('#booklist'); // Selects any element
+document.getElementById('booklist'); // Selects an element by id
+document.getElementsByClassName('item'); // Selects all elements with the specified class name
+```
 
 ### Manipulating elements
 
 Look at the following code sample:
 
 ```js
-const body = document.querySelector('body'); // you can also use 'document.body'
+const body = document.querySelector('body'); // you can also use 'document.body' directly
 const newParagraph = document.createElement('p');
 newParagraph.innerText = 'This paragraph will be added to the body!';
 newParagraph.style.background = 'red';
@@ -129,9 +145,9 @@ Browser events (also known as DOM events) are very much like real-life events: t
 
 These events are important to know about, because based on those we manipulate the DOM. For example, user clicks on an image and as a result it increases in size.
 
-Effectively it's cause and effect.
+Effectively, it's cause (user clicks on a button) and effect (the button disappears).
 
-Check out the following resources to learn more about what events there are, and what you can do to manipulate elements after an event has happened:
+Check out the following resources to learn more about what type of events there are, and what you can do to manipulate elements after an event has happened:
 
 - [What are browser events?](https://www.youtube.com/watch?v=LeKKU3a4AQo)
 - [Introduction to browser events](https://javascript.info/introduction-browser-events)
@@ -143,7 +159,7 @@ Take a look at this code:
 
 ```js
 const body = document.querySelector('body');
-body.addEventListener('click', function() {
+body.addEventListener('click', function () {
   body.style.background = 'black';
 });
 ```
@@ -156,7 +172,7 @@ This is DOM manipulation in its simplest form. It goes in three essential steps:
 (2) JavaScript is aware and looks for this specific user action (The browser is listening for the event, in this case a `click` event)
 (3) JavaScript modifies the DOM as a result (A function that makes the body background color black is executed)
 
-The second step is called **listening for the event**. We do this by using a by the browser predefined function called `addEventListener()`, which we get from the `document` object in the browser. The browser needs to listen to the event in order to know what it should do ("make the body background color black") in case a certain event (`click`) happens to a certain element (`body`).
+The second step is called **listening for the event**. We do this by using a browser predefined function called `addEventListener()`, which we get from the `document` object in the browser. The browser needs to listen to the event in order to know what it should do ("make the body background color black") in case a certain event (`click`) happens to a certain element (`body`).
 
 The third and final step is called **handling the event**. The term "handler" effectively means "taking care of" the event; the response to the event. The handler itself is nothing more than a function that executes more JavaScript code in order to manipulate a particular part of the page (either the element that experienced the event or a totally different part of the page).
 
diff --git a/Week2/MAKEME.md b/Week2/MAKEME.md
index 4c6ee8dd4..f26f2175c 100644
--- a/Week2/MAKEME.md
+++ b/Week2/MAKEME.md
@@ -38,9 +38,10 @@ console.log(doubleEvenNumbers(myNumbers)); // Logs "[4, 8]" to the console
 
 The `doubleEvenNumbers` function returns only the even numbers in the array `myNumbers` and doubles them. Like you've learned in the [README](README.md), this block of code isn't easy to decipher.
 
-Let's rewrite it.
+Let's rewrite it. Follow the steps:
 
-- Using the `map` and `filter` functions, rewrite the `doubleEvenNumbers` function.
+1. Research the [filter function](https://www.w3schools.com/jsref/jsref_filter.asp)
+2. Rewrite the `doubleEvenNumbers` function, replacing the `for-loop` with `filter`
 
 **Exercise 2: What's your Monday worth?**
 
@@ -69,11 +70,11 @@ const mondayTasks = [
 
 Let's assume your hourly rate is €25. How much would you earn on that day?
 
-- Write a program that finds out what your hourly rate on a Monday would be
-- Use the `map` array function to take out the duration time for each task.
-- Multiply each duration by a per-hour rate for billing and sum it all up.
-- Output a formatted Euro amount, rounded to Euro cents, e.g: `€11.34`.
-- Make sure the program can be used on any array of objects that contain a `duration` property with a number value
+1. Write a `function` that finds out what your hourly rate on a Monday would be
+2. Use the `map` array function to take out the duration time for each task.
+3. Multiply each duration by a per-hour rate for billing and sum it all up.
+4. Return a string value: a formatted Euro amount, rounded to Euro cents, e.g: `€11.34`.
+5. Make sure the `function` can be used on any array of objects that contain a `duration` property with a number value
 
 **Exercise 3: Lemon allergy**
 
@@ -85,9 +86,15 @@ const fruitBasket = ['Apple', 'Lemon', 'Grapefruit', 'Lemon', 'Banana', 'Waterme
 
 However, she forgot that you are allergic to lemons! Let's quickly dispose of them before you get an attack.
 
-- Write a function
-- Use the `filter` array function to take out the lemons
-- Output a string that says: "My mom bought me a fruit basket, containing [array of fruits] !"
+1. Write a function, called `removeLemons`
+2. Use the `filter` array function to take out the lemons
+3. Return a string with all the fruits in the fruitBasket
+
+Expected output:
+
+```js
+removeLemons(fruitBasket); // Returns "My mom bought me a fruit basket, containing Apple, Grapefruit, Banana, Watermelon!"
+```
 
 **Exercise 4: Collective age**
 
@@ -97,16 +104,27 @@ Have you ever wondered how old the HackYourFuture team members are? Or better ye
 const hackYourFutureMembers = [
   { name: 'Wouter', age: 33 },
   { name: 'Federico', age: 32 },
-  { name: 'Noer', age: 27 },
+  { name: 'Noer', age: 28 },
   { name: 'Tjebbe', age: 22 },
 ];
 ```
 
-- Write a program that calculates the combined age of every member
-- Make use of the `map` function to get the ages
-- It should contain a function that takes a callback
-- The callback adds all the ages together and returns the number
-- The main function should log the string "The collective age of the HYF team is: [number]" to the console, and afterwards return the number
+1. Write a `function`, called `calculateAges` that calculates the combined age of every member
+2. It takes 2 arguments: an object and a callback
+3. Make use of the `map` function to get the ages
+4. Declare another `function` (outside of `calculateAges`) that adds all the ages
+5. Return a string that contains the sum of all the ages
+
+Expected output:
+
+```js
+function addAges(...) {
+  ...
+}
+
+calculateAges(hackYourFutureMembers, addAges); // Returns "The collective age of the HYF team is: 115"
+
+```
 
 **Exercise 5: My favorite hobbies**
 
@@ -122,13 +140,15 @@ const myHobbies = [
 ];
 ```
 
-- Write a program that outputs each of these inside an HTML file
-- Create an HTML and JavaScript file, link them together
-- Use the `map` and/or `forEach` function to put each hobby into a list item
-- Output the list items in an unordered list
+1. Create an HTML (with a basic structure) and JavaScript file, link them together
+2. Inside the JS file write a `function` that outputs each of these inside an HTML file:
+   - Use the `map` or `forEach` array function to put each hobby into a list item
+   - Output the list items in an unordered list
 
 ## **3. Code along**
 
+> Create a new GitHub repository for this project. You can add it to your portfolio!
+
 Programming can be used to not only make websites, but also games! In the following tutorial you're going to apply your DOM manipulation skills in order to make a classic game: Rock, Paper, Scissors! Enjoy!
 
 - [Build a Rock, Paper, Scissors Game](https://www.youtube.com/watch?v=WR_pWXJZiRY)
@@ -150,9 +170,9 @@ Here are the requirements:
 - If the timer is running, the user can't change the session length anymore
 - Use at least 3 functions
 - Display minutes and seconds
-- If the timer finishes the timer should be replaced by the message: `Time's up!`
+- If the time is up the Pomodoro clock should be replaced by the message: `Time's up!`
 
-If you are having trouble understanding the functionality check this [demo](https://pomodoroclock-sandbox.mxapps.io).
+If you are having trouble understanding the functionality here's a [demo](https://pomodoroclock-sandbox.mxapps.io) for how it should work!
 
 Good luck!
 
@@ -163,7 +183,7 @@ After you've finished your todo list it's time to show us what you got! The home
 1. JavaScript exercises
 2. PROJECT: The Pomodoro Clock
 
-Upload both to your forked JavaScript2 repository in GitHub. Make a pull request to the original repository.
+Upload both to your JavaScript2 repository forked to your personal account in GitHub. Make a pull request to the [HackYourHomework/JavaScript2](https://www.github.com/hackyourhomework/javascript2).
 
 > Forgotten how to upload your homework? Go through the [guide](../hand-in-homework-guide.md) to learn how to do this again.
 
diff --git a/Week2/README.md b/Week2/README.md
index 808de176e..eb99f7c84 100644
--- a/Week2/README.md
+++ b/Week2/README.md
@@ -25,7 +25,7 @@ Let's look at code execution from another angle. The program that executes your
 
 Now imagine the following scenario:
 
-> Noer wants to have breakfast but he doesn't have any food at home. He decides he want to eat oatmeal. The ingredients (oats and milk) can be bought at the supermarket. How to do this? First Noer takes a shower. Then he puts on some clothes. Then some shoes. Then he opens the door and goes outside. Then he jumps on the bike and goes to the closest supermarket. After looking for some time he finds the ingredients. Then Noer buys the ingredients. Then he jump back on the bike and go home. Then he mixes the ingredients and makes oatmeal. Then Noer eats and feels amazing!
+> Noer wants to have breakfast but he doesn't have any food at home. He decides he wants to eat oatmeal. The ingredients (oats and milk) can be bought at the supermarket. How to do this? First Noer takes a shower. Then he puts on some clothes. Then some shoes. Then he opens the door and goes outside. Then he jumps on the bike and goes to the closest supermarket. After looking for some time he finds the ingredients. Then Noer buys the ingredients. Then he jump back on the bike and go home. Then he mixes the ingredients and makes oatmeal. Then Noer eats and feels amazing!
 
 In this example, each action could only happen after the previous has been completed. Noer can't put on his shoes, while taking a shower. Or, he can't eat oatmeal while he buys the ingredients.
 
@@ -35,7 +35,7 @@ As you can see, each action is executed in a synchronous manner. This is to say:
 
 ### Asynchronous
 
-Sometimes we want to do multiple things at the same time, without each action to be dependent on each other. Asynchronous execution avoids this bottleneck. You are essentially saying, “I know this function call is going to take a great deal of time, but my program doesn’t want to wait around while it executes.” Consider the following scenario:
+Sometimes we want to do multiple things at the same time, without each action to be dependent on each other. You are essentially saying, “I know this function call is going to take a great deal of time, but my program doesn’t want to wait around while it executes.” The answer to this is called `asynchronous execution`. Consider the following scenario:
 
 > 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!
 
@@ -60,7 +60,7 @@ function higherOrderFunction(anotherFunction) {
 
 // Example 2
 function anotherHigherOrderFunction() {
-  return function() {
+  return function () {
     return;
   };
 }
@@ -70,6 +70,8 @@ Why do we need them? A higher order function integrates multiple functions, whic
 
 > Higher order functions are a core concept within a programming paradigm called "functional programming". It's not relevant at all for you to know or care about this, but it's important to be exposed to it.
 
+- [How to Understand Callbacks & Higher Order Functions](https://www.youtube.com/watch?v=viQz4nUUnpw)
+
 ### Functions as arguments to other functions
 
 Imagine the following situation:
@@ -78,7 +80,7 @@ Imagine the following situation:
 
 This example illustrates the concept of **asynchronicity**: there are multiple processes happening simultaneously, without any single thing being dependent upon another. 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 answer to your friend's request to hang out).
 
-This is the utility of `callbacks`: they allow us to introduce asynchronicity into the control flow of an application.
+This is the utility of `callbacks`: they allow us to be able to do multiple things simultaneously. Or in more technical terms, introduce asynchronicity into the control flow of an application.
 
 Study the following resources to learn more about the importance of callbacks:
 
@@ -144,10 +146,10 @@ Note: while this mechanism is important to be aware of, keep in mind that you wo
 
 In simple terms, the `Event Loop` is a mechanism that operates in the browser. It keeps track of the order of execution of JavaScript commands. consists of 4 parts:
 
-1. Heap. This is where the browser assigns space in memory to each process
-2. Call Stack. This is the amount of JavaScript commands (read: function calls and events) that need to be executed
-3. Web APIs. These are objects (like the document) and functions (like XMLHttpRequest) that can be used within the JavaScript commands found in the Call Stack
-4. Callback Queue. This is the "waiting line" for asynchronous function calls
+1. **Heap**. This is where the browser assigns space in memory to each process
+2. **Call Stack**. This is the amount of JavaScript commands (read: function calls and events) that need to be executed
+3. **Web APIs**. These are objects (like the document) and functions (like XMLHttpRequest) that can be used within the JavaScript commands found in the Call Stack
+4. **Callback Queue**. This is the "waiting line" for asynchronous function calls
 
 To see it in action check out the following resources:
 
diff --git a/Week3/MAKEME.md b/Week3/MAKEME.md
index 58f28dc87..b82f7241a 100644
--- a/Week3/MAKEME.md
+++ b/Week3/MAKEME.md
@@ -19,46 +19,47 @@ Let's get familiar with basic Javascript concepts, with interactive exercises! C
 
 **Exercise 1: Add six**
 
-Declare a function called `createBase`. The function takes a number as a parameter and return a closure, that adds a number to the base number argument.
+In this exercise you'll work with closures.
 
-Call the function three times. The return values should be:
+1. Declare a function called `createBase`.
+   - It takes 1 argument: a number
+   - Returns a closure, that adds a number to the number argument.
+2. Call the function three times. The return values should be:
+   a) 15
+   b) 24
+   c) 36
 
-1. 15
-2. 24
-3. 36
-
-It should look a little like this:
+Expected output:
 
 ```js
-function createBase() {
-  // Put here your logic...
-}
-
 const addSix = createBase(6);
 
-// Put here your function calls...
-addSix();
+addSix(4); // Returns the number 10
 ```
 
 **Exercise 2: Take out the duplicates**
 
-Write a function called `removeDuplicates`, that takes in an array as an argument:
+We don't like repetition in our array of letters. Let's remove them!
+
+1. Write a function called `removeDuplicates`
+2. It takes one argument: the following array:
 
 ```js
 const letters = ['a', 'b', 'b', 'c', 'd', 'a', 'e', 'f', 'f', 'c', 'b'];
 ```
 
-The function should modifies the original array: it should remove duplicate letters and `return` the result. 
+3. Write logic that looks into the array and removes duplicates
+4. Return the modified array without the duplicates
 
-The end result should be:
+Expected output:
 
 ```js
-['a', 'b', 'c', 'd', 'e', 'f'];
+removeDuplicates(letters); // Returns ['a', 'b', 'c', 'd', 'e', 'f'];
 ```
 
 **Exercise 3: Guess the output**
 
-In this exercise you'll be presented with a code snippet. Your task is to guess the output and write out your reasoning in 50 words or less.
+In this exercise you'll be presented with a code snippet. Your task is to guess the output and write out your reasoning in 100 words or less.
 
 ```js
 // Snippet
@@ -75,7 +76,7 @@ x();
 
 **Exercise 4: Guess more**
 
-In this exercise you'll be presented with another code snippet. Guess the output and write out your reasoning in 50 words or less.
+In this exercise you'll be presented with another code snippet. Guess the output and write out your reasoning in 100 words or less.
 
 ```js
 // Snippet
@@ -98,14 +99,13 @@ console.log(y);
 
 **Exercise 5: The lottery machine**
 
-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!
-
-Write a function that takes 4 arguments.
+Don't you just love the thrill of the lottery? What if I told you we can make our own lottery machine?
 
-- A start value
-- An end value
-- A callback that executes if the number is divisible by 3
-- A callback that executes if the number is divisible by 5
+1. Write a function that takes 4 arguments.
+   - A start value
+   - An end value
+   - 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).
 
@@ -132,6 +132,8 @@ threeFive(10, 15, sayThree, sayFive);
 
 ## **3. Code along**
 
+> Create a new GitHub repository for this project. You can add it to your portfolio!
+
 In the following "code along" you'll be making a Booklist App. A user will be able to add books to a list by filling in a form, and also delete each book entry in the list.
 
 You'll make the app using vanilla JavaScript and CSS framework [Bootstrap](https://www.getbootstrap.com).
@@ -180,7 +182,7 @@ Finished? Good on you! The homework that needs to be submitted is the following:
 1. JavaScript exercises
 2. PROJECT: The Tip Calculator
 
-Upload both to your forked JavaScript2 repository in GitHub. Make a pull request to the original repository.
+Upload both to your JavaScript2 repository forked to your personal account in GitHub. Make a pull request to the [HackYourHomework/JavaScript2](https://www.github.com/hackyourhomework/javascript2).
 
 > Forgotten how to upload your homework? Go through the [guide](../hand-in-homework-guide.md) to learn how to do this again.
 
diff --git a/Week3/README.md b/Week3/README.md
index 439539c98..bc2c0a740 100644
--- a/Week3/README.md
+++ b/Week3/README.md
@@ -81,7 +81,7 @@ console.log(globalVariable);
 accessGlobalVariable();
 ```
 
-The second type of local scope is called **block scope**. A block, generally speaking, is any code wrapped within `{ }`. This includes conditional statements (`if` and `switch`) and loops (`for`, `while` and `do/while`).
+The second type of local scope is called **block scope**. A block, generally speaking, is any series of statements or expressions wrapped within `{ }`. This includes conditional statements (`if` and `switch`), loops (`for`, `while` and `do/while`) and functions.
 
 Go through the following resources to learn more about `scope`:
 
@@ -93,9 +93,26 @@ Go through the following resources to learn more about `scope`:
 
 As mentioned in the previous module, we prefer to declare variables using `const` and `let`. This is because the keywords are more descriptive and restrictive. This makes them easier to work with.
 
-In relation to scope both also behave differently: they are block scoped. This means that they can be accessed from outside a `{ }`.
+In relation to scope both also behave differently: they are block scoped relative to the place where they are defined. This means that they can only be accessed from a `{ }`.
 
-Go through the following resources to learn more about this:
+Look at the following:
+
+```js
+function someFunc() {
+  const blockScopedVar = 'this variable can only be accessed within this function';
+  console.log(blockScopedVar);
+}
+
+someFunc();
+
+console.log(blockScopedVar);
+```
+
+Try it out in your browser console and see what you get. You'll see that you the variable is only defined within the function, but not outside.
+
+Block scoping variables doesn't seem important now, but they will be later. The biggest reason why you'd want to do so is this: **You don't know want to access certain data from everywhere**. What if you could access your password to your email account, from the console? What if a hacker could?
+
+Go through the following resources to learn more about block scoped variables:
 
 - [How let and const are scoped in JavaScript](https://wesbos.com/javascript-scoping/)
 - [Should you truly never use var?](https://dev.to/johnwolfe820/should-you-never-truly-use-var-bdi)
@@ -116,13 +133,15 @@ However, this does NOT mean that the actual value given to the variable or funct
 
 Hoisting happens during `compile-time`.
 
-When you execute your JavaScript code, the interpreter goes through the code twice. The first time is called the `compile-time`, which is when your code is made ready to be executed: there will be safety checks, small optimizations and making sure the syntax is written correctly.
+When you execute your JavaScript code, the interpreter goes through the code twice. The first time is called the `compile-time`, which is when your code is made ready to be executed: there will be safety checks, small performance optimizations and making sure the syntax is written correctly.
 
 The second time is called `run-time`, which is where it actually executes your code by going through it line by line, doing the assignments, calling the functions, etc.
 
+Hoisting is a specific feature of how JavaScript works. Knowing about it allows you to better organize your variables and functions.
+
 For more research, check out the following:
 
-- [What is Hoisting in JavaScript?](https://medium.com/javascript-in-plain-english/https-medium-com-javascript-in-plain-english-what-is-hoisting-in-javascript-a63c1b2267a1h)
+- [What is Hoisting in JavaScript?](https://medium.com/javascript-in-plain-english/https-medium-com-javascript-in-plain-english-what-is-hoisting-in-javascript-a63c1b2267a1)
 
 ## 3. Closures
 
@@ -132,7 +151,7 @@ That's nice and all, but in order to really understand what it is and why we nee
 
 ### Execution context
 
-The execution context roughly equates to the 'environment' a function executes in. This consists of the following:
+The `execution context` roughly equates to the 'environment' a function executes in. This consists of the following:
 
 - The variable scopes
 - Function arguments
@@ -144,7 +163,7 @@ Checkout the following to learn more about why this is important:
 
 ### Why do we need closures?
 
-Closures are commonly used to give objects data privacy. We don't want certain data to be available globally. Think of it as "keeping something a secret. Take, for example, the following situation:
+Closures are commonly used to give objects `data privacy`: we don't want certain data to be available globally, but only accessible in the scope it was defined in. Think of it as "keeping something a secret". Take, for example, the following situation:
 
 > You want to log in to your email account, so you need a password. Usually you have that password in your head, or somewhere written down in a place that can only be accessed in a certain way. It's not out there in public, able to be accessed by anyone.
 
@@ -161,7 +180,7 @@ For further study please check the following resources:
 
 Becoming a good developer doesn't mean being good at any particular programming language: as a matter of fact, the language doesn't matter much.
 
-This is the secret behind being a good developer: if you understand the concept, structure and principles of what makes a software program work, it doesn't matter in what way (the syntax) it's written.
+This is the secret behind being a good developer: if you understand the concept, structure and principles of what makes an application work, it doesn't matter in what way (the syntax) it's written.
 
 This is also the reason why most developers, once they've mastered the fundamentals, are able to pick up another language quite easily. It's not because they have good memory; it's because they can recognize the patterns within the language.
 
diff --git a/hand-in-homework-guide.md b/hand-in-homework-guide.md
index df25de56c..7eaa48155 100644
--- a/hand-in-homework-guide.md
+++ b/hand-in-homework-guide.md
@@ -2,7 +2,7 @@
 
 In this module you'll submit your homework only using GIT and GitHub.
 
-1. [GitHub](https://www.github.com/HackYourFuture/JavaScript2)
+1. [GitHub](https://www.github.com/HackYourHomework/JavaScript2)
 
 ## 1. GitHub homework guide
 
@@ -26,7 +26,7 @@ EVERY WEEK
 6. Give the pull request a title in the following format:
 
 ```markdown
-Homework week 1 <Your name>
+Homework week 1 <YOUR_NAME>
 ```
 
 7. Submit the pull request from your forked repository branch into the `master` branch of the original repository (`HackYourHomework/JavaScript2`)

From 22790e42ebe29c1a5465d40a62be7ebdce800cb0 Mon Sep 17 00:00:00 2001
From: Noer Paanakker <noer@hackyourfuture.net>
Date: Tue, 14 Apr 2020 13:43:42 +0200
Subject: [PATCH 2/3] rewrote exercises week 3

---
 Week3/MAKEME.md                            | 17 ++++++++---------
 Week3/js-exercises/ex1-AddSix.js           | 16 +++++++++-------
 Week3/js-exercises/ex2-RemoveDuplicates.js | 12 ++++++------
 Week3/js-exercises/ex3-GuessTheOutput.js   | 17 +++++++++++------
 Week3/js-exercises/ex4-GuessMore.js        | 13 ++++++++++---
 5 files changed, 44 insertions(+), 31 deletions(-)

diff --git a/Week3/MAKEME.md b/Week3/MAKEME.md
index b82f7241a..e55d7e8be 100644
--- a/Week3/MAKEME.md
+++ b/Week3/MAKEME.md
@@ -101,24 +101,23 @@ console.log(y);
 
 Don't you just love the thrill of the lottery? What if I told you we can make our own lottery machine?
 
-1. Write a function that takes 4 arguments.
+1. Write a function, called `generateNumbers` that takes 4 arguments.
    - A start value
    - An end value
    - A callback that executes if the number is divisible by 3
    - A callback that executes if the number is divisible by 5
+2. `generateNumbers` generates an array containing values from start value to end value (inclusive).
 
-The function should first generate an array containing values from start value to end value (inclusive).
+Then the function should take the newly created array and iterate over it, and calling the first callback if the array value is divisible by 3. The callback should simply return the string "The number [i] is divisible by 3!"
 
-Then the function should take the newly created array and iterate over it, and calling the first callback if the array value is divisible by 3.
+If the iterated value is divisible by 5, execute the second callback. The callback should simply return the string "The number [i] is divisible by 5!"
 
-The function should call the second callback if the array value is divisible by 5.
-
-Both functions should be called if the array value is divisible by both 3 and 5.
+Both callbacks should be executed if the array value is divisible by both 3 and 5.
 
 Here is a starter template:
 
 ```js
-function threeFive(startIndex, stopIndex, threeCallback, fiveCallback) {
+function generateNumbers(startIndex, stopIndex, threeCallback, fiveCallback) {
   const numbers = [];
   // make array
   // start at beginning of array and check if you should call threeCallback or fiveCallback or go on to next
@@ -148,10 +147,10 @@ Happy learning!
 
 > Important! Place your code in the folder `Week3 \ project`.
 
-In this week's project you'll be making a Tip Calculator! A user can fill in 3 things:
+In this week's project you'll be making a Tip Calculator! In the webpage there's a form. A user can fill in the following:
 
 1. The amount of the bill
-2. How good the service was
+2. Rate how good the service was
 3. How many people will share the bill
 
 When the button is clicked a calculation is made and the user can read the tip amount underneath.
diff --git a/Week3/js-exercises/ex1-AddSix.js b/Week3/js-exercises/ex1-AddSix.js
index a801a72fd..e49ea2599 100644
--- a/Week3/js-exercises/ex1-AddSix.js
+++ b/Week3/js-exercises/ex1-AddSix.js
@@ -2,19 +2,21 @@
  
  ** Exercise 1: Add Six **
  
-Declare a function called `createBase`.The function takes a number as a parameter and
-return a closure, that adds a number to the base number argument.
-
-Call the function three times. The return values should be:
- 15, 24,  36
+  1. Declare a function called `createBase`.
+    - It takes 1 argument: a number
+    - Returns a closure, that adds a number to the number argument.
+  2. Call the function three times. The return values should be:
+    a) 15
+    b) 24
+    c) 36
 
  */
 
-function createBase( /* ???? */ ) {
+function createBase(/* ???? */) {
   // Put here your logic...
 }
 
 const addSix = createBase(6);
 
 // Put here your function calls...
-console.log(addSix());
\ No newline at end of file
+console.log(addSix());
diff --git a/Week3/js-exercises/ex2-RemoveDuplicates.js b/Week3/js-exercises/ex2-RemoveDuplicates.js
index aa9d0d7d0..dc760b5c2 100644
--- a/Week3/js-exercises/ex2-RemoveDuplicates.js
+++ b/Week3/js-exercises/ex2-RemoveDuplicates.js
@@ -2,20 +2,20 @@
  
  ** Exercise 2: The lottery machine **
 
-Write a function called removeDuplicates. This function accept an array as an argument
-does not return anything but removes any duplicate elements from the array.
+  1. Write a function called `removeDuplicates`
+  2. It takes one argument: the following array:
 
- The  function should remove duplicate elements.So the result should be:
+  const letters = ['a', 'b', 'b', 'c', 'd', 'a', 'e', 'f', 'f', 'c', 'b'];
 
+  3. Write logic that looks into the array and removes duplicates
+  4. Return the modified array without the duplicates
    
  */
 
-
 // WRITE YOUR FUNCTION HERE
 
 const letters = ['a', 'b', 'c', 'd', 'a', 'e', 'f', 'c', 'b'];
 
 removeDuplicates(letter);
 
-if (letters === ['a', 'b', 'c', 'd', 'e', 'f'])
-  console.log("Hooray!")
\ No newline at end of file
+if (letters === ['a', 'b', 'c', 'd', 'e', 'f']) console.log('Hooray!');
diff --git a/Week3/js-exercises/ex3-GuessTheOutput.js b/Week3/js-exercises/ex3-GuessTheOutput.js
index 7d783ceef..a938a3851 100644
--- a/Week3/js-exercises/ex3-GuessTheOutput.js
+++ b/Week3/js-exercises/ex3-GuessTheOutput.js
@@ -4,18 +4,23 @@
 
 Look at the bellow code snippet.
 Can you guess the output? 
-Write out your reasoning in 50 words or less.
+Write out your reasoning in 100 words or less.
 
 */
 
-
-
 let a = 10;
-const x = (function () {
+const x = (function() {
   a = 12;
-  return function () {
+  return function() {
     alert(a);
   };
 })();
 
-x();
\ No newline at end of file
+x();
+
+/*
+  Write out your reasoning here (100 words or less):
+
+
+
+*/
diff --git a/Week3/js-exercises/ex4-GuessMore.js b/Week3/js-exercises/ex4-GuessMore.js
index 81a4ec273..d047eb9f0 100644
--- a/Week3/js-exercises/ex4-GuessMore.js
+++ b/Week3/js-exercises/ex4-GuessMore.js
@@ -4,7 +4,7 @@
 
 Look at the bellow code snippet.
 Can you guess the output? 
-Write out your reasoning in 50 words or less.
+Write out your reasoning in 100 words or less.
 
 */
 
@@ -18,7 +18,7 @@ f1(x);
 console.log(x);
 
 const y = {
-  x: 9
+  x: 9,
 };
 
 function f2(val) {
@@ -26,4 +26,11 @@ function f2(val) {
   return val;
 }
 f2(y);
-console.log(y);
\ No newline at end of file
+console.log(y);
+
+/*
+  Write out your reasoning here (100 words or less):
+
+
+
+*/

From f37d9e96700d4b0c02f1da60ab3d3d0498300f19 Mon Sep 17 00:00:00 2001
From: Noer Paanakker <noer@hackyourfuture.net>
Date: Wed, 22 Apr 2020 14:57:20 +0200
Subject: [PATCH 3/3] Removed final step week 1 final exercise, rewrote
 exercise week 3

---
 Week1/MAKEME.md                            | 7 ++-----
 Week1/js-exercises/ex5-catWalk.js          | 3 +--
 Week2/README.md                            | 2 +-
 Week3/MAKEME.md                            | 6 +++---
 Week3/js-exercises/ex2-RemoveDuplicates.js | 8 +++++---
 5 files changed, 12 insertions(+), 14 deletions(-)

diff --git a/Week1/MAKEME.md b/Week1/MAKEME.md
index 42b39863b..71f243eff 100644
--- a/Week1/MAKEME.md
+++ b/Week1/MAKEME.md
@@ -123,12 +123,9 @@ Start with this webpage, which has a single img tag of an animated GIF of a cat
 
 1. Create a variable to store a reference to the `<img>`.
 2. Change the style of the `<img>` to have a "left" of "0px", so that it starts at the left hand of the screens.
-3. Create a function called catWalk() that moves the cat 10 pixels to the right of where it started, by changing the "left" style property.
-4. Call that function every 50 milliseconds. Your cat should now be moving across the screen from left to right.
+3. Create a function called `catWalk()` that moves the cat 10 pixels to the right of where it started, by changing the "left" style property.
+4. Call that function every **50 milliseconds**. Your cat should now be moving across the screen from left to right.
 5. When the cat reaches the right-hand of the screen, restart them at the left hand side ("0px"). So they should keep walking from left to right across the screen, forever and ever.
-6. When the cat reaches the middle of the screen, replace the `<img>` with an image of a cat dancing (use this URL: https://tenor.com/StFI.gif), keep it dancing for 5 seconds, and then replace the `<img>` with the original image and have it continue the walk.
-
-Expected result should look and behave similar to [https://dancingcat-sandbox.mxapps.io](https://dancingcat-sandbox.mxapps.io)
 
 ## **3. Code along**
 
diff --git a/Week1/js-exercises/ex5-catWalk.js b/Week1/js-exercises/ex5-catWalk.js
index 309eca0eb..cdb3d603e 100644
--- a/Week1/js-exercises/ex5-catWalk.js
+++ b/Week1/js-exercises/ex5-catWalk.js
@@ -8,6 +8,5 @@
  3. Create a  function called catWalk() that moves the cat 10 pixels to the right of where it started, by changing the "left" style property.
  4. Call that function every 50 milliseconds.Your cat should now be moving across the screen from left to right.Hurrah!
  5. When the cat reaches the right - hand of the screen, restart them at the left hand side("0px").So they should keep walking from left to right across the screen, forever and ever.
- 6. When the cat reaches the middle of the screen, replace the img with an image of a cat dancing(use this URL: https: //tenor.com/StFI.gif), keep it dancing for 5 seconds, and then replace the img with the original image and have it continue the walk.
  
-*/
\ No newline at end of file
+*/
diff --git a/Week2/README.md b/Week2/README.md
index eb99f7c84..37e0ed53c 100644
--- a/Week2/README.md
+++ b/Week2/README.md
@@ -60,7 +60,7 @@ function higherOrderFunction(anotherFunction) {
 
 // Example 2
 function anotherHigherOrderFunction() {
-  return function () {
+  return function() {
     return;
   };
 }
diff --git a/Week3/MAKEME.md b/Week3/MAKEME.md
index e55d7e8be..fc95ecbfd 100644
--- a/Week3/MAKEME.md
+++ b/Week3/MAKEME.md
@@ -42,14 +42,14 @@ addSix(4); // Returns the number 10
 We don't like repetition in our array of letters. Let's remove them!
 
 1. Write a function called `removeDuplicates`
-2. It takes one argument: the following array:
+2. It takes one argument, the following array:
 
 ```js
 const letters = ['a', 'b', 'b', 'c', 'd', 'a', 'e', 'f', 'f', 'c', 'b'];
 ```
 
-3. Write logic that looks into the array and removes duplicates
-4. Return the modified array without the duplicates
+3. Use an array function that takes out the duplicates
+4. Return the new, modified array without the duplicates
 
 Expected output:
 
diff --git a/Week3/js-exercises/ex2-RemoveDuplicates.js b/Week3/js-exercises/ex2-RemoveDuplicates.js
index dc760b5c2..f1e77d6a6 100644
--- a/Week3/js-exercises/ex2-RemoveDuplicates.js
+++ b/Week3/js-exercises/ex2-RemoveDuplicates.js
@@ -3,12 +3,14 @@
  ** Exercise 2: The lottery machine **
 
   1. Write a function called `removeDuplicates`
-  2. It takes one argument: the following array:
+  2. It takes one argument, the following array:
 
+  ```js
   const letters = ['a', 'b', 'b', 'c', 'd', 'a', 'e', 'f', 'f', 'c', 'b'];
+  ```
 
-  3. Write logic that looks into the array and removes duplicates
-  4. Return the modified array without the duplicates
+  3. Use an array function that takes out the duplicates
+  4. Return the new, modified array without the duplicates
    
  */