`).
+- An ` ` tag (for your picture)
+- Some `` tags
+
+When writing the CSS include the following:
+
+- Some CSS properties, like: `margin`, `padding`, `color`, etc.
+- You are **NOT** allowed to use CSS frameworks (like Bootstrap, MaterializeCSS, etc.)
+- Bonus: look into using [flexbox](https://www.youtube.com/watch?v=fYq5PXgSsbE) or [grid](https://www.youtube.com/watch?v=EFafSYg-PkI)
+
+## SUBMIT YOUR HOMEWORK!
+
+After you've finished your todo list it's time to show us what you got! The homework that needs to be submitted is the following:
+
+1. The CLI challenge
+2. A link to your *deployed* Digital Resume! Remember your CLI knowledge to figure out the URL to it (a webserver is just a computer and so the directories are part of the URL!)
+
+Upload both in a repository to GitHub and then upload the link to it on the Trello board: "Feedback Assignments". Go through the [guide](../hand-in-homework-guide.md) to learn how to do this.
+
+_Deadline Tuesday 23.59 CET_
diff --git a/Week1/README.md b/Week1/README.md
index d67afe8..c967827 100644
--- a/Week1/README.md
+++ b/Week1/README.md
@@ -1,50 +1,225 @@
-## Weekly Deliverables:
- * Understand the DOM structure
- * Get a feeling for HTML syntax
- * Get familiair with your text editor
- * Basic understanding of CSS syntax
- * Linking to external files
- * Structuring your files
-
-
-## Homework
-
-### Read these Chapters from the Front-end Handbook
- * What Is a Front-End Developer?
- * Part I. The Front-End Practice
-
-### Watch these videos:
- * How the Internet Works in 5 Minutes
- * How Web Browsers Work
-
-### Exercises:
- * Khan Academy: Into to HTML/CSS: Making webpages
-
-
-### Assignment:
- * Make your own web resume:
- * One page
- * Two files: HTML and CSS
- * Include the following:
- * Your personal info (name, place of birth, etc.)
- * A picture
- * A few lines about who you are
- * Education
- * Work experience
- * Include the following:
- * Different types of headings (h1, h2)
- * A list (ul)
- * img
- * p
- * Some css properties: margin, padding
- * Make sure that you page looks nice, and that your text is readable
- * upload in a zip
- * BEFORE you hand it in, read the Style guide and check your files (you can also use the HTML validator ).
-
-### Assignment:
- * Next week we will talk about responsive web design and using media queries start reading about this subject here Introduction to Media Queries . And take a look at this website here you can find examples of responsive design.
-
-
-### Helpful links:
- * https://developer.mozilla.org/en-US/docs/Learn/CSS/CSS_layout/Introduction
- * https://css-tricks.com/almanac/properties/
+# Reading Material HTML/CSS/GIT Week 1
+
+## Agenda
+
+These are the topics for week 1:
+
+1. What is the command line interface (CLI)?
+2. Introduction to HTML:
+ - Crash course
+ - The most commonly used tags
+ - Semantic HTML
+3. Introduction to CSS:
+ - Crash course
+ - Where to write it?
+ - The box model
+ - The cascading effect
+ - Specificity
+4. Working with the browsers
+ - What is a web browser?
+ - Choosing the right web browser
+ - How to use the inspector
+ - Useful browser extensions
+
+## 0. Video Lectures
+
+Your teacher Arco has made video lectures for this week's material. You can find them here: [Videos 1 - 6](https://www.youtube.com/playlist?list=PLVYDhqbgYpYXbAL_Hps1Y--THRmaTFipj)
+
+
+
+## 1. What is the command line interface (CLI)?
+
+The `Command Line interface` (also known as CLI or shell) is a way to navigate through your computer's content (media, folders, applications, etc.) without a visual user interface. It allows you to type text commands to perform specific tasks. Since you can directly control the computer by typing, many tasks can be performed more quickly, and some tasks can be automated with special commands that loop through and perform the same action on many files.
+
+As a beginning developer it's important to get familiar with it, as it will teach you how computers work: as tools that you give instructions to. This is not any different from programming for web development; but instead of writing instructions to the computer directly, you write instructions for browsers to execute!
+
+The first thing you'll notice is that once you type in a command, the computer doesn't always give back feedback. This is completely normal. Most of application development goes like that, and it's good to get used to it.
+
+**Note for Windows users**: Please install [Git for Windows](https://gitforwindows.org). It comes with an application called _Git BASH_ which simulates frequently used CLI commands in Unix fashion. This aligns our work here in this course, as we can all use the same commands. But there is an even bigger reason: Being comfortable in the Unix Bash shell is very important for a web developer, as web servers usually run Linux.
+
+For more information, check the following resources and code along:
+
+- [Understanding the Command Line for Beginners](https://learntocodewith.me/getting-started/topics/command-line/)
+- [A Command Line Primer for Beginners](https://lifehacker.com/a-command-line-primer-for-beginners-5633909)
+- [Command Line Crash Course](https://www.youtube.com/watch?v=yz7nYlnXLfE)
+
+## 2. Introduction to HTML
+
+### Crash course
+
+HTML is the foundation of web development. It is an acronym for **HyperText Markup Language**. It is used to structure content on a webpage. What do we mean by content? Plain text, images, videos, links to other websites, etc. The structure gives content meaning by defining that content as, for example, headings, paragraphs, or images.
+
+In order to learn HTML properly it's important to know what is is. Go through the following resources to learn more about it:
+
+- [HTML5 Basics - History of HTML](https://www.youtube.com/watch?v=NzzGt7EmXVw)
+- [HTML Crash Course](https://www.youtube.com/watch?v=UB1O30fR-EE)
+
+### The most commonly used tags
+
+If at any point you came to believe you would have to learn a whole list of tags by heart in order to write great HTML, you are in luck: that's not needed.
+
+The most important thing to know is that the tags are used to **structure content**, or in other words: to decide how each part is organized in order to more easily understand what the page is trying to communicate.
+
+It's useful to memorize this list, but don't feel like you have to learn and memorize _every_ HTML tag. Once you understand the basics, you can easily look up which tag you need.
+
+Check out the following article to find a list of the most commonly used tags: [The Most Commonly Used Tags](https://www.geeksforgeeks.org/most-commonly-used-tags-in-html/)
+
+## Semantic HTML
+
+Semantic HTML are HTML tags that introduce meaning to the web page rather than just presentation. For example, a `
` tag indicates that the enclosed text is a paragraph. A `` tag indicates a navigation menu of some kind. Both examples show meaning and structure, in this way it's easier to understand for both the browser and the developer.
+
+This leads to the following insight about writing code: while code is written to produce working software, it should also be written so **other developers can easily read and understand it**. That's why it's so important to write meaningful code: if somebody else can read it and understand what you meant you did a great job!
+
+Take a look at the following resources to learn more about semantic HTML:
+
+- [Semantic HTML](https://www.internetingishard.com/html-and-css/semantic-html/)
+- [HTML5 as Fast as Possible](https://www.youtube.com/watch?v=IsXEVQRaTX8)
+
+## 3. Introduction to CSS
+
+### Crash course
+
+CSS is just as important as HTML. It is an acronym for **Cascading Style Sheets**. It is a language created to change the appearance of content. By referring to the HTML tags you can `style` it in various ways: change the `font-size`, increase the `height` or attach a `background-image` to it.
+
+Go through the following video to get a firmer grasp of the fundamentals of CSS:
+
+- [CSS Crash Course](https://www.youtube.com/watch?v=yfoY53QXEnI)
+
+### Where to write it?
+
+There are 3 basic ways to write CSS:
+
+- In an external stylesheet: a `.css` file, that is linked to a `.html` file using the following tag:
+
+```html
+
+```
+
+- In the `` of a `.html` file. This is done using the `
+
+```
+
+- As part of the attribute `style` inside any HTML tag. This is called `inline styling`:
+
+```html
+HackYourFuture is cool!
+```
+
+In practice, you'll always write your CSS in separate `.css` files. This is because you want to make sure **every file has a single purpose**: an HTML file should only contain the content and structure of a page, while a stylesheet should only contain styling rules that apply to a page.
+
+This is a software design principle called [`separation of concerns`](https://softwareengineering.stackexchange.com/questions/32581/how-do-you-explain-separation-of-concerns-to-others).
+
+### The box model
+
+"In CSS, everything is a box". This phrase summarizes a central concept in HTML/CSS: the box model. When building a web page each element can be considered a box that has the following properties: `margin`, `border`, `padding` and `content`. Starting from the first element within the ``, everything that comes after will be pushed down (thanks to these 4 properties).
+
+To learn more about the box model, go through the following:
+
+- [Learn CSS Box Model In 8 Minutes](https://www.youtube.com/watch?v=rIO5326FgPE)
+- [Opening the Box Model](https://learn.shayhowe.com/html-css/opening-the-box-model/)
+
+### The cascading effect
+
+The first C in CSS stands for Cascading and it's crucial to learning how to use CSS correctly. Essentially, it means that it matters
+(1) **in which order** and
+(2) **how specific** you write CSS rules.
+
+Read the following articles to learn about it:
+
+- [The "C" in CSS](https://css-tricks.com/the-c-in-css-the-cascade/).
+- [How CSS works: understanding the cascade](https://blog.logrocket.com/how-css-works-understanding-the-cascade-d181cd89a4d8)
+
+### Specificity
+
+As there are multiple ways to write your css code which leads to multiple rules applying to the same html element CSS needs to decide which rule to follow. In the simplest form, if we for example have the following HTML:
+
+```html
+This paragraph should be styled normally
+
+ This paragraph should be styled differently as we add a class to the element
+
+```
+
+and the following CSS:
+
+```css
+p .explanation {
+ font-weight: 600;
+}
+
+p {
+ font-weight: 400;
+}
+```
+
+Then because the `p .explanation` rule is more specific than the `p` rule the `font-weight` of our second paragraph will be `600` even though the other rule was applied last. Read the following articles to learn more about how it works:
+
+- [Learn Basic CSS Selectors in 15 mins](https://www.youtube.com/watch?v=7kxhOI1Y38Y)
+- [Specifics on CSS specificity](https://css-tricks.com/specifics-on-css-specificity/)
+- Optional as it goes into every detail: [MDN's guide on Specificity](https://developer.mozilla.org/en-US/docs/Web/CSS/Specificity)
+
+## 4. Working with the browser
+
+### What is a web browser?
+
+You probably use it daily. Let's take a closer look at what it actually is.
+
+A `web browser` is software that allows you to view webpages, either retrieved from the internet or loaded from your computer. The primary function of a web browser is to render HTML files: transforming all the code (HTML, CSS and JavaScript) as well as the references (images, videos, etc.) to display a page correctly.
+
+For further study, delve into the following:
+
+- [What is a browser?](https://www.youtube.com/watch?v=TcbhVv9ty44)
+- [How web browsers work](https://www.youtube.com/watch?v=WjDrMKZWCt0)
+- [About your web browser](http://www.allaboutcookies.org/browsers/)
+
+### Choosing the right browser
+
+As a web developer you will write code that will display in different browsers. As such it is important that you get familiar with most major browsers in use today. These are:
+
+- [Google Chrome](https://www.google.com/chrome/)
+- [Safari](https://support.apple.com/downloads/safari)
+- [Mozilla Firefox](https://www.mozilla.org/en-GB/firefox/new/)
+- [Microsoft Edge](https://www.microsoft.com/en-us/windows/microsoft-edge)
+- [Opera](https://www.opera.com/download)
+
+There are other browsers popping up, but they are mostly enhancements of the Chromium OS browser which is the basis of Chrome. This generally means that if it works in Chrome, it will work on those browsers too.
+
+In your HackYourFuture journey you'll mainly be using **Google Chrome** when developing, as is has great developer tools that allow us to develop web applications in an easier and clearer way.
+
+### How to use the browser inspector
+
+The inspector is a part of web browsers developers can use to take a closer look at the composition of the HTML elements. This makes it easier to write HTML and CSS code that works.
+
+Watch the following videos and follow along:
+
+- [Using browser inspector tools](https://www.youtube.com/watch?v=WJIqIDm7CoA)
+- [Google Chrome Developer Tools Crash Course](https://www.youtube.com/watch?v=x4q86IjJFag)
+
+### Useful browser extensions
+
+As web developers we'll be dealing with the browser all the time. Why not upgrade our browser so it can make our programming life easier?
+
+A `browser extension` is a piece of software someone has written to increase the capability of the web browser. For example, if you hate receiving advertisements you probably use something like [Adblock](https://chrome.google.com/webstore/detail/adblock/gighmmpiobklfepjocnamgkkbiglidom) to block all the unwanted ads you might find in your webpages (if not, download it as soon as possible!).
+
+The following is a list of extensions that have proven to be useful during web development. This list only applies for Google Chrome, so if you don't have it, [install it](https://www.google.com/chrome/).
+
+Extensions:
+
+- Modify the technologies underlying each website, in real time, using [Web developer](https://chrome.google.com/webstore/detail/web-developer/bfbameneiokkgbdmiekhjnmfkcnldhhm/related?hl=en-US)
+- Expose what technologies a website is using with [WhatRuns](https://chrome.google.com/webstore/detail/whatruns/cmkdbmfndkfgebldhnkbfhlneefdaaip?hl=en-US)
+- If you ever wanted to know the exact color of any element in a page, you can now do so with [ColorZilla](https://chrome.google.com/webstore/detail/colorzilla/bhlhnicpbhignbdhedgjhgdocnmhomnp?hl=en-US)
+- When developing you'll be using dummy text to populate your elements. Enter [Loren Ipsum Generator](https://chrome.google.com/webstore/detail/lorem-ipsum-generator-def/mcdcbjjoakogbcopinefncmkcamnfkdb?hl=en%20)
+
+There are many more of these extensions and we encourage you to explore. See what fits your needs!
+
+## Finished?
+
+Are you finished with going through the materials? Nice job!!! If you feel ready to get practical, click [here](./MAKEME.md).
diff --git a/Week1/assets/github_pages1.png b/Week1/assets/github_pages1.png
new file mode 100644
index 0000000..54ceb5d
Binary files /dev/null and b/Week1/assets/github_pages1.png differ
diff --git a/Week1/assets/github_pages2.png b/Week1/assets/github_pages2.png
new file mode 100644
index 0000000..f61bb7a
Binary files /dev/null and b/Week1/assets/github_pages2.png differ
diff --git a/Week1/prep-exercises/01-bird-in-css/README.md b/Week1/prep-exercises/01-bird-in-css/README.md
new file mode 100644
index 0000000..a5b2c1f
--- /dev/null
+++ b/Week1/prep-exercises/01-bird-in-css/README.md
@@ -0,0 +1,18 @@
+# Create a bird using just HTML and CSS!
+
+Your task is to create the following bird using just html and css:
+
+
+
+Tips:
+
+- The beak is probably the hardest and may need some googling on how you can do triangles in CSS.
+- Remember to create an html as well as a css file, do not use inline styling!
+
+## Things to think about
+
+In this exercise you have seen that you can do quite cool things already with just some basic html/css knowledge. Before the session on Sunday, have a think about the following questions. You don't need to know or fill in the answers as they will be discussed on Sunday, but see if you can figure it out:
+
+- Which html element(s) did you use for each of the shapes? Why did you use that one/those?
+- If you couldn't change the css file that you just created but you are allowed to add a new css file, how would you change the color of the bird?
+- Can you think of a reason why you sometimes cannot change a css file?
diff --git a/Week2/LESSONPLAN.md b/Week2/LESSONPLAN.md
new file mode 100644
index 0000000..5619bb4
--- /dev/null
+++ b/Week2/LESSONPLAN.md
@@ -0,0 +1,82 @@
+# Lesson Plan Week 2
+
+## Agenda
+
+The purpose of this class is to introduce to the student (1) the basics of using GIT, and (2) the basics of grid-based thinking and using flexbox:
+
+- Basic GIT commands
+- Introducing GitHub
+- Setting up an SSH key pair
+
+- Introducing grid-based thinking
+- The problem Flexbox solves
+- Basic flexbox commands
+
+## Core Concepts
+
+FIRST HALF (12.00 - 13.30)
+
+## GIT
+
+### Explanation
+- GIT is software that allows us to keep track of the changes within our files
+- Imagine having written complex code that messed everything up, GIT allow us to return to a previous state where everything was still working
+- It can be used through the command line interface (CLI) or using a graphical user interface (also known as GUI): SourceTree, SmartGit, etc.
+
+### Example
+### Exercise
+
+_Create a new local repository and tell students to do the same_
+
+_Show the hidden file `.git` in the folder_
+
+- When you want to save your work, you can make a snapshot of your workspace: this is called 'committing your work', which is another way of saying 'saving your work'
+
+_Create a .txt file through the CLI and commit it to the local repository_
+
+_Delete the file and commit that change_
+
+- GIT allows us to revert our workspace to a previous commit. We can look for the right commit using `git log`, `git checkout` and `git revert`
+
+_Show the student the process of reverting back to the first commit_
+
+- GitHub is a development platform that allows us to store a copy of our code online (in developer terms: remote)
+- Main benefits are (1) store our code online, (2) let's us easily work together with others in the same repository
+
+_Ask students to create an account if they haven't_
+
+- In order to securely use GitHub we need to create an SSH key
+- SSH keys allow GitHub to identify us as a safe connection
+
+_Create an SSH key through the CLI_
+
+_Link the SSH key with your GitHub account_
+
+_Show how to clone the HTML-CSS-GIT repo using SSH_
+
+_Ask students to create an SSH key, link it to their account and clone the repo_
+
+### Essence
+
+
+
+
+SECOND HALF (14.00 - 16.00)
+
+## 2. Grid-based thinking and Flexbox
+
+### Explanation
+- Flexbox allows us to easily align elements on the page
+- It replaces float-based web design
+- It is activated with the `display: flex` CSS property, after you can make use of flex-specific properties
+### Example
+Take a look at the following [CodePen](https://codepen.io/enxaneta/pen/adLPwv) with students
+
+Look at the following [website](https://htmlstream.com/preview/unify-v2.6.2/unify-main/home/home-default.html) and dissect it thinking in grids
+### Excercise
+Rebuild the navigation bar, center image and reponsive website layout from this [example](https://github.com/ratracegrad/made-with-flexbox)
+
+Play the game! : https://flexboxfroggy.com/
+### Essence
+
+
diff --git a/Week2/MAKEME.md b/Week2/MAKEME.md
new file mode 100644
index 0000000..85915a6
--- /dev/null
+++ b/Week2/MAKEME.md
@@ -0,0 +1,87 @@
+## Homework HTML/CSS/GIT Week 2
+
+> Create a directory "week2" inside your `HYF-Module-HTMLCSSGIT` directory on GitHub. There should already be a "week1" folder that contains your homework from the last week.
+
+## Todo list
+
+1. Prep exercises
+2. GIT exercises
+3. Responsive design challenges
+4. Code along
+5. PROJECT: Responsive website
+6. Optional: Flexbox games
+
+### 1. Prep exercises
+
+> Prep exercises are exercises that you should work on _before_ the session on Sunday. These are a little more difficult or show an important concept and as such are a great exercise to talk about with your mentor. Have a solution ready by Sunday as you may be asked to show what you did.
+
+Inside your `HTML-CSS` fork, go to the folder `week2`. Inside of that folder, navigate to `/prep-exercises`. For each exercise, you will find a separate folder. The `README` explains what needs to be done. There will also be some questions at the bottom to think about. Go through them _before_ the session on Sunday as it will be covered then.
+
+### 2. GIT exercise
+
+1. Create a repository on Github called favorite-cmd-commands, make sure to check the checkmark about including a README file
+2. Clone that repository (Google how to clone a repository).
+3. Edit the `README.md` markdown file.
+4. Add bash commands that you like (at least 3) and style them as headers.
+5. Provide a short description (20 characters~) for each.
+6. Then `git add`, `git commit` and `git push` the file to your GitHub repository.
+
+### 3. Responsive design challenges
+
+Making websites that are `responsive` to a variety of device sizes (in other words, that still "look good" on any device), has become the standard way of building websites. You have to learn how to do this too. It's not as intimating as it might seem; you're **not** going to build a separate page for literally every device size out there.
+
+Instead, you'll be applying certain CSS rules only to certain device sizes: the average desktop (1024px and more), the average tablet (between 600px and 1024px) and the average mobile device (600px and below).
+
+In the following mini-course you'll get some practice in doing this:
+
+- [Responsive Web Design Challenges](https://learn.freecodecamp.org/responsive-web-design/responsive-web-design-principles/)
+
+### 4. Code along
+
+In the following video you'll be rebuilding a responsive HTML5 website. Put your focus on how the structure of the page is built: First HTML to provide structure & content, and then the CSS. Look at the HTML tags used and the names given to classes.
+
+- [Build A Responsive Website With HTML & CSS Tutorial](https://www.youtube.com/watch?v=ZeDP-rzOnAA)
+
+### 5. PROJECT: Responsive website
+
+> Tip: Use GIT and GitHub along the way, so that you can practice it!
+
+In this project you're going to rebuild `the homepage` of an existing responsive website. Choose one of the following:
+
+- [Codecademy](https://www.codecademy.com/)
+- [Uber](https://www.uber.com/nl/nl/)
+- [Adyen](https://www.adyen.com/)
+- [Patreon](https://www.patreon.com/)
+- [Coursera](https://www.coursera.org/)
+- [Triodos](https://www.triodos.nl/)
+
+You don't have to build everything, but include the following requirements:
+
+- Create a completely new repository on your GitHub for your website, you can name it _WEBSITENAME-copy_
+- Create an `index.html` to make your HTML
+- Design-wise it should be similar so the fonts, icons, text, etc. should look the same as the original
+- Only rebuild the homepage (which should include a navigation bar, footer, the landing section and at least 2 other sections. A section is one part of the website that contains information and that needs to adjust based on the screen size. A list of company logo's or a single button is not considered a section!)
+- Write your CSS in an external stylesheet
+- You are **allowed** to use a CSS framework if you have experience in it, but you do not have to. It is up to you!
+- Make use of `flexbox`
+- Download the assets (images, other forms of media) through the original webpage, or use your own!
+- Use media queries for both tablet and mobile (This might be same for the website you're making)
+- Deploy your website using Github Pages! It is very similar to what you did in week 1, have a look at the guide if you forgot how to do it.
+
+### 6. Optional: Flexbox games
+
+If you like learning in a fun way there are quite a few games on the internet that teach you the way flexbox works:
+
+- [Flexbox Froggy](https://flexboxfroggy.com/)
+- [Flexbox Defense](http://www.flexboxdefense.com/)
+- [Flexbox Adventure](https://codingfantasy.com/games/flexboxadventure)
+
+## SUBMIT YOUR HOMEWORK!
+
+After you've finished your todo list it's time to show us what you got! The homework you have to submit this week is the following:
+
+1. GIT exercise (the URL of the remote `favorite-cmd-commands` repository)
+2. A link to your repository of your copied website
+3. A link to your *deployed* copied website
+
+Go through the [guide](../hand-in-homework-guide.md) to learn how to submit your homework.
diff --git a/Week2/README.md b/Week2/README.md
index 74c86f4..aec3272 100644
--- a/Week2/README.md
+++ b/Week2/README.md
@@ -1,42 +1,268 @@
-## Weekly Deliverables:
- * Understand the HTML structure
- * CSS (id's, classes, selectors and attributes)
- * Tips and tricks
- * Understand the basics of Media queries
- * Understand why/ how to use which language
- * How to work with the inspector
- * Resume presentations
-
-## Homework
-
-### Read:
- * Introduction to media queries
- * More about media queries
- * HTML syntax
- * Article about mulitiple ways to select classes and id's
- * Read about nice color combinations
-
-### Exercises:
- * Udacity: Responsive web design fundamentals
-
-### Assignment:
- * Grids exercise
- * Download the html and images in the folder Homework3
- * You are going to write the css for this page
- * You are not allowed to change the html
- * The page contains two grids: the first one should work using floats, the second using flexbox. Be careful not to mix the two!
- * We want the grid to look as follows:
- * On mobile phones: a two column grid, with the exception that the first item spans the full width
- * On tablets: a three column grid, with the exception that the first two items span the full width together (so first we have two columns, then afther the first two items we have three columns)
- * On desktops: a four column grid, with the exception that the first item spans two columns.
- * There should be some space between the grid items
- * Make the page look beautiful by adding some more css! Some tips:
- * How about some nice colors, fonts, hover styles?
- * According to the grid specification, some products are bigger than others. Maybe these are "highlighted" products, so the rest of the styling could also be different.
- * BEFORE you hand it in, read the Style guide again and check your files
-
-## Extra extra:
-
-* Make a page including:
- * An animation using CSS keyframes
- * An SVG
+# Reading Material HTML/CSS/GIT Week 2
+
+## Agenda
+
+These are the topics for week 2:
+
+1. Introduction to GIT
+ - What is GIT?
+ - Installing GIT
+ - Basic GIT commands
+ - What is GitHub?
+ - Working with SSH
+2. More advanced CSS
+ - Flexible organizing with flexbox
+ - Using the grid layout
+ - Pseudo class selectors
+ - Responsive design with media queries
+3. Markdown
+
+## 0. Video Lectures
+
+Your teacher Arco has made video lectures for this week's material. You can find them here: [Videos 7 - 11](https://www.youtube.com/playlist?list=PLVYDhqbgYpYXbAL_Hps1Y--THRmaTFipj)
+
+
+
+## 1. Introduction to GIT
+
+### What is GIT?
+
+GIT is software that allows you to save your work at any given moment in time. It's typically called a `version control system`, which essentially means that it allows you to create `versions` of your workspace and makes possible to switch between older and newer states.
+
+You can think of it like a video game. You get to a certain point in the game, after hours of struggle. You're really proud of how far you've come, and don't want to do it over again in case you die. So you decide to _save your game_. If something bad happens after that point you can always reload your game and start from that point on.
+
+This is exactly what happens with GIT: however, instead of calling it _saving your game_ we call it **committing your changes**. A "change" is a code modification you made in one or more files. It's recommended to commit multiple times a day, every time you make something that is worth saving. Making commits often also makes it easier to reset your work to the last working state. Discarding changes with GIT is better than to trust on CTRL-Z to undo failed attempts.
+
+If you ever would want to go back to a previous _game save_ you can make GIT help you do so by **checking out to that commit**. You will learn more about that in the next sections.
+
+Check out the following short clip to learn about the essentials of GIT:
+
+- [GIT explained in 100 seconds](https://www.youtube.com/watch?v=hwP7WQkmECE)
+
+### Installing GIT
+
+In order to use GIT you first have to install it. The software is different depending on your operating system:
+
+- For Windows, install [Git Bash](https://git-scm.com/download/win)
+- For MacOS, install [GIT](https://git-scm.com/download/mac)
+- For Linux, install [GIT](https://git-scm.com/download/linux)
+
+After you've installed it you can use it through the CLI. To verify that it worked, enter the command:
+
+```bash
+git --version
+```
+
+It should say that the version is **2.21** (or up if you've installed a new version).
+
+You can work with GIT using only the CLI but you can also use a GUI (graphical user interface).
+Two free cross-platform examples are [SourceTree](https://www.sourcetreeapp.com/) and [Gitkraken](https://www.gitkraken.com/).
+It's up to personal preference what works the best, both CLI and GUI will use the same underlying system.
+You can even use both in the same project, e.g. commands on the CLI will reflect instantly in the GUI.
+The main advantage of a GUI is that it has a visual overview of all commits and branches, local and remote.
+
+Now that you have GIT installed, it's important to make a basic configuration. Inside your CLI, type in the following (Replace "Your name" and "your.email@youremailserver.com" with your own name and email address, respectively).
+In case you are using a GUI, it will probably ask the same data the first time you open the application, and it will do these commands for you.
+
+```bash
+git config --global user.name "Your name"
+git config --global user.email "your.email@yourmailserver.com"
+```
+
+This makes sure GIT is able to identify you as the person that uses it to save your files and folders.
+
+### Basic GIT commands
+
+You'll use GIT like any software you execute through the CLI.
+
+There are different ways of using GIT. For now we'll learn one procedure: **committing your workspace to a local repository**. Let's take that phrase apart first:
+
+- **Committing** is another word for saving or storing the changes you've made to the files in your workspace. For example, changing the content of a file is a "change".
+- **Workspace** is another word for the project folder (and its contents). When making a repository it will be in the root (in other words, the top level) of the folder.
+- **Local** refers to your computer, with no involvement of the internet. When you create a file or folder on your computer, you are creating it "locally".
+- **Repository** is a storage location containing the data regarding your project folder. GIT creates a hidden folder `.git` that functions as the local repository.
+
+Before we start we must know the most basic command of all:
+
+```bash
+git init
+```
+
+What it does is creating a brand new **local** repository in your project folder. Only after doing this you will be able to follow along the next procedure.
+
+Now we can continue with the actual procedure itself. This happens in 3 stages:
+
+1. **Untracked**. In this stage GIT is not aware of the changes in your workspace.
+2. **Staged**. In this stage the changes are selected for the next commit.
+3. **Committed** In this stage your changes have been saved into the local repository. If you need to refer to a previous version of your workspace you can safely do that now.
+
+This might sound very abstract, and it is. So to make it more comprehensible, you can watch the following videos and/or try stuff in the Git playground:
+
+- [GIT command line basics](https://www.youtube.com/watch?v=HVsySz-h9r4)
+- [Learn Git - using CLI & GitKraken](https://www.youtube.com/playlist?list=PLe6EXFvnTV7-_41SpakZoTIYCgX4aMTdU)
+- [Introduction to GIT - Core Concepts](https://www.youtube.com/watch?v=uR6G2v_WsRA)
+- [GIT & GitHub Crash Course](https://www.youtube.com/watch?v=SWYqp7iY_Tc)
+- [Git Playground](https://git-school.github.io/visualizing-git/)
+
+## What is GitHub?
+
+GitHub is **NOT the same** as GIT. While GIT is software that allows you to keep track of your files, GitHub is an online software development platform that allows you to store a copy of your code online. Check the following video to learn more:
+
+- [What is GitHub?](https://www.youtube.com/watch?v=w3jLJU7DT5E)
+
+We use GitHub because of its main benefit: it allows us to freely store our code online (or `remote`, as we developers also call it). This is useful, for example, in the case that our computer crashes and our projects are lost.
+
+The second benefit of using an online code storage is that it allows us to work together with other developers, using one central (and remote) repository. This is done using branches, which you will learn about [next week](../Week3/README.me).
+
+- [GIT Good: A Practical Introduction to GIT and GitHub I](https://codeburst.io/git-good-part-a-e0d826286a2a)
+- [GIT Good: A Practical Introduction to GIT and GitHub II](https://codeburst.io/git-good-a-practical-introduction-to-git-and-github-in-git-we-trust-f18fa263ec48)
+
+### Working with SSH
+
+SSH stands for Secure Shell and is a way of providing users a secure way of accessing (the content of) a computer over an unsecure network. Simply put, it makes the connection much more difficult to hack or intercept.
+
+When working with online (or what you'll hear more often: `remote`) code repositories, you might be dealing with unsecure connections. In order to make the connection more secure, you have to use an **SSH key**. Similar to a real key, this digital key allows your computer to be identified by the network you're trying to access. If the connection has been made you can access and modify the contents of network.
+
+> The concept of secure networking through use of identifiers (like an SSH key) is also known as "authentication": are you who you say you are? Authentication is a central idea within programming and you should keep it in mind. You'll also be seeing more of it in later modules!
+
+Check the following resources for more information:
+
+- [Beginners Guide To SSH](https://www.youtube.com/watch?v=qWKK_PNHnnA)
+- [How SSH works](https://www.youtube.com/watch?v=zlv9dI-9g1U)
+
+When working with GitHub we want to ensure the same level of security. Thus, we will have to make an SSH key and link it to GitHub!
+
+- [How to generate an SSH key](https://help.github.com/en/articles/generating-a-new-ssh-key-and-adding-it-to-the-ssh-agent)
+- [Adding SSH Key to GitHub](https://www.youtube.com/watch?v=H5qNpRGB7Qw)
+
+> Note that if you are in AZC then usually the SSH port is blocked on the internet. If that is the case you cannot use SSH, so you will need to do all your communication with git using HTTPS instead
+
+## 2. More advanced CSS
+
+By now you've had some practice with CSS. In the following sections you'll learn about some more essentials concepts in order to write modern stylesheets for the web!
+
+### Flexible organizing with flexbox
+
+CSS is used to order and style HTML elements. A big part of this is organising elements in a visually attractive way. This can be done using `flexbox`.
+
+What it does is helping you to think according to `grid-based web design`: elements are not randomly placed on the page, but are neatly organised along a grid.
+
+Read the following to learn more about 'grid-based web design':
+
+- [Introduction to grids in web design](https://webdesign.tutsplus.com/articles/a-comprehensive-introduction-to-grids-in-web-design--cms-26521)
+- [Intro to Web Design Grids](https://www.youtube.com/watch?v=gjYZoPEk0ow)
+
+Once you understand this way of thinking you'll know why it makes sense to use `flexbox`.
+
+In order to make use of it we have to access it through the `display` CSS property:
+
+```css
+display: flex;
+```
+
+This will give us the `flexbox`-specific properties, so we can develop clean and organised CSS. Check the following links to understand how this is done:
+
+- [Interactive guide to flexbox](https://www.joshwcomeau.com/css/interactive-guide-to-flexbox/)
+- [What is Flexbox and Why to Learn it](https://www.youtube.com/watch?v=CXSwNIPsyTs)
+- [CSS Flexbox Course](https://www.youtube.com/watch?v=-Wlt8NRtOpo)
+
+### Using the grid layout
+
+The most recent addition to the css toolkit for organising your layout is using `display: grid`. Where every other layout always goes from top to bottom, grid allows you to create a two-dimensional layout.
+
+The complete guide to grid by css-tricks is the go to guide, read it here:
+
+- [CSS-tricks complete guide to grid](https://css-tricks.com/snippets/css/complete-guide-grid/)
+
+### When to use flex and when to use grid
+
+A common question we get is when to use flexbox and when to use grid. Kevin Powell is a css master and does a great job of answering that question here:
+
+- [Flexbox or grid](https://www.youtube.com/watch?v=3elGSZSWTbM)
+
+### Pseudo class selectors
+
+Every HTML element can be in different states. The default state is when an element is untouched. You already know how to style for this.
+
+```css
+button {
+ background-color: white;
+}
+```
+
+There are times when a user interacts with an element. For example: clicking a button that opens another page. As frontend developers we need to give the user feedback on that particular action. When they place the mouse on top of the button it lights up (we call this a `hover state`). We need to write instructions for that to happen:
+
+```css
+button:hover {
+ background-color: blue;
+}
+```
+
+Like the hover state there are others as well: `click`, `focus`, `visited`, and others. For most of these element states we have special selectors. Read the following article to learn about them. Once you have done that, try them out for yourself!:
+
+- [Pseudo class selectors](https://css-tricks.com/pseudo-class-selectors/)
+- [Pseudo-Classes vs Pseudo-Elements in CSS](https://www.youtube.com/watch?v=0VDx1570X3U)
+
+### Responsive design with media queries
+
+Nowadays people use different devices to access websites: desktops, tablets and mobile phones of all different sizes. Responsive design is a way to put together a website so that it automatically scales its content and elements to match the screen size of the viewer. It prevents that images are larger than the screen width, so visitors on mobile devices will see a visually attractive website as well
+
+For more information about responsive design, check this article: [Responsive Design](https://www.internetingishard.com/html-and-css/responsive-design/).
+
+The primary way of making a responsive website is by writing custom CSS code that makes it so. This can be done using `media queries`: CSS instructions that only apply to certain screen sizes.
+
+Learn more about media queries here:
+
+- [Introduction to Media Queries](https://developer.mozilla.org/en-US/docs/Learn/CSS/CSS_layout/Media_queries).
+- [Learn CSS Media Query in 7 Minutes](https://www.youtube.com/watch?v=yU7jJ3NbPdA)
+
+### Layouts
+
+Now that you know about all the tools at your disposal it is time to look at creating layouts, which are the most basic design of your app/website. It is important to always do this step first as any changes in the layout will affect all of the other parts in the website, whereas the smaller parts should not affect the layout.
+
+Learn more about them here:
+- [The fundamentals of css layouts](https://www.youtube.com/watch?v=yMEjLBKyvEg)
+
+## 3. Markdown
+
+As you've probably seen, every project on GitHub comes with a file called `README.md`
+This readme file is used in general to outline the goal of the project and usually includes some code examples.
+
+Even the page you are reading now is also created using Markdown.
+
+Markdown is not a syntax that browsers understand, it is however really simple to write and read with any text editor.
+Many online GIT platforms, like GitHub, will parse Markdown files and display them as pretty HTML pages.
+Another good example on Markdown support is Slack. You can style your Slack messages using Markdown!
+
+A few examples of what you can do with Markdown:
+
+| HTML | Markdown |
+| ---------------------------- | -------------------------------------------- |
+| H1 | `# title` |
+| H2 | `## title` |
+| _Emphasis_ | `*italic` |
+| **Bold** | `**bold**` |
+| ~~Strikethrough~~ | `~~Scratch this.~~` |
+| [Link](#) | `[link text](https://somewhere)` |
+| `Single line of code
` | `` use single `backticks` around your code`` |
+
+If you want to show a bigger block of code, you start and end with 3 backticks
+
+````markdown
+```
+
+ ...
+ ...
+
+```
+````
+
+With Markdown you can to more things like images, list, checklists, tables and more.
+If you want to learn more about Markdown you could check these sources:
+
+- [Markdown Crash Course](https://www.youtube.com/watch?v=HUBNt18RFbo)
+- [Markdown Cheatsheet](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet)
+
+## Finished?
+
+Are you finished with going through the materials? Nice job!!! If you feel ready to get practical, click [here](./MAKEME.md).
diff --git a/Week2/assets/git-commit-flow.png b/Week2/assets/git-commit-flow.png
new file mode 100644
index 0000000..37c2ffd
Binary files /dev/null and b/Week2/assets/git-commit-flow.png differ
diff --git a/Week2/assets/img_htmltree.gif b/Week2/assets/img_htmltree.gif
new file mode 100644
index 0000000..d8882cf
Binary files /dev/null and b/Week2/assets/img_htmltree.gif differ
diff --git a/Week2/assets/wireframe.png b/Week2/assets/wireframe.png
new file mode 100644
index 0000000..d492a2a
Binary files /dev/null and b/Week2/assets/wireframe.png differ
diff --git a/Week2/prep-exercises/01-drones-website/README.md b/Week2/prep-exercises/01-drones-website/README.md
new file mode 100644
index 0000000..8952850
--- /dev/null
+++ b/Week2/prep-exercises/01-drones-website/README.md
@@ -0,0 +1,24 @@
+# Drones Website
+
+In this project you'll be building on an existing project. It's your job to make it `responsive` and look organised on various devices.
+
+The HTML and images are in this folder. You are going to write the CSS for this page, **it is not allowed to change the HTML**.
+
+The page contains two grids: the first one should work using `flexbox`, the second using `grid`. Be careful not to mix the two!
+
+Other than that you should use `media queries`. Here are the requirements for each device size:
+
+- On mobile phones (smaller than 600px): a one column grid, that spans the full width
+- On tablets (between 600px and 1024px): a three column grid, with the exception that the first two items span the full width together (so first we have two columns, then after the first two items we have three columns)
+- On desktops (1024px and up): a four column grid, with the exception that the first item spans two columns.
+- There should be some `margin` between the grid items
+
+So that it works like this:
+
+
+
+## Things to think about
+
+- Which way do you think is better for this use case? Flex or grid? What use cases can you think of that would make you use the other one?
+- Can every browser run both flex and grid? What about certain features of flex and grid? What is an easy way to see if browsers support a certain feature?
+- Did you use the browser inspector for the exercise? What is the reason for yes/no here?
diff --git a/Week2/Homework2/images/drone1.png b/Week2/prep-exercises/01-drones-website/images/drone1.png
similarity index 100%
rename from Week2/Homework2/images/drone1.png
rename to Week2/prep-exercises/01-drones-website/images/drone1.png
diff --git a/Week2/Homework2/images/drone2.png b/Week2/prep-exercises/01-drones-website/images/drone2.png
similarity index 100%
rename from Week2/Homework2/images/drone2.png
rename to Week2/prep-exercises/01-drones-website/images/drone2.png
diff --git a/Week2/Homework2/images/drone3.png b/Week2/prep-exercises/01-drones-website/images/drone3.png
similarity index 100%
rename from Week2/Homework2/images/drone3.png
rename to Week2/prep-exercises/01-drones-website/images/drone3.png
diff --git a/Week2/Homework2/images/drone4.png b/Week2/prep-exercises/01-drones-website/images/drone4.png
similarity index 100%
rename from Week2/Homework2/images/drone4.png
rename to Week2/prep-exercises/01-drones-website/images/drone4.png
diff --git a/Week2/Homework2/images/drone5.png b/Week2/prep-exercises/01-drones-website/images/drone5.png
similarity index 100%
rename from Week2/Homework2/images/drone5.png
rename to Week2/prep-exercises/01-drones-website/images/drone5.png
diff --git a/Week2/Homework2/images/drone6.png b/Week2/prep-exercises/01-drones-website/images/drone6.png
similarity index 100%
rename from Week2/Homework2/images/drone6.png
rename to Week2/prep-exercises/01-drones-website/images/drone6.png
diff --git a/Week2/Homework2/images/drone7.png b/Week2/prep-exercises/01-drones-website/images/drone7.png
similarity index 100%
rename from Week2/Homework2/images/drone7.png
rename to Week2/prep-exercises/01-drones-website/images/drone7.png
diff --git a/Week2/Homework2/index.html b/Week2/prep-exercises/01-drones-website/index.html
similarity index 81%
rename from Week2/Homework2/index.html
rename to Week2/prep-exercises/01-drones-website/index.html
index ca7a57c..ccc05cb 100644
--- a/Week2/Homework2/index.html
+++ b/Week2/prep-exercises/01-drones-website/index.html
@@ -3,83 +3,83 @@
- Grids
+ Drones
-
- Grid with floats
-
-
- Drone 6-AXIS + camera
+
+ Using flexbox
+
+
+ 6 Eksenli Drone + Kamera
- De Eddy Toys Drone is een instap drone met 6 assen en laat zich besturen door de meegeleverde 2.4Ghz controller met een bereik tot 50m hoogte.Vliegduur is 6 minuten.
+ Oyuncakçı Eddy’nin dronu yeni başlayanlar için, altı ekseni var. 2.4Ghz kumadasıyla hareket ederek 50 metre yüksekliğe kadar çıkabilir. Uçuş süresi ise 6 dakika.
-
+
DJI Mavic Pro Fly More Combo
- Met de Mavic, die direct opvalt vanwege zijn kleine afmeting, zet DJI een nieuwe standaard op het gebied van drones. De Mavic is zeer behulpzaam tijdens de niet altijd even makkelijke vluchten, vooral dankzij de vele ingebouwde technieken.
+ طائرة مافيك: مايميز هذه الطائرة هو صغر حجمها، وهي معيار جديد في مجال الطائرات من دون طيار. طائرة المافيك مفيدة كثيراً في الحالات التي لايكون الطيران فيها سهلاً، وذلك بفضل التقنيات العديدة المدمجة فيها.
-
+
DJI Phantom 4
De DJI Phantom 4 is een intelligente drone die onder meer automatisch obstakels vermijdt en 4K-beelden opneemt. Uiteraard is dit niet het enige waar de Phantom 4 indruk mee maakt. Wat dacht je van ActiveTrack, een sportmodus en een nog langere vliegduur.
-
+
DJI Phantom 3 Standard
Met een bereik van 500 meter, een Full HD-camera die met 30 fps opneemt en een f/2.8-lens maakt u met de DJI Phantom 3 standard de mooiste opnames vanuit de lucht.
-
+
YUNEEC Breeze 4K
De Breeze 4K van Yuneec is makkelijk te besturen, veilig en snel in staat opnames te delen. De drone wordt bestuurd met je iOS- of Android-apparaat en produceert indrukwekkende 4K-beelden.
-
+
SKEYE Nano Drone
Met de Nano Drone kan iedereen het gevoel van vliegen met een drone ervaren. De zeer kleine drone van slechts vier centimeter breed is na uitpakken direct klaar om te vliegen.
-
+
DJI Spreading Wings S900
Met prachtige luchtfoto's en -video's maak je indruk. De DJI Spreading Wings S900 is een lichtgewicht drone die met zijn draaggewicht van maximaal 8,2 kilogram voorziet in het maken van dergelijke beelden.
-
+
Drone 6-AXIS + camera
De Eddy Toys Drone is een instap drone met 6 assen en laat zich besturen door de meegeleverde 2.4Ghz controller met een bereik tot 50m hoogte.Vliegduur is 6 minuten.
-
+
DJI Mavic Pro Fly More Combo
Met de Mavic, die direct opvalt vanwege zijn kleine afmeting, zet DJI een nieuwe standaard op het gebied van drones. De Mavic is zeer behulpzaam tijdens de niet altijd even makkelijke vluchten, vooral dankzij de vele ingebouwde technieken.
-
+
DJI Phantom 4
De DJI Phantom 4 is een intelligente drone die onder meer automatisch obstakels vermijdt en 4K-beelden opneemt. Uiteraard is dit niet het enige waar de Phantom 4 indruk mee maakt. Wat dacht je van ActiveTrack, een sportmodus en een nog langere vliegduur.
-
+
DJI Phantom 3 Standard
Met een bereik van 500 meter, een Full HD-camera die met 30 fps opneemt en een f/2.8-lens maakt u met de DJI Phantom 3 standard de mooiste opnames vanuit de lucht.
-
+
YUNEEC Breeze 4K
De Breeze 4K van Yuneec is makkelijk te besturen, veilig en snel in staat opnames te delen. De drone wordt bestuurd met je iOS- of Android-apparaat en produceert indrukwekkende 4K-beelden.
-
+
SKEYE Nano Drone
Met de Nano Drone kan iedereen het gevoel van vliegen met een drone ervaren. De zeer kleine drone van slechts vier centimeter breed is na uitpakken direct klaar om te vliegen.
-
+
DJI Spreading Wings S900
Met prachtige luchtfoto's en -video's maak je indruk. De DJI Spreading Wings S900 is een lichtgewicht drone die met zijn draaggewicht van maximaal 8,2 kilogram voorziet in het maken van dergelijke beelden.
@@ -87,18 +87,18 @@ DJI Spreading Wings S900
-
- Grid with flexbox
-
+
+ flexbox with flexbox
+
Drone 6-AXIS + camera
- De Eddy Toys Drone is een instap drone met 6 assen en laat zich besturen door de meegeleverde 2.4Ghz controller met een bereik tot 50m hoogte.Vliegduur is 6 minuten.
+ Oyuncakçı Eddy’nin dronu yeni başlayanlar için, altı ekseni var. 2.4Ghz kumadasıyla hareket ederek 50 metre yüksekliğe kadar çıkabilir. Uçuş süresi ise 6 dakika.
DJI Mavic Pro Fly More Combo
- Met de Mavic, die direct opvalt vanwege zijn kleine afmeting, zet DJI een nieuwe standaard op het gebied van drones. De Mavic is zeer behulpzaam tijdens de niet altijd even makkelijke vluchten, vooral dankzij de vele ingebouwde technieken.
+ طائرة مافيك: مايميز هذه الطائرة هو صغر حجمها، وهي معيار جديد في مجال الطائرات من دون طيار. طائرة المافيك مفيدة كثيراً في الحالات التي لايكون الطيران فيها سهلاً، وذلك بفضل التقنيات العديدة المدمجة فيها.
DJI Phantom 4
diff --git a/Week3/LESSONPLAN.md b/Week3/LESSONPLAN.md
new file mode 100644
index 0000000..85b0240
--- /dev/null
+++ b/Week3/LESSONPLAN.md
@@ -0,0 +1,75 @@
+# Lesson Plan Week 3
+
+## Agenda
+
+The purpose of this class is to introduce to the student:
+
+- What is GIT branching?
+- Remote vs. local branches
+- What's a pull request?
+
+- What is a framework?
+- Popular CSS frameworks
+- Framework vs custom CSS
+
+## Core Concepts
+
+FIRST HALF (12.00 - 13.30)
+
+## 1. GIT branching
+
+### Explanation
+
+- A branch is an experiment, a possible way your project can evolve.
+- Local branch can be created with `git branch ` command. Remote branch must be set using `--set-upstream` option while pushing
+- Pull request is a `diff` between two commit points. It can be merged when we want to suggest changes to a Github repository to which we don't have write access.
+
+### Example
+
+Create a repository and initialize GIT. Show the use of `git branch`, `git checkout -b`
+
+### Exercise
+
+A fun exercise by [Arco](https://github.com/ArcoMul) to practise creating pull requests: [Cat pull request exercise](https://github.com/ArcoMul/netlify-cats)
+
+Instruction on how to set things up at Netlify: https://github.com/ArcoMul/netlify-cats/blob/main/SETUP.md
+
+### Essence
+
+
+SECOND HALF (14.00 - 16.00)
+
+## 2. CSS framework
+
+### Explanation
+
+- A software framework is prewritten code that provides generic functionality and a structure to build applications with
+- Analogy of pot of ingredients (see [example](./README.md) at section 2)
+- CSS frameworks allow for faster development
+
+- Pros and cons of framework
+
+ - PRO: Speeds up your development
+ - PRO: Enables cross-browser functionality
+ - PRO: Are usually maintained by a community of developers
+ - CON: It takes time to learn a framework
+ - CON: Lack of understanding the underlying CSS
+
+- Pros and cons of custom CSS
+ - PRO: Satisfies your specific needs
+ - PRO: Total control over the direction of CSS
+ - PRO: Creates a unique look
+ - CON: Have to maintain own code
+ - CON: You have to make sure it works cross-browser
+
+### Example
+
+Show various CSS frameworks: [MaterializeCSS](https://materializecss.com/), [Bootstrap](https://getbootstrap.com/), [Foundation](https://foundation.zurb.com/)
+
+### Exercise
+
+Give students an exercise to rebuild a button and navbar with custom CSS. Then let them do the same with any of the CSS frameworks you feel most comfortable with!
+
+### Essence
+
+A CSS framework is used to speed up development: it's prewritten code that provides the developer with basic structure and styling in order to create a presentable user interface.
diff --git a/Week3/MAKEME.md b/Week3/MAKEME.md
new file mode 100644
index 0000000..f67e0a6
--- /dev/null
+++ b/Week3/MAKEME.md
@@ -0,0 +1,84 @@
+## Homework HTML/CSS/GIT Week 3
+
+## Todo list
+
+1. Prep exercises
+2. Practice the concepts
+3. Code along
+4. Optional: Practice using frameworks
+5. Optional: Side project ideas
+6. Final notes
+
+### 1. Prep exercises
+
+> Prep exercises are exercises that you should work on _before_ the session on Sunday. These are a little more difficult or show an important concept and as such are a great exercise to talk about with your mentor. Have a solution ready by Sunday as you may be asked to show what you did.
+
+Inside your `HTML-CSS` fork, go to the folder `week3`. Inside of that folder, navigate to `/prep-exercises`. For each exercise, you will find a separate folder. The `README` explains what needs to be done. There will also be some questions at the bottom to think about. Go through them _before_ the session on Sunday as it will be covered then.
+
+### 2. Practice the concepts
+
+We'll start the week off with some more GIT practice! Go through the following:
+
+1. [Learn Git branching](https://learngitbranching.js.org/)
+2. [How to Use GIT and GitHub](https://eu.udacity.com/course/how-to-use-git-and-github--ud775)
+3. [Git katas](https://github.com/eficode-academy/git-katas/blob/master/Overview.md) (Do 1-4 of the Basic Git Katas and have a quick look at the Katas that solve standard problems section so you know what to do when you encounter those situations. The rest is more advanced, but bookmark this page and go through them later on when you start getting more comfortable with Git basics)
+
+### 3. Code along
+
+In this code along you'll continue practicing your skill by building a fully responsive website:
+
+- [Build a responsive website](https://www.youtube.com/watch?v=p0bGHP-PXD4)
+
+> Tip: Use GIT and GitHub along the way to practice!
+
+### 4. Optional: Practice using frameworks
+
+Some people love using frameworks, others like being in full control of the CSS. This is a personal thing and also differs per company so there is no one way that the world works here. If you have time and are interested, then have a look at the following tutorials for the different frameworks:
+
+#### Bootstrap
+
+Bootstrap is probably the most used CSS framework if a framework is being used. Have a look at the following links to know how to use it:
+
+- [Bootstrap 5 Crash Course](https://www.youtube.com/watch?v=4sosXZsdy-s)
+- [Making a complete responsive website using Bootstrap/HTML/CSS](https://www.youtube.com/watch?v=zhllkjYYUVE)
+
+#### Materialize
+
+In this section you're going to get familiar with [MaterializeCSS](https://materializecss.com/), a CSS framework based on Material Design - a design language created by Google.
+
+- [Materialize Tutorial](https://www.youtube.com/playlist?list=PL4cUxeGkcC9gGrbtvASEZSlFEYBnPkmff)
+- [Build A Travel Agency Theme With Materialize CSS](https://www.youtube.com/watch?v=MaP3vO-vEsg)
+
+### 5. Optional: Side project ideas
+
+> A part of the HackYourFuture curriculum is to work on as many side projects as you can throughout the time you have. This is a nice way to add extra knowledge to your arsenal and show in your CV that you are motivated to learn new technologies. There are plenty of people available to help you out in the `#get-help` channel on Slack so definitely make use of that! Have a look at the [hyf_projects repo](https://github.com/HackYourFuture/hyf_projects/blob/main/README.md#project-2-a-try-out-application) for more details.
+
+#### 5.1 CSS preprocessor
+
+In the wild you may also encounter the following terms: Less, SCSS, Sass. These are CSS preprocessors that give you some extra functionality when working with CSS. You can, for example, create certain blocks of css code (mixins) that you can then use in multiple places allowing you to make sure that if you change the css in that mixin it is changed everywhere automatically. The preprocessor will convert your code to actual CSS files and the browser will be none the wiser.
+
+For more information, have a look at:
+
+- [Sass vs SCSS vs Less: tutorial](https://marksheet.io/sass-scss-less.html)
+
+You can try to recreate your project from week 2 using one of these CSS preprocessors but you may need to add a couple more pages from the original website. The strength of the preprocessors comes when you have a lot of closely related css.
+
+#### 5.2 Parallax effect
+
+You may have seen some [beautiful websites](https://www.awwwards.com/30-great-websites-with-parallax-scrolling.html) that look more like art than a website. The techniques used in these websites are broadly called the Parallax effect and it works by making the website respond to mouse movements or scrolling. Imagine how a cool website like that would look on your CV.
+
+Try to copy one of the examples! Note that you will need to have a little bit of JavaScript knowledge to do this so if you don't have any previous programming experience you may want to wait until you have done some of the JavaScript weeks.
+
+### 6. Final notes
+
+In this module and especially this last week we have bombarded you with a lot of different ways to create your styles. In the rest of the curriculum we will leave it up to you to decide what way you like to work. Per project that you do, think about how you want to manage your css. You can either:
+
+- **Write the CSS yourself**. This will allow you to have full control over the styles enabling you to make any changes you want, but will probably take some more time initially to make sure everything works.
+- **Use a CSS framework**. If you had time to go through the frameworks, you may decide that you want to use the speed that they offer and don't mind the loss of some customizability.
+- **Use a CSS preprocessor**. If you had the time to try these out and like that they solve a couple of problems you have writing the CSS yourself then use these. They require a little setting up though that could complicate things, so make sure you understand how that works.
+
+You will always have to write some css yourself, but make sure to always choose only _one_ way of working per project, otherwise you are going to create a mess! If you are up for the challenge, then feel free to try different ways per project. It's always good to try different things!
+
+## SUBMIT YOUR HOMEWORK!
+
+There is no homework this week, spend your time working on the parts you found difficult or copying another website like you did last week!
diff --git a/Week3/README.md b/Week3/README.md
index 5cbacf8..325f94f 100644
--- a/Week3/README.md
+++ b/Week3/README.md
@@ -1,33 +1,134 @@
-## Weekly Deliverables:
- * Presentations of students website remakes
- * Repeat topics of last two weeks:
- * Understand why/ how to use which language
- * Media-queries
- * DOM
- * File structure, external links
- * How to find information on the web
-
-
-## In class:
- * Task: find some info about a certain topic in groups of 2, present to each other
- * Choose one of the following subjects, look up how it works and implement it in a webpage
- * CSS transitions
- * CSS animations with keyframes
- * SVG
- * Dropdown menu in CSS
- * flex-box
-
-## Homework
-
-### Assignment:
- * Remake an existing responsive website: choose one of the following
- * https://www.rijksoverheid.nl
- * http://www.awwwards.com
- * https://www.bostonglobe.com
- * https://www.thinkwithgoogle.com
- * http://muumilaakso.tampere.fi/en/
- * http://incredibletypes.com
- * http://thenextweb.com
- * It should have an external CSS file
- * BEFORE you hand it in, read the Style guide again and check your files
+# Reading Material HTML/CSS/GIT Week 3
+## Agenda
+
+These are the topics for week 3:
+
+1. GIT branching
+ - Local branches
+ - Working with branches on GitHub
+ - Making pull requests
+2. CSS Frameworks
+ - Why use a framework?
+ - Most popular frameworks
+ - CSS Framework vs. custom CSS
+
+## 0. Video Lectures
+
+Your teacher Arco has made video lectures for this week's material. You can find them here: [Videos 12 - 15](https://www.youtube.com/playlist?list=PLVYDhqbgYpYXbAL_Hps1Y--THRmaTFipj)
+
+
+
+## 1. GIT branching
+
+### Local branches
+
+`Branches` are a core feature of GIT. A branch allows you to work on a different "version" of your project. Take a look at the following image:
+
+
+
+Whenever you make a branch, you're creating an exact copy of your workspace that you can work with. Try it out:
+
+```md
+Go into a folder and initialize GIT to create a local repository. Then create a branch. In this new branch, create some basic files. **stage** and **commit** the changes you've made. Now, switch back to the original branch (**main**). What do you see? Nothing! That's because in that branch you didn't make those changes. If you switch back to the other branch you will see the files you've created again. Magic!
+```
+
+You can see a branch as an experiment, a possible way your project can evolve. Usually, each branch (except the `main` branch) contains code for what is called a new `feature`: a piece of functionality that you want to add to your software. Let's take Facebook as a simple example: After creating an account (which is a feature itself) you can do multiple things. Each "thing" is a feature: having a news feed, being able to send friend requests or liking posts.
+
+Working with branches is especially important when working with other developers. This only applies when working with a **remote** repository, which we'll talk about in the next section.
+
+When working with different branches it is useful to have one single branch that contains all the working and finished code: the `main` branch (we call it main out of convention, but in actuality you can name it whatever you want). Whenever you're working on a project that has already been put on the internet, it is the code from the main branch that is online.
+
+However, usually there's a separate branch that contains all the development code. Of course, this is called the `development` branch. This branch is an almost exact copy of main, but contains features that have not been tested yet.
+
+After finishing a feature, it is time to merge the branch into the main branch. This is usually either the `main` or `development` branch.
+
+Once the new version of the software has been tested and approved, the cycle repeats!
+
+Go through the following resources to learn more:
+
+- [Git Tutorial: Branches](https://www.youtube.com/watch?v=sgzkY5vFKQQ)
+- [Introduction to GIT - Branching and Merging](https://www.youtube.com/watch?v=FyAAIHHClqI)
+
+### Working with branches on GitHub
+
+While working with branches works a bit differently on GitHub (because of its user interface) the concept remains the same: you always want to have a main branch that holds all your stable, working code. Any other branches will contain software features that eventually will be merged into main.
+
+Go through the following project to learn how to work with branches on GitHub:
+
+- [GitHub 'Hello World' Project](https://guides.github.com/activities/hello-world/)
+
+### Making pull requests
+
+A **pull request** is a term GitHub uses to refer to a request to incorporate code changes from one branch made by a developer (whether it's you or another developer) into the code stored in a different branch of a repository.
+
+> Sometimes you'll hear developers speak of "merge requests". This is just another name for the same thing: pulling changes from another branch or fork into your branch and merging the changes with your existing code. Software development platforms like GitLab (an alternative to GitHub) use this the term "merge request" instead of "pull request".
+
+These changes are made in one branch, and the pull request usually is made to merge into the `main` branch. However, this doesn't happen directly: in normal circumstances, there has to be at least one other person reviewing the proposal before it is approved to be merged. The reason why is simple: it's very easy to merge code that might be buggy or conflicts with what's already there.
+
+- [GitHub Pull Request in 100 Seconds](https://www.youtube.com/watch?v=8lGpZkjnkt4)
+
+Pull requests only happen in remote repositories. This can happen in 2 ways:
+(1) From one branch to another **within the same repository**. For more information on this, read:
+
+- [Creating a pull request](https://help.github.com/en/articles/creating-a-pull-request)
+
+(2) From one branch to another branch **from a forked repository into the original repository**. A `fork` is a copy of a repository, that is stored in your personal GitHub account. Forks let you make changes to a project without affecting the original repository. You can fetch updates from or submit changes to the original repository with pull requests.
+
+While both are important to know about, it's useful to study the second way a little more in-depth because that's how you'll submit your homework:
+
+- [About forks](https://help.github.com/en/articles/about-forks)
+- [GitHub Homework flow](https://www.youtube.com/watch?v=CpYARPYGQU8)
+
+Also the following diagram will help you in understanding the principles of flow movements between the local and remote repositories.
+
+
+
+## 2. CSS Frameworks
+
+In order to explain CSS frameworks, we first must understand what a framework is. Let's illustrate this using an analogy.
+
+Let's suppose you want to make a ginger tea on daily basis. You do this with several ingredients: water, pieces of ginger and sugar. Doing so you will find it is really difficult to put all ingredients in the right proportions, to get the right flavor, all the time.
+
+One morning you come up with idea of mixing all the ingredients in one jar in the correct proportion, such that every spoon will serve the right amount to make the tea.
+
+This jar is your framework. By using it you don't have to think about the ingredients, nor the proportions. Only about how much you want to use to fit your needs.
+
+Or here's another analogy:
+
+Imagine you want to make star-shaped pancakes. That's pretty hard to do by itself, so you choose to use a mold. The mold helps you "structure" the pancake. All you need to add is the right content, which is the pancake batter.
+
+This mold is your framework. By using it, you need only think about the actual content you want to use. The rest will be taken care of for you.
+
+> Tip: The concept of a framework will come back many times, as we don't want to reinvent the wheel every time we create a new application. The point of any piece of software is to write it as simply as possible, and a framework really helps with that. So keep it in mind!
+
+### Why use a CSS framework?
+
+A CSS framework allows you to style your HTML reliably, by making use of pre-defined CSS rules. This way you don't have to think about what custom CSS you have to write to make something the way you want. This is useful mainly to **speed up development**.
+
+There are other reasons as well which you can learn about in the following article:
+
+- [What are the benefits of using a CSS framework](https://css-tricks.com/what-are-the-benefits-of-using-a-css-framework/)
+
+It does come with a drawback, however, and that is that it forces you into a specific design and adjusting things to your needs will be more difficult.
+
+### Most popular frameworks
+
+There are a lot of different CSS frameworks out, each with their pros and cons. In the following video you'll learn about several of the top ones used and what problems exactly they're trying to solve:
+
+- [CSS frameworks](https://www.youtube.com/watch?v=AMDx0IIgiK4)
+
+### CSS Framework vs. custom CSS
+
+As a general rule, you always want to be able to write custom CSS when needed. And if you're using a framework, you need to at least know why it works the way it does. This means that you look at the **documentation** of that particular CSS framework first. Alternatively, you could also look into the class definition within the stylesheet (you can use the browser inspector for this, more on that later).
+
+However, writing custom CSS is in practice not always possible. This could be because of project deadlines, lack of skill or wanting to do rapid prototyping (a technique to quickly build a working version in order to test if it works). This is when we use frameworks to help us out.
+
+Keep in mind that a framework should be there only to assist, not compensate or define your application. Research the following resources to learn about the pros and cons of CSS frameworks:
+
+- [Are CSS Frameworks Bad?](https://www.youtube.com/watch?v=VlY5CfkL760)
+- [Discussing the Pros and Cons of Using a CSS Framework](https://speckyboy.com/discussing-the-pros-and-cons-of-using-a-css-framework/)
+
+## Finished?
+
+Are you finished with going through the materials? Nice job!!! If you feel ready to get practical, click [here](./MAKEME.md).
diff --git a/Week3/assets/branches.png b/Week3/assets/branches.png
new file mode 100644
index 0000000..ba08bd0
Binary files /dev/null and b/Week3/assets/branches.png differ
diff --git a/Week3/assets/diagram.jpeg b/Week3/assets/diagram.jpeg
new file mode 100644
index 0000000..95252e3
Binary files /dev/null and b/Week3/assets/diagram.jpeg differ
diff --git a/Week3/prep-exercises/01-animals-repo/README.md b/Week3/prep-exercises/01-animals-repo/README.md
new file mode 100644
index 0000000..19a4fa9
--- /dev/null
+++ b/Week3/prep-exercises/01-animals-repo/README.md
@@ -0,0 +1,27 @@
+# Animals repo
+
+In this homework you'll be working with GIT and GitHub. Follow the steps to learn how to create a remote repository and work with it from your local machine:
+
+1. Create a repository on GitHub, called `animals`
+2. Clone the repository to your local machine, using the SSH URL
+3. Locally, create a file called "zoo.txt". Include 3 animals found in a zoo
+4. Add and commit the file to the local repository. Make sure the commit message is meaningful (ex. "created txt file with animal names")
+5. Push your commit to the remote repository, verify that it has worked on GitHub
+6. Go back to your local repository and create a branch called `new-feature`
+
+> Tip: in software, a "feature" is a technical term that points to any functionality that a user can derive benefit from. For example, Facebook has many features: the ability to make a profile, like a post, place comments, etc.
+
+7. Inside the new branch, create a file called "pets.txt". Include 3 animals that could be a pet
+8. Also, add 2 more animals to the "zoo.txt" file
+9. Add and commit the file to the local repository. Again, make sure the commit message is meaningful
+10. Push your commit to the remote repository, verify that it has worked on GitHub
+11. On GitHub, find out how to merge branch `new-feature` into `main`
+12. Merge the branches
+13. Switch back to branch `main`
+14. Pull the changes from your remote repository to your local repository, verify that everything worked
+
+## Things to think about
+
+- Why do you think we develop features in a branch rather than straight away pushed to `main`? Is there a situation that pushing to the `main` branch directly is better?
+- What would happen if you create two different branches that edit the same file and then merge them after each other?
+- Why do you think is the commit message important?
diff --git a/assets/bird.png b/assets/bird.png
new file mode 100644
index 0000000..6d7098d
Binary files /dev/null and b/assets/bird.png differ
diff --git a/assets/github-logo.png b/assets/github-logo.png
new file mode 100644
index 0000000..63a59be
Binary files /dev/null and b/assets/github-logo.png differ
diff --git a/assets/github_pages1.png b/assets/github_pages1.png
new file mode 100644
index 0000000..54ceb5d
Binary files /dev/null and b/assets/github_pages1.png differ
diff --git a/assets/github_pages2.jpg b/assets/github_pages2.jpg
new file mode 100644
index 0000000..4a93da6
Binary files /dev/null and b/assets/github_pages2.jpg differ
diff --git a/assets/github_pages3.jpg b/assets/github_pages3.jpg
new file mode 100644
index 0000000..469e198
Binary files /dev/null and b/assets/github_pages3.jpg differ
diff --git a/assets/module1.png b/assets/module1.png
new file mode 100644
index 0000000..6aef461
Binary files /dev/null and b/assets/module1.png differ
diff --git a/assets/slack-logo.png b/assets/slack-logo.png
new file mode 100644
index 0000000..b41f9ca
Binary files /dev/null and b/assets/slack-logo.png differ
diff --git a/assets/trello-logo.png b/assets/trello-logo.png
new file mode 100644
index 0000000..a78c2b2
Binary files /dev/null and b/assets/trello-logo.png differ
diff --git a/assets/trello.-logopng.png b/assets/trello.-logopng.png
new file mode 100644
index 0000000..a78c2b2
Binary files /dev/null and b/assets/trello.-logopng.png differ
diff --git a/assets/vscode-logo.png b/assets/vscode-logo.png
new file mode 100644
index 0000000..ee7d5b5
Binary files /dev/null and b/assets/vscode-logo.png differ
diff --git a/assets/week1-arco.png b/assets/week1-arco.png
new file mode 100644
index 0000000..d1d66d5
Binary files /dev/null and b/assets/week1-arco.png differ
diff --git a/assets/weekflow.png b/assets/weekflow.png
new file mode 100644
index 0000000..9da0971
Binary files /dev/null and b/assets/weekflow.png differ
diff --git a/hand-in-homework-guide.md b/hand-in-homework-guide.md
new file mode 100644
index 0000000..4e14519
--- /dev/null
+++ b/hand-in-homework-guide.md
@@ -0,0 +1,49 @@
+# How to hand in homework
+
+During this module you will hand in your homework in the following order:
+
+1. [GitHub](https://www.github.com/HackYourFuture/HTML-CSS).
+
+You'll first create a personal GitHub repository (a storage place for code) in which you'll upload all the homework files.
+
+2. [Trello](https://trello.com/b/U1gK8Q1c/feedback-assignments).
+
+After you've uploaded your files you'll copy the link to the homework folder in GitHub and paste it in a card on Trello in the board "Feedback Assignments" (in the correct week).
+
+In the following guides you'll learn how to do this step-by-step.
+
+## 1. GitHub homework guide
+
+At the beginning of the module:
+
+1. Go to Github and [create a new repository](https://github.com/new) called `HYF-Module-HTMLCSSGIT` (select the option: initialize with README)
+
+Then follow these steps for every week of the HTML/CSS/GIT module:
+
+2. Inside the new repository create a folder with the name of the appropriate week (ex. `week1`)
+3. Upload the the homework files
+4. Before submitting the upload, write a message that says something about what you've done. For week1 the message could be: "wrote cli commands and build digital resume"
+5. Open the files in your folder to check if all of this worked.
+6. Now go to the settings of your repository:
+
+
+
+7. And go to _Github Pages_ select "main" or "master" instead of "none"
+
+
+
+8. Now you can view your homework online at: https://_hereyouplaceyourgithubusername_.github.io/HYF-Module-HTMLCSSGIT/week1, this url will also be visible on the settings page:
+
+
+
+> Here is an example of how your homework repository should look: https://github.com/mkruijt/HTML-CSS
+
+## 2. Trello homework guide
+
+Follow these steps to upload the link to your homework:
+
+1. Go to the `Feedback Assignments` board
+2. In the correct week, create a card with your name and week number (like, `Noer Paanakker Week 1 homework`)
+3. Click on the card, and attach the URL of your GitHub repository and/or other links that are relevant. Additionally, add a short description of what you did
+
+If you have any questions or if something is not entirely clear ¯\\\_(ツ)\_/¯, please ask/comment on Slack!