diff --git a/README.md b/README.md
index 7a67435..44b24b8 100644
--- a/README.md
+++ b/README.md
@@ -1,34 +1,42 @@
# Programming 101
-Welcome to Programming 101. This five day course will help build your programming fundamentals.
+Welcome to Programming 101. This five day course will help build your programming fundamentals. Following along with this syllabus will allow you to work independently. However, if you'd like to sign up for a live remote class, please visit our [Eventbrite](https://www.eventbrite.com/o/pdx-code-guild-17959456298) to see a list of upcoming classes.
+
+## Instructions
+
+The syllabus below outlines the concepts you will learn in this course. Click on each **Unit** link to view lecture note and examples.
+
+**For the live class**: Each unit contains labs that you will need to complete and turn in to the instructor on Slack. You can find directions on how to submit homework to Slack [here](/docs/slack.md). **If you are having issues, please email admin@pdxcodeguild.com**
## Syllabus Overview
While we don't expect you to complete all the advance versions of the labs, we expect you to give it a try. and challenge yourself!
-| Unit | Concepts | Labs | Videos |
-| ---- | -------- | ---- | ------ |
-| [Unit 00](/units/unit-0.md) | Intro to the terminal, installing python, installing VS Code | [Lab 01: Create a folder](/labs/pdxfolder.md) |
| [Lab 05: Password Generator](/labs/password_generator.md) | [Unit 05 ](/practice/unit_5/) |
## Quick Links
Below is a list of helpful links.
-| Resource | Link | Note |
+| Resource | Link | Note |
| ---------- | -------- | --------- |
-| Class Chatroom | [Slack](https://app.slack.com/client/TH5A28SJ0/CH6DE8QK1) | for enrolled Intro students only. [directions on how to use slack](https://github.com/PdxCodeGuild/IntroToProgramming/blob/master/documentation/slack.md) |
-| Terminal Cheatsheet | [Google Sheets](https://docs.google.com/spreadsheets/d/18WWrry7RI2zzJlTsUHQLCsElNjiVVuMGjowBKZ5DPH8/edit#gid=0) | Command Prompt/Terminal/Powershell |
-| VS Code Keyboard ShortCuts | [For Windows](https://code.visualstudio.com/shortcuts/keyboard-shortcuts-windows.pdf) |
-| VS Code Keyboard ShortCuts | [For macOS](https://code.visualstudio.com/shortcuts/keyboard-shortcuts-macos.pdf) |
-| Python Tutor | [Python Tutor](http://pythontutor.com/visualize.html#mode=edit) | online debugging tool |
-| Stuck? | [Debugging Errors Guide](https://github.com/PdxCodeGuild/IntroToProgramming/blob/master/documentation/troubleshooting.md) |
-| Online Code Editor | [Repl](https://repl.it) | cloud based editor and interpreter |
-| Compare two code snippets | [DiffChecker](https://www.diffchecker.com/) | great tool to compare 2 files of code side by side |
-| Learning Resources | [Guide](https://github.com/PdxCodeGuild/IntroToProgramming/blob/master/documentation/resources.md) |
-| Future Intro Classes | [Eventbrite](https://www.eventbrite.com/o/pdx-code-guild-17959456298) |
+| How To Learn | [Strategic Learning](/docs/how_to_learn/) | A short course outlining simple strategies for more effective learning |
+| Lab Submissions |[How to Submit Labs in Slack](/docs/slack.md) | For enrolled Intro students only |
+| Terminal Cheatsheet | [Terminal Cheatsheet](/docs/terminal_cheatsheet.md) | Command Prompt/Terminal/Powershell |
+|Flowcharts|[Flowcharts](/docs/flowcharts/)|Example flowcharts with corresponding code|
+|Vocab|[Vocab List](/docs/vocab.md/)|A collection of programming terms and their definitions|
+| VS Code Keyboard Shortcuts | [For Windows](https://code.visualstudio.com/shortcuts/keyboard-shortcuts-windows.pdf) |
+| VS Code Keyboard Shortcuts | [For macOS](https://code.visualstudio.com/shortcuts/keyboard-shortcuts-macos.pdf) |
+| Python Tutor | [Python Tutor](http://pythontutor.com/visualize.html#mode=edit) | Online debugging tool |
+| Stuck? | [Debugging Errors Guide](https://github.com/PdxCodeGuild/IntroToProgramming/blob/master/documentation/troubleshooting.md) |
+| Online Code Editor | [Repl.it](https://repl.it) | Cloud-based editor and interpreter |
+| Compare two code snippets | [DiffChecker](https://www.diffchecker.com/) | Great tool to compare two code files side-by-side |
+| Learning Resources | [Guide](https://github.com/PdxCodeGuild/IntroToProgramming/blob/master/documentation/resources.md) | | Future Intro Classes | [Eventbrite](https://www.eventbrite.com/o/pdx-code-guild-17959456298) |
[Back to top](#top)
diff --git a/docs/flowcharts/README.md b/docs/flowcharts/README.md
new file mode 100644
index 0000000..8c73dd2
--- /dev/null
+++ b/docs/flowcharts/README.md
@@ -0,0 +1,43 @@
+# Flowcharts
+
+[Back to Syllabus](../README.md)
+
+## Table of Contents
+
+- [Introduction](#intro)
+- [Symbols](#symbols)
+- [Examples](#examples)
+
+### Introduction
+
+When first examining a programming problem, it can be a little overwhelming thinking about where to start. Therefore, it helps to try to split the problem into as many pieces as possible. Then we can work on solving the smaller problems which will work together to solve the overarching problem.
+
+Flowcharts are a great tool for helping organize the logical flow of a program before we write the actual code.
+
+A flowchart is a type of diagram that represents a workflow or process. A flowchart can also be defined as a diagrammatic representation of an algorithm, a step-by-step approach to solving a task.
+
+### Symbols
+
+Flowcharts use different shapes to represent different data, processes and decisions that will make up the program.
+
+| Symbol | Name | Description |
+| ---------------------------------------------------- | ------------ | --------------------------------------------------------------------------------------------------------------------------------------------- |
+|  | Flow Arrows | Shows the process's order of operation. A line coming from one symbol and pointing at another. |
+|  | Terminal | Indicates the beginning and ending of a program. They usually contain the word "Start" or "End" |
+|  | Process | Represents an operation that changes data. |
+|  | Decision | Shows a conditional operation that determines which one of the two paths the program will take. Commonly a yes/no question or true/false test |
+|  | Input/Output | Indicates the process of entering or displaying data. |
+
+[Back to top](#top)
+
+---
+
+### Examples
+
+[Output a Value](flowchart_example_1.md)
+
+[Even or Odd?](flowchart_example_2.md)
+
+[Guess the Number](flowchart_example_3.md)
+
+[Square the Numbers](flowchart_example_4.md)
diff --git a/docs/flowcharts/flowchart_example_1.md b/docs/flowcharts/flowchart_example_1.md
new file mode 100644
index 0000000..b2503e9
--- /dev/null
+++ b/docs/flowcharts/flowchart_example_1.md
@@ -0,0 +1,30 @@
+# Flowchart Example 1 - Output a value
+
+In this example a variable will be defined containing a string representing a color and then displayed in the terminal.
+
+
+
+Notice:
+
+- A rectangle is used when defining the variable
+- A parallelogram is used when outputting to the terminal
+
+### Code:
+
+```python
+# begin program
+
+# set color to 'blue'
+color = 'blue'
+
+# print color to the terminal
+print(color)
+
+# end program
+```
+
+---
+
+## [Example 2 >](./flowchart_example_2.md)
+
+### [<< Back to Flowcharts](/docs/flowcharts/)
diff --git a/docs/flowcharts/flowchart_example_2.md b/docs/flowcharts/flowchart_example_2.md
new file mode 100644
index 0000000..5050f78
--- /dev/null
+++ b/docs/flowcharts/flowchart_example_2.md
@@ -0,0 +1,39 @@
+# Flowchart Example 2 - Even or Odd?
+
+In this example the user will be asked to enter a number, which will be converted from a string to an integer. Then the program will output whether the number is even or odd.
+
+
+
+Notice:
+
+- A rectangle is used when converting the number from string to integer
+- A diamond shape is used when making the decision whether or not the user's number is even or odd. Two different paths diverge from it to represent the different outcomes of the decision.
+
+### Code:
+
+```python
+# begin program
+
+# ask the user for a number
+number = input('Please enter a number: ')
+
+# convert the number from string to integer
+number = int(number)
+
+# number is odd?
+if number % 2 == 1:
+ # print number is odd
+ print(f'{number} is odd.')
+
+else:
+ # print number is even
+ print(f'{number} is even.')
+
+# end program
+```
+
+---
+
+## [< Example 1](./flowchart_example_1.md)| [Example 3 >](./flowchart_example_3.md)
+
+### [<< Back to Flowcharts](/docs/flowcharts/)
diff --git a/docs/flowcharts/flowchart_example_3.md b/docs/flowcharts/flowchart_example_3.md
new file mode 100644
index 0000000..4cc3bc5
--- /dev/null
+++ b/docs/flowcharts/flowchart_example_3.md
@@ -0,0 +1,43 @@
+# Flowchart Example 3 - Guess the Number
+
+In this example a variable will be defined to represent a secret number. The user will be asked to guess a number between 1 and 10, which will be converted from a string to an integer. Then the program will output whether the number is greater than, less than or equal to the secret number.
+
+
+
+### Code:
+
+```python
+# begin program
+
+# set secret number
+secret = 5
+
+# ask the user for a guess
+guess = input('Please guess a number 1-10: ')
+
+# convert the number to an integer
+guess = int(number)
+
+# guess equals secret?
+if guess == secret:
+ # print you guessed the secret!
+ print(f'You guessed the secret number: {secret}')
+
+# guess less than secret?
+elif guess < secret:
+ # print guess was too low
+ print(f'Your guess of {guess} was too low!')
+
+# guess greater than secret?
+elif guess > secret:
+ # print guess was too high
+ print(f'Your guess of {guess} was too high!')
+
+# end program
+```
+
+---
+
+## [< Example 2](./flowchart_example_2.md)| [Example 4 >](./flowchart_example_4.md)
+
+### [<< Back to Flowcharts](/docs/flowcharts/)
diff --git a/docs/flowcharts/flowchart_example_4.md b/docs/flowcharts/flowchart_example_4.md
new file mode 100644
index 0000000..fcf2be1
--- /dev/null
+++ b/docs/flowcharts/flowchart_example_4.md
@@ -0,0 +1,38 @@
+# Flowchart Example 4 - Square the Numbers
+
+In this example we will loop through a list of integers and print the square of each number.
+
+
+
+Notice:
+
+The loop is running until it gets through the last number in the list. Once the last in the list is squared and added to the list, the loop ends.
+
+### Code:
+
+```python
+# begin program
+
+# create list of numbers
+numbers = [11, 22, 33, 44, 55]
+
+# create empty list for squares
+squares = []
+
+# loop through all numbers
+for num in numbers:
+ # square the number
+ num_squared = num ** 2
+
+ # add the square to the list of squares
+ squares.append(num_squared)
+
+# print the list of squares
+print(squares)
+```
+
+---
+
+## [< Example 3](./flowchart_example_3.md)
+
+### [<< Back to Flowcharts](/docs/flowcharts/)
diff --git a/docs/flowcharts/flowchart_example_5.md b/docs/flowcharts/flowchart_example_5.md
new file mode 100644
index 0000000..1721d65
--- /dev/null
+++ b/docs/flowcharts/flowchart_example_5.md
@@ -0,0 +1,21 @@
+# Flowchart Example 5 -
+
+In this example...
+
+
+
+### Code:
+
+```python
+# begin program
+
+
+
+# end program
+```
+
+---
+
+## [< Example 1](./flowchart_example_1.md)| [Example 3 >](./flowchart_example_3.md)
+
+### [<< Back to Flowcharts](/docs/flowcharts/)
diff --git a/docs/flowcharts/flowchart_example_template.md b/docs/flowcharts/flowchart_example_template.md
new file mode 100644
index 0000000..d8d2e38
--- /dev/null
+++ b/docs/flowcharts/flowchart_example_template.md
@@ -0,0 +1,21 @@
+# Flowchart Example
+
+In this example...
+
+
+
+### Code:
+
+```python
+# begin program
+
+
+
+# end program
+```
+
+---
+
+## [< Example 1](./flowchart_example_1.md)| [Example 3 >](./flowchart_example_3.md)
+
+### [<< Back to Flowcharts](/docs/flowcharts/)
diff --git a/docs/flowcharts/flowchart_images/circle.jpg b/docs/flowcharts/flowchart_images/circle.jpg
new file mode 100644
index 0000000..87c2272
Binary files /dev/null and b/docs/flowcharts/flowchart_images/circle.jpg differ
diff --git a/docs/flowcharts/flowchart_images/diamond.jpg b/docs/flowcharts/flowchart_images/diamond.jpg
new file mode 100644
index 0000000..82b645f
Binary files /dev/null and b/docs/flowcharts/flowchart_images/diamond.jpg differ
diff --git a/docs/flowcharts/flowchart_images/flowArrows.jpg b/docs/flowcharts/flowchart_images/flowArrows.jpg
new file mode 100644
index 0000000..88307df
Binary files /dev/null and b/docs/flowcharts/flowchart_images/flowArrows.jpg differ
diff --git a/docs/flowcharts/flowchart_images/flowchart_example_1.jpg b/docs/flowcharts/flowchart_images/flowchart_example_1.jpg
new file mode 100644
index 0000000..f132bd7
Binary files /dev/null and b/docs/flowcharts/flowchart_images/flowchart_example_1.jpg differ
diff --git a/docs/flowcharts/flowchart_images/flowchart_example_2.jpg b/docs/flowcharts/flowchart_images/flowchart_example_2.jpg
new file mode 100644
index 0000000..e0868c9
Binary files /dev/null and b/docs/flowcharts/flowchart_images/flowchart_example_2.jpg differ
diff --git a/docs/flowcharts/flowchart_images/flowchart_example_3.jpg b/docs/flowcharts/flowchart_images/flowchart_example_3.jpg
new file mode 100644
index 0000000..6649c87
Binary files /dev/null and b/docs/flowcharts/flowchart_images/flowchart_example_3.jpg differ
diff --git a/docs/flowcharts/flowchart_images/flowchart_example_4.jpg b/docs/flowcharts/flowchart_images/flowchart_example_4.jpg
new file mode 100644
index 0000000..c847289
Binary files /dev/null and b/docs/flowcharts/flowchart_images/flowchart_example_4.jpg differ
diff --git a/docs/flowcharts/flowchart_images/parallelogram.jpg b/docs/flowcharts/flowchart_images/parallelogram.jpg
new file mode 100644
index 0000000..9b82e01
Binary files /dev/null and b/docs/flowcharts/flowchart_images/parallelogram.jpg differ
diff --git a/docs/flowcharts/flowchart_images/rectangle.jpg b/docs/flowcharts/flowchart_images/rectangle.jpg
new file mode 100644
index 0000000..4f17502
Binary files /dev/null and b/docs/flowcharts/flowchart_images/rectangle.jpg differ
diff --git a/docs/how_to_learn/1_mind_body_connection.md b/docs/how_to_learn/1_mind_body_connection.md
new file mode 100644
index 0000000..5ae4fb1
--- /dev/null
+++ b/docs/how_to_learn/1_mind_body_connection.md
@@ -0,0 +1,299 @@
+
+
+---
+
+
+
+When beginning the process of learning something new, it’s important to point out the inescapable connection between body and mind.
+
+Between reading books, taking notes, analyzing data, reciting information, and drawing connections between topics, it’s easy to become so engrossed in studying that we begin to neglect our basic needs. We forget to drink enough water, stand up and get our hearts pumping, or practice focusing our eyes on subjects beyond our computer screen.
+
+Our brains need blood flow and proper hydration to work at their peak efficiency and our spirits need new and varied experiences to stay motivated and curious.
+
+
+
+
+
+
+
+Because exercise prepares and encourages nerve cells to bind to one another, it spurs the development of new connections in the brain. In short, **not only does exercise help the brain get ready to learn but it actually makes retaining information easier.**
+
+
+
+
+
Let’s Get Moving!
+
+
+According to the _World Health Organization_, **adults 18-64** years of age should participate in **two and a half to five hours** of moderate physical activity each week (about **thirty minutes, five days a week**) in order to maintain a baseline of physical and mental health.
+
+In addition, adults should intake **two to four liters of water** a day. This amount may vary depending on activity levels, environment and overall health, but it is a good goal to shoot for.
+
+Maintaining a healthy lifestyle will compliment one’s learning process and lead to deeper understanding of the material with less stress.
+
+
+
+
+
Nature Heals
+
+
+Too much sedentary time in front of screens can have detrimental effects on our physical and mental well-being.
+
+In a study of 20,000 people, the European Centre for Environment & Human Health at the University of Exeter found that **people who spent at least _two hours a week_ in green spaces like local parks or other natural environments were substantially more likely to report good health and psychological well-being than those who didn’t.**
+
+
+
+
+
+Prolonged staring at a computer screen that’s no more than an arm’s length away can lead to a unique form of eye-strain, called **Computer Vision Syndrome** (CVS).
+
+
+
+
CVS Symptoms:
+
Blurred or double vision
+
Dry eyes
+
Eye discomfort & fatigue
+
Eye itching, redness & tearing
+
Headaches
+
Neck & shoulder pain
+
+
+
+
+
+## Studies show that up to **90%** of people who spend three or more hours per day with a digital device are affected by one or more of the symptoms of Computer Vision Syndrome.
+
+
+
+
+In a survey by the American Optometric Association...
+
+**62%** of respondents spent at least **five hours a day** using a digital device
+
+**14%** spent upwards of **ten hours a day** in front of a screen.
+
+
+
+
These things will also increase the risk of CVS:
+
Screen glare
+
Poor lighting
+
Poor posture
+
Improper viewing distance and angle
+
Uncorrected vision Problems
+
Not taking enough breaks while working
+
+
+
+
+Computer Vision Syndrome is a result of poor screen-usage habits and in order to undo their effects, they must be corrected and replaced with healthier patterns of behavior.
+
+Luckily, the strategies for combating Computer Vision Syndrome are easy to implement and require only small adjustments to begin practicing them.
+
+
+
+## Here are three of the simplest changes we can make to our routine:
+
+
+
+### 1. Drink more water
+
+Our bodies are mostly water, and our eyes are no exception. Keeping ourselves hydrated will help our eyes to produce the tears necessary to lubricate them.
+
+**We blink up to \***66%**\* less while using a computer, so be sure to blink often.**
+
+
+
+
+### 2. Adjust Screen Distance and Angle
+
+| | |
+| -------- | --------------------------------------------------------------------- |
+| Distance | **20 to 28 inches from our eyes** (or about a full arm’s length away) |
+| Height | Top of the screen at **eye level** |
+| Distance | Tilted back **10-20 degrees** |
+
+
+
+
+### 3. Practice the "10-20-20" Rule
+
+
+
+
+
+The “20-20-20” Rule is a technique designed to help alleviate the symptoms of Computer Vision Syndrome.
+
+According to the “20-20-20” Rule, after every **twenty-minute working interval**, we should focus our eyes on a subject at least **twenty feet away** for at least **twenty seconds**.
+
+This helps strengthen the muscles responsible for seeing far away and prevents the muscles around the eyes from becoming too accustomed to only focusing at a short distance.
+
+
+
+Click [here](./combatting_computer_vision_syndrome.md) for more ideas for combatting Computer Vision Syndrome.
+
+
+
+
+
+
+
+
+As technology evolves, people are growing more and more accustomed to a digital lifestyle. As our use of smartphones, tablets, LED monitors and flatscreen TVs increases, so does our exposure to blue light. While the amount of blue-colored light we take in might not seem that important, too much exposure to blue light can have a wide range of negative health effects.
+
+
+
+
+
+
+
+
+
+
+
+## Circadian Rhythm
+
+
+
+
+
+Often referred to as our **“biological clock”**, our **circadian rhythm** is a **finely-tuned, 24-hour cycle** that helps our bodies know when to carry out essential functions like eating and sleeping.
+
+The phrase gets its name from the Latin _"circa diem"_, meaning _"around a day"_.
+
+**Light is the most important factor in aligning circadian rhythms.** While all types of visible light can affect circadian rhythms, blue light has the largest impact.
+
+For much of human history, our sleep cycles were closely aligned with sunrise and sunset, but with the advent of artificial light and electronics, we are being exposed to increasing amounts of light before bedtime.
+
+Blue light suppresses the body’s release of melatonin, a hormone that makes us feel drowsy. While this may be useful during the day, it becomes unhelpful at night when we’re trying to sleep.
+
+**Being exposed to blue light in the evening can trick our brain into thinking it’s still daytime**, disrupting circadian rhythms and leaving us feeling alert instead of tired.
+
+
+
Download an app to automatically reduce blue-light at night
+
Upgrade CRT TVs and monitors
+
Stop using screens one hour before bed
+
+
+
+
+
+An improper sleep schedule can lead to a multitude of other chronic health problems, such as depression, anxiety, high blood pressure, and even certain types of cancer, so we can definitely start to see the importance of doing everything we can to promote healthy sleep.
+
+
+
+
+
Poor sleep habits can lead to:
+
Depression
+
Anxiety
+
High blood pressure
+
Certain types of cancer
+
+
+
+
+
+Animal and human studies suggest that the quantity and quality of sleep have a profound impact on learning. Sleep is important for storing memories and acts to restore and refresh our mental faculties.
+
+Throughout the day, our brains produce a toxic protein called **beta-amyloid**, which can be found in high concentrations in people suffering from Alzheimer’s Disease.
+
+
+
+
+As this protein accumulates, it can leave us in a mental fog, impairing our ability to think clearly and preventing us from recalling information. The deepest stages of sleep cause our brain cells to shrink enough to allow these toxins to be flushed, leaving us feeling refreshed and ready to tackle the day ahead.
+
+Lack of sleep impairs reasoning, problem-solving, attention to detail, and more.
+
+
+
+
Lack of Sleep Impairs:
+
Reasoning
+
Problem-solving
+
Information recall
+
Attention to detail
+
And more...
+
+
+
+
+For some strategies to improve sleep habits, check out the [Tips for Better Sleep](tips_for_better_sleep.md).
+
+
+
+
+
+Maintaining a baseline of physical health will benefit any learning endeavor. Developing a habit of interspersing a few minutes of activity between study or work sessions will lead to desirable outcomes in terms of retaining new information. Spending time outdoors and getting enough quality sleep both support overall health and will improve our learning results as well.
+
+Adults should shoot for **thirty minutes of exercise, five days a week** and should aim to **drink between two and three liters of water a day**.
+
+## So, let's get moving!
+
+Before beginning the next section, consider doing something that raises your heartrate a bit.
+
+
+
+---
+
+
+
+
+
+---
+
+
+
+Forgetting is an inherent part of having a brain. Our brains filter reality down so we can exist without being overwhelmed by the sheer breadth of the information we’re receiving. We’re naturally forgetting a large majority of all that we’re experiencing every single second, and this is to our advantage.
+
+When it comes to the things we do want to remember, humans need to find meaningful associations between bits of information in order for them to be effectively encoded in our memory.
+
+While the entire brain is interwoven with memories stored throughout all areas, there are a few sections of the brain which are generally regarded as being integral in the process of encoding and recalling information.
+
+
+
+
+
Parts of the brain that encode memories
+
Thalamus
+
Amygdala
+
Hippocampus
+
Prefrontal Cortex
+
+
+
+
+
+
+
+
+
+
+
+
+
+### Thalamus
+
+All of our senses except smell are routed through the thalamus. It determines which information is important enough to be sent elsewhere in the brain for further processing and the filters out the rest.
+
+Studies have shown that the thalamus is also essential for determining how well new memories are encoded. It helps to focus our attention and alerts the brain where or when to be engaged.
+
+
+
+
+### Amygdala
+
+The Amygdala (pronounced Uh-mig-duh-luh) is stimulated by intense emotions such as anger, sadness or anxiety. It is often associated with our “fight or flight” response.
+
+Recent studies have shown that the amygdala is also partially responsible for recognizing more than just negative stimuli and can indeed play a role in remembering positive experiences as well. It analyzes incoming sensations and flags stimuli that have a strong emotional component so that they are remembered more effectively.
+
+
+
+
+### Hippocampus
+
+The hippocampus plays an important role in encoding and retrieving memories. Its close proximity to the amygdala ensures that stimuli which trigger strong emotions are remembered.
+
+As new memories are encoded, the hippocampus associates them to existing memories and forms connections that will aid in the retrieval of the data later.
+
+
+
+
+### Prefrontal Cortex
+
+
+The prefrontal cortex plays a major role in determining who we are and how we respond to situations. It provides much of functionality on which we rely for healthy relationships with ourselves and others.
+
+The prefrontal cortex has access to the same short-term memory locations to which the hippocampus encodes new memories and acts as a regulatory agent that decides which memories get stored in long-term memory and how we recall those memories after the fact.
+
+
+
+
+
+
+
+Because memory is such a complicated system, psychologists have divided memory into two main categories: **explicit memory** and **implicit memory**.
+
+
+
+
+
+## Explicit Memory
+
+
+Explicit memory is the **conscious, intentional recollection of facts, experiences, and concepts**.
+
+This type of memory requires gradual learning, with multiple presentations of a stimulus and response. Explicit memory is also known as “declarative” memory since the information can be consciously recalled and explained.
+
+
+
+
Examples of Explicit Memory
+
Birthdays of family members
+
The first ten digits of pi
+
The rules of chess
+
The start date of your coding boot camp at PDX Code Guild
+
+
+
+
+
+
+## Implicit Memory
+
+Implicit or "non-declarative" memories are things that we don't intentionally try to remember. These types of memories are learned rapidly, sometimes requiring only a single exposure to a stimulus.
+
+Implicit memories are often procedural and focused on the step-by-step processes that must be performed in order to complete a task.
+
+Once these skills are learned, we don’t have to learn them again in order to perform them. These memories are largely unconscious and occur automatically; we don't need to think about all of the exact steps we need to follow in order to complete each task.
+
+
+
+
+
Examples of Implicit Memory
+
Riding a bike
+
Typing on a keyboard
+
Tying shoelaces
+
Speaking in one's native language
+
Dancing to a funky beat
+
+
+
+
+
+---
+
+
+
+
+
+## Example of Implicit Vs Explicit Memory
+
+
+
+Without looking at the keyboard, type the following sentence:
+
+
+
+
+
+
+
+
+
+
+Now, without looking at the keyboard:
+
+
+
+
+
+### **Try to name the letters on the top ten keys of the keyboard**
+
+
+
+
+
+
+For even the most novice typist, it was probably quite easy to type the sentence without having to consciously think about where each letter appeared on the keyboard.
+
+### **That task requires *implicit* memory.**
+
+
+
+However, having to recall which letters appear in the top row of your keyboard may have proven to be a bit more difficult.
+
+### **That task requires *explicit* memory.**
+
+
+
+Since we haven’t taken the time to intentionally commit the order of those keys to memory, it's not something that we are able to easily recall.
+
+
+
+---
+
+
+
TL;DR
+
+
+
+
+## The Brain
+
+Human's remember things better if we can associate them to things we already know.
+
+There are four parts of the brain that are crucial for encoding and retrieving memories.
+
+### 1. Thalamus
+Determines which incoming information is important
+
+### 2. Amygdala
+Flags stimuli that trigger strong emotions to be remembered.
+
+### 3. Hippocampus
+Encodes & retrieves memories through association.
+
+### 4. Prefrontal Cortex
+Performs all the tasks that make up one's personality and is able to intentionally recall memories.
+
+---
+
+
+
+## Memory
+
+Cognitive psychologists have divided memories into two categories.
+
+
+
+### Explicit memory
+Information that is intentionally learned and recalled such as facts or events.
+
+
+
+### Implicit memory
+Information that is unconsciously learned and recalled automatically. These memories are usually more procedural and deal with the how rather than the why.
+
+
+
+---
+
+
+
+---
+
+
+
+When we focus too intently for too long, we can reach a point where our brains simply cannot absorb any additional information. We can begin to feel a bit hopeless and to worry that we’ll never understand the material.
+
+However, this is when we must remember the difference and recognize the benefits of both the **focused** and **diffuse** modes of thinking.
+
+
+
+
+
+## Focused Thinking
+
+Focused thinking is when the mind concentrates intently on a particular subject. We immerse ourselves in the information and actively expend energy towards learning it.
+
+
+
+
+
Examples of Focused Thinking
+
Writing a paper
+
Doing a math problem
+
Creating a webpage
+
+
+
+The longer we keep our brains in focused mode, the more we experience tunnel vision, which makes it harder to think outside-the-box. This phenomenon is known as the ***Einstellung Effect*** and removes our ability to reset the parameters or premise of a problem and thereby blocks creativity.
+
+For this reason, **when you’re feeling stuck or frustrated with a topic, it’s best to step back and take a break** to let the diffuse mode of thinking run for a while.
+
+
+
+
+
+
+## Diffuse Thinking
+
+Diffuse thinking looks at the big picture. It allows us to zoom out a bit and approach the subject from the outside in, starting with general concepts rather than more specific ones.
+
+We generally default to this mode of thinking when we’re doing something other than studying so this is why taking regular breaks is so important while learning something new.
+
+While our conscious minds are relaxed, they are able to make connections across broader areas of the brain and deepen understanding of concepts learned during focused thinking.
+
+
+
+
+
+
Examples of Diffuse Thinking
+
Pondering the topic of your paper while doing dishes
+
Mulling over a math problem while taking a walk
+
Considering how different webpage designs would affect a user's experience
+
+
+
+
+
+Too much diffuse thinking can get in our way as well as it will prevent us from ever getting the details of anything straight.
+
+We should practice alternating work sessions with frequent breaks to allow ourselves to zoom out a bit from the details and solidify the bigger picture.
+
+### Try to avoid things like social media or watching TV.
+
+Instead, opt for activities that allow the mind to truly wander like walking or meditating.
+
+
+
+
+
+
+Learning and memory are often described in terms of three functions: **Acquisition**, **Consolidation** and **Recall**.
+
+
+
+### Acquisition
+
+Acquisition is where **new information is introduced into the brain**.
+
+In this stage, we actively pay attention to a subject and link it to existing knowledge in order to make the new connection more meaningful, which will make it easier to recall the information later.
+
+Acquisition can take place in a single learning session, but is usually more effective with multiple, repeated sessions spread out over time.
+
+New information can usually be recalled shortly after it’s acquired, but without repeated exposure to the information, it’s much more difficult to recall after a longer period of time.
+
+
+
+### Consolidation
+
+Consolidation is the **process of encoding short-term memories into long-term memories**.
+
+This compression of memories is necessary in order to combine the various bits of data we acquire about a subject and to find the appropriate associations for them in our memory so that they’re easily recalled when needed.
+
+Consolidation takes place primarily during periods of diffuse thinking or sleep and leaves memories in a more stable and useful form.
+
+
+
+
+
+### Recall
+
+Recall is **the ability to intentionally retrieve information after it’s been committed to memory**.
+
+How well a memory can be recalled is largely dependent on how many times it’s been encountered in the acquisition stage and how thoroughly it’s been integrated in the consolidation stage.
+
+However, there are also many other factors that can affect our ability to quickly and accurately recall information, such as quantity and quality of sleep.
+
+
+
+
+### Sleep
+
+Modern hypotheses highlight an active role for sleep in which memories undergo a process of systemic integration.
+
+During periods of Rapid Eye Movement (REM) sleep, our brains process the information we’ve acquired during the day in the form of dreams. In fact, the areas of the brain which are activated during REM sleep are the same areas that are active during acquisition of information, suggesting that REM sleep plays a role in memory consolidation.
+
+Once we enter the deeper stages of sleep, the memories we’ve processed in our dreams are consolidated further and are associated with existing memories at a much broader level.
+
+
+
+
+
+
+
+Both modes of thinking are equally valuable, but it’s the harmony between them that matters.
+
+### We master the specifics in focused mode and comprehend how everything ties together in the diffuse mode.
+
+
+
+
+
+
+## Stages of Learning
+
+### Acquisition
+
+Introducing new information into the brain through one or more repetitions.
+
+### Consolidation
+
+The process of encoding short-term memories into long-term memories during periods of diffuse thinking or sleep.
+
+### Recall
+
+Intentionally retrieving information after it’s been committed to memory.
+
+
+
+
+---
+
+
+
+---
+
+
+
+
+The amount of information that can be stored in short-term memory can vary.
+
+Modern research suggests that we can store between four and six pieces of information in short-term memory, depending on the complexity of each piece.
+
+
+
+
+
+
+
+
+
+
+### As we focus on a subject, we fill up our short-term memory.
+
+
+
+### If we force ourselves to continue focusing, old information is pushed out to make room for new information.
+
+
+
+
+
+
+
+### Taking a break instead will allow our brain to determine which pieces of information important and which are not.
+
+
+
+
+
+
+### The important information is encoded in long-term memory and the rest is forgotten.
+
+
+
+
+
+
+
+
+
+
+---
+
+
+
TL;DR
+
+
+
+
+
+Our short-term memory can only hold a few pieces of information at a time. To avoid frustration and increase recall, it's important to take frequent breaks while learning to allow information to be assimilated in to long-term memory.
+
+
+
+---
+
+
+
+When we’re trying to learn complex information, it helps to separate related data into smaller groups to make it easier to process.
+
+We can break up the concepts using a technique called **chunking**.
+
+Meaningful bits of information, or **chunks**, are grouped together so that the brain can more easily encode and relate that information to previous knowledge, which makes it easier to recall later.
+
+
+
+## The process of chunking can be broken down into the following steps:
+
+### 1. Look at the big picture
+
+Take an overview of the subject as a whole to see where the information might lead. Don’t pay particular attention to any details.
+
+
+
+### 2. Break big ideas up into smaller ideas
+
+Take a look at the core topics and try to anticipate what type of information might be covered in each one.
+
+
+
+### 3. Focus on one small concept at a time
+
+Study and practice recalling the particular ideas within the smaller concept, perhaps even forgetting about the big picture for a moment to really pay attention to the details.
+
+
+
+### 4. Apply smaller ideas in a variety of contexts
+
+This will solidify understanding of the smaller ideas and start to open up the avenues for forming connections between smaller parts of the overall topic.
+
+
+
+### 5. Organize the smaller ideas into larger ideas
+
+Once we start to recognize patterns in the information, we can group smaller ideas together to attempt to recreate the complexity of the original subject.
+
+
+
+### 6. Relate each larger idea back to the original concept and to other smaller concepts
+
+Consider each chunk’s place in the overall subject and how it ties into the previously studied chunks
+
+
+
+### 7. Repeat as many times as necessary
+
+Regular review of the information will ensure quick and accurate recall of the information when needed.
+
+
+
+
+
+---
+
+## Chunking Example
+
+
+
+Imagine that we're given a string of characters and told to count how many dollar signs **$** appear in the string.
+
+
+
+
+
+### ?$*@?$#*??$#**@$@#?*@#$#@
+
+
+
+
+The way the string is organized, it might take a few seconds to scan the string to count the dollar signs.
+
+However, if we take a moment to sort the string by character:
+
+
+
+
+
+### ##### ????? ***** $$$$$ @@@@@
+
+
+
+
+We can see, at a glance that there are **five** dollar signs and it would make counting the other characters much simpler as well.
+
+### What a big difference a little organization makes!
+
+
+
+
+
+
+
+New information fades quickly as soon as we learn it, represented here by red line on the chart.
+
+We can see that retention of the information is almost 100% as soon as it’s processed, but drops dramatically shortly thereafter until we review it.
+
+With each review, our understanding increases, as represented by the green line on the chart.
+
+Reviewing also slows the forgetting curve, helping us retain more information for longer periods of time until eventually we’ve remembered more than we’ve forgotten.
+
+
+
+---
+
+
+
TL;DR
+
+
+
+
+Chunking is an excellent technique for efficiently dividing a complex subject into more digestible sections.
+
+Once the larger subject is divided, we can focus on the smaller concepts in more detail, eventually connecting them back to the complex subject as a whole.
+
+Even after breaking information up, if we want the information to become second nature, we still need to revisit it regularly.
+
+
+
+---
+
+
+
+
+
+### Beware the illusion of competence.
+
+If we’ve studied something long enough, we might start to feel like we’re becoming masters in the subject.
+
+We test our knowledge and when we pass our own test, we feel so accomplished that we become narrow-minded about acquiring more information. Suddenly, we’ve fooled ourselves into believing that we understand the subject more than we actually do and in doing so, we've hindered further learning.
+
+It’s to our advantage to be open with ourselves about what we don’t know.
+
+### When all is said and done, it is better to have an honest ignorance than a self-deceptive one.
+
+
+
+
+
+
+
+The **Dunning Kruger Effect** is the cognitive bias behind the illusion of competence.
+
+It causes people to believe that they are smarter and more capable than they really are.
+
+Inexperienced people do not possess the wisdom needed to recognize the information they don’t know and this can cause them to be very confident in their incorrectness.
+
+It is actually pretty easy to fall into this pattern when learning new information.
+
+### To avoid falling victim to the Dunning Kruger Effect, practice the following on a regular basis:
+
+
+
+### 1. Play devil's advocate
+
+We should always check the information we feel like we understand. We should ask ourselves how we might be wrong and genuinely try to disprove ourselves.
+
+
+
+
+### 2. Teach someone
+
+Taking the time to explain the material to someone else and answer their questions will expose holes that might exist in our understanding.
+
+
+
+
+### 3. Seek feedback
+
+Ask for critiques from people you can trust who you know are highly skilled in your area of interest.
+
+Be prepared to take constructive criticism and value the perspectives of those who share different viewpoints.
+
+Don’t get defensive if someone disagrees with you, take it as an opportunity for growth.
+
+
+
+
+### 4. Be humble
+
+Don’t pretend to know something you don’t. Make it a priority to continue learning and growing.
+
+
+
+
+
+
+### “In the beginner’s mind there are many possibilities, but in the expert’s there are few.”
+
+
+
+
+
+**Imposter Syndrome** is the opposite of the Dunning Kruger Effect.
+
+### The more skilled we are, the more we feel like a fraud.
+
+This tends to make us think we’re not worthy and that we’re one wrong move away from being outed as the liars that we are.
+
+**The only line of defense we have against this delusion is our perception of it**. Awareness is the first step to overcoming any obstacle and Imposter Syndrome no different.
+
+Imposter syndrome can take on many forms and evoke a multitude of confusing emotions. Let’s take a look at some of the more common faces of Imposter Syndrome and some advice for dealing with them when they arise.
+
+
+
+### 1. The Perfectionist
+
+The Perfectionist tends to set unreasonable or even impossible goals and struggles with self-doubt when they inevitably cannot complete them. They tend to have trouble finishing projects because their work doesn’t live up to their own rigorous standards. They often feel like they “could have done a better job.”
+
+### Advice:
+
+- Stop dwelling on failures and give credit where credit is due.
+
+- Aim to complete the "Minimal Viable Product", then add details later.
+
+- Break large goals into lots of smaller goals, focus on one at a time.
+
+- Celebrate small successes to reinforce self-worth.
+
+
+
+
+### 2. The “Superhero”
+
+The Superhero is always trying to work harder than everyone else to cover up feeling like a fraud amongst their ‘real-deal’ team mates. They are constantly thinking about work, pushing themselves to and even beyond their limits at the sacrifice of crucial downtime.
+
+### Advice:
+
+- Try not to seek validation from others, but rather from within oneself.
+
+- Remember that breaks are just as conducive to success as proaction and time spent relaxing or being creative is essential for mental health.
+
+- The quality of our work will benefit from us being happy and healthy, so let’s not rob ourselves of that by being too caught up in work.
+
+
+
+
+### 3. The “Rugged Individualist”
+
+Also known as “The Soloist”, the “Rugged Individualist” will often avoid asking for help because they see it as a sign of weakness and believe it would expose them as a fraud.
+
+### Advice:
+
+- No one exists in a vacuum. We are all intrinsically connected and we uphold each other through those connections.
+
+- Knowing when to ask for help is a vital skill and will earn us respect and humility amongst our peers.
+
+- If we’re working alone, we can’t help anyone else either. We’re denying the world the benefit of our knowledge and if we allow others to help us, our ideas will blossom much more readily. Two heads are better than one and many hands make light work.
+
+
+
+
+### 4. The “Natural Genius”
+
+The “Natural Genius” believes that if something costs them a lot of effort, it must mean that they are bad at it. They are reluctant to accept help from others and are too afraid of failure to try new things.
+
+### Advice:
+
+- Try measuring successes by the effort put into them and acknowledge the fact that no one can be great at everything.
+
+- Instead of avoiding challenges see them as opportunities to learn and develop.
+
+- Use areas of expertise to help others grow and learn
+
+
+
+
+### 5. The “Expert”
+
+The "Expert" is so caught up on the notion of achieving mastery of a skill that they lose all confidence in the skill they already possess.
+
+They may feel like they actually have no right to the job they're doing and are just waiting their peers to find out how incompetent they really are. Perhaps They don’t even apply to certain jobs because They don’t have every single skill they mentioned in the job description.
+
+### Advice:
+
+- Skill gaps are normal and they don’t detract from what we already know
+
+- There are many people out there applying because they have most of the skills required and are quite happy to develop the others on the job.
+
+- Focus on existing skills and strengths , consciously note successes and making realistic plans to fill in any gaps.
+
+
+
+
+---
+
+
+
+### Imposter Syndrome is ***incredibly*** common.
+
+### We should always try not to be compassionate with ourselves when learning something new.
+
+### Everyone is unique and learns things in their own way and at their own pace.
+
+
+
+---
+
+
+
TL;DR
+
+
+
+
+### Dunning Kruger Effect
+
+The **Dunning Kruger Effect** is the cognitive bias that causes people to believe that they are smarter and more capable than they really are.
+
+We can avoid this by always questioning our knowledge, especially if we think we have a good understanding of it.
+
+
+
+
+### Imposter Syndrome
+**Imposter Syndrome** is the persistent inability to believe that one's success is deserved or has been legitimately achieved as a result of one's own efforts or skills.
+
+To avoid Imposter Syndrome in its many forms, celebrate small successes, take frequent breaks, don't be afraid to ask for help and don't worry too much about gaps in knowledge.
+
+
+
+
+---
+
+
+
+---
+
+
+
+It’s easy for us to find distaste in something we’re not good at yet.
+
+We’ve all been there - sitting, putting off a task we know we should do. We find all sorts of excuses and time-fillers to distract us and while this may make us feel better in the moment, we suffer in the end.
+
+Don’t worry though, no one is alone in this. Studies show that up to **88%** of people procrastinate while working, and that’s just those who are brave enough to admit it.
+
+
+
+
+
+
+
+
+
+
+
+The result of this cycle is that **the dread of doing a task uses up more time and energy than doing the task itself.**
+
+
+
+
+
+
+
+The most difficult part of any task is getting started. Once we begin, we gain momentum and before we know it, we’re cruising right along, making great progress on what we need to do.
+
+Once we cross the threshold of action, the pain begins to subside. The guilt, shame, and anxiety that we feel while procrastinating are usually far worse than the effort we have to put in while we’re working.
+
+
+
+### The problem is not ***doing*** the work, it’s ***starting*** the work.
+
+
+
+
+
+---
+
+## Types of Procrastination
+
+
+There are four main architypes for procrastination.
+
+
+
+### 1. The Performer
+
+This procrastinator forces themselves to focus by shrinking the time they have to tackle a task. They wait until the last second to begin and frantically rush to meet the deadline.
+
+
+
+**Biggest challenge:** Getting started
+
+**Your solution:** Focus on a time to begin a task, not when it needs to be done This will take a tremendous amount of pressure off of the situation.
+
+
+
+
+### 2. The Self-Deprecator
+
+This procrastinator tends to blame inaction on laziness or stubbornness rather than admit they are tired. When they don't do something they are extra hard on themselves.
+
+
+
+**Biggest challenge:** Taking a break.
+
+**Your solution:** Recharge. Try taking a walk to give yourself space and to begin to rebuild your energy.
+
+
+
+
+### 3. The Overbooker
+
+This procrastinator is a pro at filling up their calendar and is often overwhelmed. When busy-ness comes up as an excuse for not doing something, it's usually an indication of avoidance.
+
+Rather than facing a challenge head on or admitting they don't want to do something, it's easier to place the blame on having other important things to do.
+
+
+
+**Your biggest challenge:** Creating chaos to avoid facing what we know we need to face right now.
+
+**Your solution:** Take a moment of introspection. Ask: What am I really avoiding?
+
+
+
+
+
+### 4. The Novelty Seeker
+
+This procrastinator is constantly coming up with new projects to take on — and then getting bored with them a week later. They're intrigued by the latest trend and will be quick to implement but not follow through.
+
+They are great at making decisions and taking action. However, they end up inadvertently losing a lot of time and burning out because they don't take consistent action in one direction long enough to see results.
+
+
+
+**Your biggest challenge:** Completion.
+
+**Your solution:** Write down new ideas or projects, but don't pursue them until you finish what you are currently working on.
+
+
+
+
+---
+
+
+## Overcoming Procrastination
+
+
+
+
+### Be Kind to Yourself
+
+**We can’t beat ourselves up about procrastinating.** We must acknowledge the desire to procrastinate, sit with it for a moment, take a deep breath and make the conscious decision not to follow that desire.
+
+**Changing habits takes lots of patience** and compassion towards oneself, but the outcome is worth the effort.
+
+
+
+
+## Figure Out Why
+
+### We need to identify the reasons why we’re procrastinating before we can begin to tackle them.
+
+Are we avoiding a task because we find it boring or unpleasant?
+
+Are we overwhelmed by the breadth of the task and hand and need to do a little organizing before we can begin?
+
+Perhaps we’re feeling afraid of failure, or even *success*?
+
+
+
+
+## Adjust Inner Dialogue
+
+### The way we word the excuses we make to ourselves can have a big impact on productivity.
+
+For instance, instead of saying,
+
+**“I have plenty of time, why start now?”**
+
+
+
+we could say,
+
+**“I have plenty of time, but I’ll feel better if I don’t wait until the last minute.”**
+
+
+
+Adjusting our inner dialogue can make all the difference.
+
+Instead of using words like “have to” or “should”, which make our tasks feel like chores, we can say “I choose to ...” which implies that we own our project and can make us feel more in control of our workload.
+
+
+
+
+## Adopt Practical Strategies
+
+### At its core, procrastination is a habit, but all habits can be undone.
+
+Here are some ideas for confronting procrastination:
+
+
+
+### 1. Commit to the task
+
+Break the task up into smaller pieces, write all the smaller tasks down and specify times for doing them
+
+
+
+### 2. Promise yourself a reward
+
+When you complete a task, be sure to reward yourself for your efforts. It doesn’t have to be much, just enough to enjoy the satisfaction of completing a task.
+
+
+
+### 3. Minimize distractions
+
+Silence your phone and all other devices while working. Avoid multitasking and listen to unobtrusive music.
+
+
+
+### 4. “Eat an Elephant Beetle” First Thing
+
+No, this doesn’t require the consumption of any insects.
+
+This means conquering the hardest, least desirable task first thing in the morning so you don’t waste energy dreading it all day.
+
+
+
+### 5. Keep a regular schedule
+
+Start studying at a particular time each day to begin to develop positive study habits.
+
+
+
+---
+
+
+
+The trick to overwriting a habit is to look for the pressure point – our reaction to a cue.
+
+The only place we need to apply willpower is to change our reaction to the cue. It takes a little practice before one starts to enjoy the work...
+
+The better we get at something, the more enjoyable it can become. We need to believe the system can work.
+
+
+
+
+
+### If we can undo our procrastination habit, a myriad of positive changes will begin to unfold.
+
+
+
+---
+
+
+
TL;DR
+
+
+
+
+Procrastionation the habitual action of delaying or postponing something and can present itself in many forms.
+
+The irony of procrastination is that the dread of doing a task uses up more time and energy than doing the task itself.
+
+As with all habits, procrastination takes effort to undo. Through strategies like keeping a regular schedule, rewarding ourselves when we complete something, or dividing goals into smaller tasks, we can overcome the negative patterns of procrastination and conjur success!
+
+
+
+---
+
+
+
+
+
+---
+
+
+
+
+
+## Pomodoro Technique
+
+
+
+The Pomodoro Technique was developed by **Francesco Cirillo** in the late 1980s. It involves using a timer to space out working intervals with breaks of different durations and is a great way to conquer procrastination.
+
+It is called the “Pomodoro” Technique after a uniquely-shaped analog timer shaped like a tomato.
+
+
+
+
+
+
+
+In reality, any timer will work and there is a wide variety of phone apps that can also serve this purpose, as long as having one’s phone on one’s desk doesn’t prove to be distracting.
+
+
+
+
+The technique works like this:
+
+### 1. Work for twenty-five minutes
+
+### 2. Take a five minute break
+
+Stretch, exercise, drink water, or practice the "20-20-20 Rule"
+
+### 3. Repeat steps 1 and 2 three more times
+
+### 4. Take a twenty minute break
+
+Avoid screens and other distractions! Practice some diffuse thinking by going for a walk, taking a nap, meditating, or breathing deeply. Reward yourself for completing some work!
+
+### 5. Return to step 1
+
+Repeat steps 1 - 5 as many times as needed.
+
+
+
+---
+
+
+As we saw in the sections about the brain and memory, frequent breaks can facilitate learning by allowing the information in our short-term memory to be absorbed into long-term memory.
+
+Taking a little time to rest our brains after periods of work will leave us feeling less burnt-out at the end of the day, and we'll have achieved much more than if we had tried to do the same amount in a single work session.
+
+
+
+
+
+### One of the best ways to solidify knowledge is to explain it to someone else.
+
+
+
+
+Teaching will expose any holes in one’s current understanding and will reinforce the points which are best understood. However, it can often be difficult to find a willing victim student to participate in the exercise.
+
+
+
+### Enter the rubber duck.
+
+
+
+The rubber duck technique is primarily a method of debugging code, but can also be used when learning other subjects.
+
+The name is a reference to a story in the book *The Pragmatic Programmer* in which a programmer would carry around a rubber duck and debug their code by forcing themselves to explain it, line-by-line, to the duck.
+
+The rubber duck is a nice prop because it has a face, but in the absence of this very specific toy, other items can be substituted.
+
+A set of googly eyes goes a long way in providing some much needed personality to your chosen inanimate student.
+
+
+
+
+
+
+---
+
+
+
+## Effective Reading with OK4R
+
+
+Despite the vast amount of content that can be found in video or audio format, **reading is still the most prevalent way that most people consume information**.
+
+It can be a little overwhelming to begin to tackle a large body of text pertaining to a certain subject. Developing an effective reading strategy can work wonders in terms of recalling the information later.
+
+Instead of starting at the beginning and reading through to the end, we will complete assignments faster and remember more if we first take the time to follow the **OK4R reading method**.
+
+Originally devised by *Dr. Walter Pauk*, OK4R is a reading strategy to help absorb as much content from reading material as possible.
+
+OK4R is an acronym which stands for **Overview**, **Key Ideas**, **Read**, **Recall**, **Reflect** and **Review**.
+
+
+
+
+### 1. Overview
+Go through the introduction, table of contents, headings, subheadings, summaries and diagrams to develop a **general idea** of what the study material is about and what to expect to learn from reading it.
+
+### 2. Key Ideas
+
+Go back through the key ideas of the study material.
+
+These are most often in the beginning of each paragraph or emphasized in some way – like bolded text, bullet points, pictures or graphs.
+
+### 3. Read
+
+Once we’ve outlined the key ideas and know a bit of what to expect, we can begin to read the study material while keeping the key ideas in mind.
+
+### 4. Recall
+
+At regular intervals, close the study material and try to recall as much as possible, especially in regards to the main points of the text.
+
+**Write down all the key points that you remember.**
+
+### 5. Reflect
+
+Reflect on the new knowledge by thinking of practical examples.
+
+This is where we can **associate the new knowledge to what we already know**, and brainstorm new and creative applications of the information.
+
+### 6. Review
+
+We should **review the material often to refresh our memory and improve our recall**. Repetitions should be spaced out and **prioritize reviewing the details have been forgotten**.
+
+
+
+
+The OK4R reading method compliments the chunking strategy outlined in previous sections. It will help to make a large body of text more approachable by breaking it down into smaller parts. Once each part is read, it’s connected back to the overall theme, thereby bolstering our understanding of the text as a whole.
+
+
+
+
+
+
+---
+
+## As Within, So Without
+
+
+
+### Humans are not separate from our environment.
+
+
+
+The way we feel on the inside is directly influenced by our surroundings and the way we feel about our surroundings is influenced by how we feel inside.
+
+The tidiness of a room, the colors on the walls, the music in the background, and the amount of natural light we receive can all affect how we feel about ourselves and the world around us, whether we’re aware of it or not.
+
+Our chosen study location and environment can heavily influence productivity and concentration when it comes time to learn.
+
+
+
+
+### Take some time to set up a room or small area dedicated to studying.
+
+Make your space comfortable, but not *too* comfortable.
+
+### Clear away distractions
+
+Make sure the area is free of clutter and that the space is aesthetically pleasing enough to want to spend a fair amount of time there.
+
+
+### Cast out the darkness
+
+If possible, choose a naturally lit location for studying, or consider purchasing a full-spectrum lamp.
+
+### Remove clutter
+
+Be intentional about the objects that are kept in the space.
+
+### Choose the right tunes
+
+If music is to be played in the background, opt for music with minimal lyrics, allowing one’s own thoughts to fill the void.
+
+### Bring nature to you
+
+Keep a few houseplants around for some company and fresh oxygen (some googly eyes could even transform the plants into excellent students to teach as we learn).
+
+### Ditch the devices
+
+Turn off or silence phones and other devices and keep them out of reach.
+
+### Promote thinking
+
+Try keeping some fidget toys around to play with while pondering. These can also help reduce stress.
+
+
+
+
+
+
+
+
+## Pomodoro Technique
+
+
+
+The **Pomodoro Technique** involves using a timer to space out working intervals with breaks of different durations.
+
+
+
+The technique works like this:
+
+1. Work for twenty-five minutes
+
+2. Take a five minute break
+
+3. Repeat steps 1 and 2 four times
+
+4. Take an extended break of twenty minutes
+
+5. Return to step 1
+
+
+
+Avoid screens and other distractions during breaks. Instead, use them to exercise, drink water or practice diffuse thinking.
+
+
+
+---
+
+## Rubber Duck Technique
+
+
+
+The **Rubber Duck Technique** is founded in the notion that teaching something to someone else will solidify our knowledge of that subject.
+
+In the absence of a human student, we can substitue a rubber duck or other inanimate object.
+
+
+
+---
+
+
+## OK4R
+
+
+
+**OK4R** is a technique for effectively reading learning materials.
+
+**OK4R** is an arcronym for
+
+1. **Overview** - A quick glance over the material to see what might be covered. Look at headings, subheadings, summaries and diagrams
+
+2. **Key Ideas** - Outline the important points of the text. Look at bold text, graphs, images and bulleted points
+
+3. **Read** - Read the study material while keeping the key ideas in mind.
+
+4. **Reflect** - Reflect on the new knowledge. Associate the new knowledge to what we already know and brainstorm new and creative applications of the information.
+
+5. **Recall** - At regular intervals, close the study material and try to recall as much as possible, especially regarding the main points of the text.
+
+6. **Review** - Review the material often to refresh our memory and improve our recall. Repetitions should be spaced out and **prioritize reviewing the details have been forgotten**.
+
+
+
+---
+
+
+
As Within, So Without
+
+
+
+
+Our study environment can have a big impact on our learning. Take some time to set up a room or small area specifically for studying.
+
+
+
+Make your space comfortable, but not *too* comfortable.
+
+1. Clear away distractions / clutter. Turn off or silence phones and other devices and keep them out of reach.
+
+2. Choose a naturally lit location for studying, or consider purchasing a full-spectrum lamp
+
+4. Opt for music with minimal lyrics, allowing one's own thoughts to fill the void
+
+5. Keep a few houseplants around for some company and fresh oxygen
+
+
+
+---
+
+
diff --git a/docs/how_to_learn/9_pdx_code_guild.md b/docs/how_to_learn/9_pdx_code_guild.md
new file mode 100644
index 0000000..a2bbec4
--- /dev/null
+++ b/docs/how_to_learn/9_pdx_code_guild.md
@@ -0,0 +1,121 @@
+
+
+
+
+
+
+
+## PDX Code Guild
+
+
+
+### Our goal is to prepare our students for the real-life challenges of finding a job in the tech industry.
+
+
+
+
+Boot Camp students will develop the skills required to create full-stack web applications and will present a final project to an audience of their peers, alumni and advisors upon the course’s completion.
+
+In addition to popular web technologies like HTML, CSS, Python and Javascript, students of our Full Stack Python Boot Camps will receive hands-on training to develop common professional practices and techniques including:
+
+- Pair / group programming
+
+- Agile development / time management
+
+- Self-driven problem solving
+
+- Reading technical documentation
+
+- Code management / version control
+
+- Interview skills / resume writing
+
+
+
+
+## Career Services
+
+Our Career Services department is here to help empower your job search! They will check in on boot camp students at regular intervals to make sure everyone is on track to start looking for jobs as soon as they graduate, if not sooner.
+
+
+
+### What can you expect from Career Services?
+
+- Trusted advice & confidentiality
+
+- Career search sesources
+
+- Reviews of resumes and LinkedIn Profiles
+
+- Mock Interviews
+
+- Job Search Strategy and Marketing Plan
+
+- Goal Setting & Overcoming Barriers
+
+
+
+We offer a variety of programs and services to help tend to each of our students' individual job search needs.
+
+
+
+### Career Services Resources
+
+- PDX Code Guild Job Search Group (meets virtually every Wednesday from 11:30 am - 1:00 pm)
+
+- Career search resources and information
+
+- Individualized career services meetings
+
+- Community resources
+
+- Goal setting & overcoming barriers
+
+- Access to our Job-Leads channel on Slack
+
+
+
+---
+
+
+
+At PDX Code Guild, we love helping our students learn to write code and guiding them as they develop into software engineers. We hope that this course has piqued your interest and given you some helpful tools to use throughout all stages of your coding journey.
+
+When you join PDX Code Guild, you’re getting far more than just coding knowledge. Throughout your boot camp experience, we'll help you build not only your resume and portfolio, but also the confidence in your ability to metamorphosize into a full-stack web developer.
+
+Our community of advisors, instructors and alumni, are what set us apart from other coding programs. The support you receive through our network of peers is, by far, the greatest benefit of our programs and we can’t wait for you to be joining us for more learning!
+
+
+
+
diff --git a/docs/how_to_learn/README.md b/docs/how_to_learn/README.md
new file mode 100644
index 0000000..0352c0c
--- /dev/null
+++ b/docs/how_to_learn/README.md
@@ -0,0 +1,72 @@
+
+
+
+
+
+
Strategic Learning
+
+
A Practical Approach to Continued Education
+
+
+---
+
+Welcome to the PDX Code Guild and thanks for joining us in our Strategic Learning course, which break down some of the key elements of what it means to learn.
+
+We’ll take a look at the physiology behind learning, including how new memories are formed and the parts of the brain that are involved in encoding them as well as the important role that physical health plays in our ability to absorb and retain new information.
+
+We’ll explore the different ways we process data and how sleep can help us to learn.
+
+Finally, we’ll expose some of the common pitfalls we may encounter while learning as well as some techniques for overcoming them.
+
+Learning outside the context of a traditional classroom can present its own unique challenges. With no one looking over our shoulder, grading our work and critiquing each step of the way, it’s easy to fall victim to lack of motivation, procrastination and self-doubt. These types of feelings can get us caught in a negative feedback loop, causing us to feel that we’ll never reach our goal and this can lead us to give up on learning.
+
+This course is designed to provide techniques that will help to keep morale high and interest piqued, as well as to maximize information retention and recall. The concepts and strategies outlined in this course are meant to compliment all learning styles and to provide activities and tools to enhance their efficacy.
+
+At PDX Code Guild, our mission is to cultivate our students' confidence in their ability to solve the unique programming puzzles they will encounter on their new career path in the technology industry. We are passionate in our quest for knowledge and we are excited to have you along for the journey.
+
+
+
+
+---
+
+
+
+## Table of Contents
+
+1. [The Mind-Body Connection](./1_mind_body_connection.md)
+
+2. [The Brain & Memory](./2_the_brain_and_memory.md)
+
+3. [Modes of Thinking](./3_modes_of_thinking.md)
+
+4. [Short-Term Memory](./4_short_term_memory.md)
+
+5. [Chunking & Spaced Review](./5_chunking_and_spaced_review.md)
+
+6. [Cognitive Biases](./6_cognitive_biases.md)
+
+7. [Procrastination](./7_procrastination.md)
+
+8. [Practical Study Techniques](./8_practical_study_techniques.md)
+
+9. [PDX Code Guild](./9_pdx_code_guild.md)
+
+
diff --git a/docs/how_to_learn/combatting_computer_vision_syndrome.md b/docs/how_to_learn/combatting_computer_vision_syndrome.md
new file mode 100644
index 0000000..4d29b5c
--- /dev/null
+++ b/docs/how_to_learn/combatting_computer_vision_syndrome.md
@@ -0,0 +1,44 @@
+
+
+
+
+
+ Computer Vision Syndrome
+ Prevention and Treatment
+
+
+
+
+The following may be practiced to help alleviate/prevent Computer Vision Syndrome:
+
+- Resting your eyes at least 15 minutes after each 2 hours of computer use
+
+- Looking away from the computer and into the distance for at least 20 seconds every 20 minutes (Pomodoro Technique / 20-20-20 Rule)
+
+- Enlarging the text on your computer screen
+
+- Reducing glare from nearby light sources
+
+- Using a screen glare filter
+
+- Using a flat-screen monitor
+
+- Positioning your screen so that the center is 4 to 5 inches below your eye level
+
+- Positioning your screen so that it is 20 to 28 inches from your eye
+
+- Remembering to blink often
+
+- Wearing lenses to correct your vision
+
+- Using lubricating eye drops
+
+- Using a humidifier
+
+- Minimize caffeine intake
+
+- Drinking plenty of water
+
+- Drinking green tea during your break may help even more, because green tea contains antioxidants called catechins that may help your eyes produce tears for better lubrication.
+
+- Taking a prescription medicine to increase tear production
diff --git a/docs/how_to_learn/images/20_20_20_rule.drawio.svg b/docs/how_to_learn/images/20_20_20_rule.drawio.svg
new file mode 100644
index 0000000..e0c8a88
--- /dev/null
+++ b/docs/how_to_learn/images/20_20_20_rule.drawio.svg
@@ -0,0 +1,120 @@
+
\ No newline at end of file
diff --git a/docs/how_to_learn/images/beta_amyloid.jpg b/docs/how_to_learn/images/beta_amyloid.jpg
new file mode 100644
index 0000000..3e02b6b
Binary files /dev/null and b/docs/how_to_learn/images/beta_amyloid.jpg differ
diff --git a/docs/how_to_learn/images/blue_light.drawio.svg b/docs/how_to_learn/images/blue_light.drawio.svg
new file mode 100644
index 0000000..8a98414
--- /dev/null
+++ b/docs/how_to_learn/images/blue_light.drawio.svg
@@ -0,0 +1,109 @@
+
\ No newline at end of file
diff --git a/docs/how_to_learn/images/chunking/chunking.drawio.svg b/docs/how_to_learn/images/chunking/chunking.drawio.svg
new file mode 100644
index 0000000..414d8ff
--- /dev/null
+++ b/docs/how_to_learn/images/chunking/chunking.drawio.svg
@@ -0,0 +1,289 @@
+
\ No newline at end of file
diff --git a/docs/how_to_learn/images/chunking/chunking_1.drawio.svg b/docs/how_to_learn/images/chunking/chunking_1.drawio.svg
new file mode 100644
index 0000000..31aca94
--- /dev/null
+++ b/docs/how_to_learn/images/chunking/chunking_1.drawio.svg
@@ -0,0 +1,6 @@
+
\ No newline at end of file
diff --git a/docs/how_to_learn/images/chunking/chunking_2.drawio.svg b/docs/how_to_learn/images/chunking/chunking_2.drawio.svg
new file mode 100644
index 0000000..c0297ff
--- /dev/null
+++ b/docs/how_to_learn/images/chunking/chunking_2.drawio.svg
@@ -0,0 +1,7 @@
+
\ No newline at end of file
diff --git a/docs/how_to_learn/images/chunking/chunking_3.drawio.svg b/docs/how_to_learn/images/chunking/chunking_3.drawio.svg
new file mode 100644
index 0000000..c98ef27
--- /dev/null
+++ b/docs/how_to_learn/images/chunking/chunking_3.drawio.svg
@@ -0,0 +1,9 @@
+
\ No newline at end of file
diff --git a/docs/how_to_learn/images/chunking/chunking_4.drawio.svg b/docs/how_to_learn/images/chunking/chunking_4.drawio.svg
new file mode 100644
index 0000000..ab8fe4a
--- /dev/null
+++ b/docs/how_to_learn/images/chunking/chunking_4.drawio.svg
@@ -0,0 +1,13 @@
+
\ No newline at end of file
diff --git a/docs/how_to_learn/images/chunking/chunking_5.drawio.svg b/docs/how_to_learn/images/chunking/chunking_5.drawio.svg
new file mode 100644
index 0000000..c302213
--- /dev/null
+++ b/docs/how_to_learn/images/chunking/chunking_5.drawio.svg
@@ -0,0 +1,13 @@
+
\ No newline at end of file
diff --git a/docs/how_to_learn/images/chunking/chunking_6.drawio.svg b/docs/how_to_learn/images/chunking/chunking_6.drawio.svg
new file mode 100644
index 0000000..1128967
--- /dev/null
+++ b/docs/how_to_learn/images/chunking/chunking_6.drawio.svg
@@ -0,0 +1,13 @@
+
\ No newline at end of file
diff --git a/docs/how_to_learn/images/chunking/chunking_7.drawio.svg b/docs/how_to_learn/images/chunking/chunking_7.drawio.svg
new file mode 100644
index 0000000..2b9e4f7
--- /dev/null
+++ b/docs/how_to_learn/images/chunking/chunking_7.drawio.svg
@@ -0,0 +1,13 @@
+
\ No newline at end of file
diff --git a/docs/how_to_learn/images/dunning_kruger.png b/docs/how_to_learn/images/dunning_kruger.png
new file mode 100644
index 0000000..16d37ab
Binary files /dev/null and b/docs/how_to_learn/images/dunning_kruger.png differ
diff --git a/docs/how_to_learn/images/imposter_syndrome_comic.png b/docs/how_to_learn/images/imposter_syndrome_comic.png
new file mode 100644
index 0000000..dede86b
Binary files /dev/null and b/docs/how_to_learn/images/imposter_syndrome_comic.png differ
diff --git a/docs/how_to_learn/images/pdx_code_guild_logo.svg b/docs/how_to_learn/images/pdx_code_guild_logo.svg
new file mode 100644
index 0000000..96b3805
--- /dev/null
+++ b/docs/how_to_learn/images/pdx_code_guild_logo.svg
@@ -0,0 +1,2 @@
+
+
diff --git a/docs/how_to_learn/images/pomodoro.jpg b/docs/how_to_learn/images/pomodoro.jpg
new file mode 100644
index 0000000..e566726
Binary files /dev/null and b/docs/how_to_learn/images/pomodoro.jpg differ
diff --git a/docs/how_to_learn/images/pomodoro_technique.drawio.svg b/docs/how_to_learn/images/pomodoro_technique.drawio.svg
new file mode 100644
index 0000000..2cdd7b0
--- /dev/null
+++ b/docs/how_to_learn/images/pomodoro_technique.drawio.svg
@@ -0,0 +1,173 @@
+
\ No newline at end of file
diff --git a/docs/how_to_learn/images/procrastination.drawio.svg b/docs/how_to_learn/images/procrastination.drawio.svg
new file mode 100644
index 0000000..af7fb67
--- /dev/null
+++ b/docs/how_to_learn/images/procrastination.drawio.svg
@@ -0,0 +1,180 @@
+
\ No newline at end of file
diff --git a/docs/how_to_learn/images/procrastination.jpg b/docs/how_to_learn/images/procrastination.jpg
new file mode 100644
index 0000000..40baddf
Binary files /dev/null and b/docs/how_to_learn/images/procrastination.jpg differ
diff --git a/docs/how_to_learn/images/rubber_duck.jpg b/docs/how_to_learn/images/rubber_duck.jpg
new file mode 100644
index 0000000..850118e
Binary files /dev/null and b/docs/how_to_learn/images/rubber_duck.jpg differ
diff --git a/docs/how_to_learn/images/short_term_memory/STM_1.drawio.svg b/docs/how_to_learn/images/short_term_memory/STM_1.drawio.svg
new file mode 100644
index 0000000..e10ecdd
--- /dev/null
+++ b/docs/how_to_learn/images/short_term_memory/STM_1.drawio.svg
@@ -0,0 +1,41 @@
+
\ No newline at end of file
diff --git a/docs/how_to_learn/images/short_term_memory/STM_2.drawio.svg b/docs/how_to_learn/images/short_term_memory/STM_2.drawio.svg
new file mode 100644
index 0000000..deb6cec
--- /dev/null
+++ b/docs/how_to_learn/images/short_term_memory/STM_2.drawio.svg
@@ -0,0 +1,165 @@
+
\ No newline at end of file
diff --git a/docs/how_to_learn/images/short_term_memory/STM_3.drawio.svg b/docs/how_to_learn/images/short_term_memory/STM_3.drawio.svg
new file mode 100644
index 0000000..309a5c3
--- /dev/null
+++ b/docs/how_to_learn/images/short_term_memory/STM_3.drawio.svg
@@ -0,0 +1,182 @@
+
\ No newline at end of file
diff --git a/docs/how_to_learn/images/short_term_memory/STM_4.drawio.svg b/docs/how_to_learn/images/short_term_memory/STM_4.drawio.svg
new file mode 100644
index 0000000..c8eb6d6
--- /dev/null
+++ b/docs/how_to_learn/images/short_term_memory/STM_4.drawio.svg
@@ -0,0 +1,182 @@
+
\ No newline at end of file
diff --git a/docs/how_to_learn/images/short_term_memory/STM_5.drawio.svg b/docs/how_to_learn/images/short_term_memory/STM_5.drawio.svg
new file mode 100644
index 0000000..aa11634
--- /dev/null
+++ b/docs/how_to_learn/images/short_term_memory/STM_5.drawio.svg
@@ -0,0 +1,182 @@
+
\ No newline at end of file
diff --git a/docs/how_to_learn/images/short_term_memory/STM_6.drawio.svg b/docs/how_to_learn/images/short_term_memory/STM_6.drawio.svg
new file mode 100644
index 0000000..892305d
--- /dev/null
+++ b/docs/how_to_learn/images/short_term_memory/STM_6.drawio.svg
@@ -0,0 +1,163 @@
+
\ No newline at end of file
diff --git a/docs/how_to_learn/images/short_term_memory/short_term_memory.drawio.svg b/docs/how_to_learn/images/short_term_memory/short_term_memory.drawio.svg
new file mode 100644
index 0000000..4d86d27
--- /dev/null
+++ b/docs/how_to_learn/images/short_term_memory/short_term_memory.drawio.svg
@@ -0,0 +1,787 @@
+
\ No newline at end of file
diff --git a/docs/how_to_learn/images/spaced_review.drawio.svg b/docs/how_to_learn/images/spaced_review.drawio.svg
new file mode 100644
index 0000000..351c1a7
--- /dev/null
+++ b/docs/how_to_learn/images/spaced_review.drawio.svg
@@ -0,0 +1,176 @@
+
\ No newline at end of file
diff --git a/docs/how_to_learn/images/the_brain.drawio.svg b/docs/how_to_learn/images/the_brain.drawio.svg
new file mode 100644
index 0000000..84d852b
--- /dev/null
+++ b/docs/how_to_learn/images/the_brain.drawio.svg
@@ -0,0 +1,174 @@
+
\ No newline at end of file
diff --git a/docs/how_to_learn/tips_for_better_sleep.md b/docs/how_to_learn/tips_for_better_sleep.md
new file mode 100644
index 0000000..0a14000
--- /dev/null
+++ b/docs/how_to_learn/tips_for_better_sleep.md
@@ -0,0 +1,67 @@
+
+
+
+
+
+ 10 Tips for Better Sleep
+
+
+
+
+## 1. Establish a bedtime routine
+
+A regular bedtime and a relaxing bedtime routine will help regulate our Circadian rythym and prepare our bodies to go to sleep. Stretching or meditating before bed can be useful.
+
+
+
+## 2. Don't lie awake in bed
+
+If we can’t fall asleep after 15 to 20 minutes, we should get out of bed and go into another room. While there, we should do something relaxing, such as reading quietly with a dim light.
+
+
+
+
+## 3. Don't use screens
+
+Don’t look at phones, computers or other screens When you feel sleepy again, get back into bed. Don’t sleep in to make up for lost sleep. Avoid reading and watching television in bed.
+
+
+
+## 4. Get plenty of exercise.
+Build up to 30 - 45 minutes of moderate exercise nearly every day. Get your exercise early in the day.
+Whenever possible, schedule stressful or demanding tasks early in the day and less challenging activities later. This helps you wind down at the end of your day.
+
+
+
+## 5. Don’t go to bed hungry...
+But don’t eat a big meal right before getting into bed. If you want a bedtime snack, try to avoid sugar. Favor protein-rich snacks instead.
+
+
+
+## 6. Limit caffeine and alcohol consumption
+
+Both caffeine and alcohol can have negative effects on the quality and quantity of sleep we receive.
+
+
+
+## 7. Turn off the lights!
+Be sure your bed is comfortable and your bedroom is dark and quiet. Consider a sleep mask or earplugs.
+
+
+
+## 8. Don’t take long naps during the day
+
+If you need a nap, restrict it to 20 to 30 minutes in the early afternoon.
+
+
+
+## 9. Breathe
+
+Practice relaxation breathing. Use slow breaths, especially when you exhale.
+
+
+
+## 10. Don't hang out in bed
+
+Use your bed only for sleep or sex. Don’t sit in bed watching TV or reading,as this will train your brain to associate being in bed with sleeping.
+
diff --git a/docs/python_windows.md b/docs/python_windows.md
index 425b432..03741b5 100644
--- a/docs/python_windows.md
+++ b/docs/python_windows.md
@@ -1,4 +1,5 @@
# Installing Python 3 - Windows
+
[Back to Syllabus](../README.md)
Start by heading to the Python [dowload page](https://www.python.org/downloads/)
@@ -15,6 +16,10 @@ Once the download completes open the downloaded file.
This is the first window you should see. Our first step is to click the "Add Python to PATH" checkbox.
+## Attention!
+
+Failure to add Python to the PATH may result in strange errors that will require reinstallation of Python as the easiest fix.
+
Next we want to click on install now.
@@ -27,12 +32,10 @@ Wait for the installation process to do its thing
Finally we should see a window like this. You can click close now.
-
-
Now let's verify everything is working properly.
-Open your powershell by opening your start menu and typing ```powershell```.
+Open your powershell by opening your start menu and typing `powershell`.
You should see something similar to this:
@@ -41,7 +44,7 @@ After clicking on PowerShell we should see a window like this one:
-Now lets type the command ```py``` and press enter:
+Now lets type the command `py` and press enter:
@@ -49,12 +52,12 @@ You should see something similar to this with your python version displayed.
-You should also see ```>>>``` towards the bottom. This means you are now inside your python interpreter.
+You should also see `>>>` towards the bottom. This means you are now inside your python interpreter.
Now that we are inside our python interpreter we can run python commands. Let's try one.
-Type: ```print("Hello World")``` inside your PowerShell and press enter:
+Type: `print("Hello World")` inside your PowerShell and press enter:
@@ -62,7 +65,7 @@ Your PowerShell should output the message "Hello World"
-To exit out of your Python interpreter just type ```exit()``` and press enter:
+To exit out of your Python interpreter just type `exit()` and press enter:
@@ -70,4 +73,4 @@ Now you are back in your normal PowerShell
-Congratulations you have successfully installed Python!
\ No newline at end of file
+Congratulations you have successfully installed Python!
diff --git a/docs/slack.md b/docs/slack.md
new file mode 100644
index 0000000..9ff0a46
--- /dev/null
+++ b/docs/slack.md
@@ -0,0 +1,69 @@
+# Slack
+
+[Back to Syllabus](../README.md)
+
+Slack is a communication tool we will be using in Programming 101 and 102, as well as the PDX Code Guild's boot camps.
+
+By the first day of class, you will be added to a channel, or chatroom. The channel's name will include the start date for the course.
+
+For example, if your **Programming 101** class starts on **Aug 31, 2020**, the channel name will be **101_20-08-31** (class_YY-MM-DD).
+
+## Turning in Labs
+
+### 1. Search for recipient
+
+At the top of the Slack window, you'll find a search bar that says `Search PDX Code Guild Intro Classes`.
+
+
+
+Click the search bar and begin typing the name of the recipient
+
+
+
+Click the recipient's name to open a Direct Message with them.
+
+
+
+### 2. Create a code snippet.
+
+Code must be submitted as a Slack code snippet, otherwise the code's formatting may get lost in translation.
+
+Click the icon shaped like a **lightning bolt** on the bottom left of the chat box.
+
+
+
+Select **Create code or text snippet**. You may need to search for "snippet" in the dropup menu that appears after clicking the lightning bolt icon.
+
+
+
+Enter your code in the box labeled **Content**. You can optionally give your file a name and specify the language as **Python** using the dropdown in the upper right.
+
+
+
+Once you've pasted your code, click the green **Create Snippet** button and your file will be uploaded.
+
+
+
+### 3. Copying code from Slack
+
+The instructor will be posting all class code into Slack.
+
+If you want to copy code from Slack into VS Code, it is advisable to copy the code in the following way:
+
+Hover over the code and find the icon with the **three horizontal dots**.
+
+
+
+Click the icon and select **View Raw**
+
+
+
+This will open a plain text version of the code.
+
+Note:
+
+If you copy and paste directly from the Slack chat, you may encounter strange errors when the code is run.
+
+This is due to invisible whitespace characters that are present in the rendered version of the code in Slack.
+
+Copying the 'raw' version will avoid such errors.
diff --git a/docs/terminal_cheatsheet.md b/docs/terminal_cheatsheet.md
new file mode 100644
index 0000000..a6b471c
--- /dev/null
+++ b/docs/terminal_cheatsheet.md
@@ -0,0 +1,34 @@
+# Terminal Cheatsheet
+
+[Back to Syllabus](../README.md)
+
+The following commands will work in Mac and Linux terminals as well as Windows PowerShell.
+
+## Terminal Navigation
+
+| Action | Command |
+| ------------------------- | ----------------------------- |
+| Display current directory | `pwd` |
+| Show directory contents | `ls` |
+| Change directory | `cd ` |
+| Go up a directory | `cd ..` |
+| Create a directory | `mkdir ` |
+| Delete a directory | `rm -r ` |
+| Move a file or folder | `mv ` |
+| Cancel current operation | `ctrl + C` / `Command + C` |
+
+## Python in the Terminal
+
+Each operating system has a different shortcut for running Python's `.py` files in the terminal.
+
+| Command | Mac | Linux | Windows |
+| ----------------------- | -------- | -------- | -------- |
+| `py .py` | ✗ | ✗ | ✓ |
+| `python3 .py` | ✓ | ✓ | ✗ |
+| `python .py` | ✗ | ✓ | ✗ |
+
+When these commands are run without a `filename`, the **Python** **_interpreter_** will run in the terminal.
+
+Also, the terminal will need to be navigated to the folder containing the file before the file will be able to be run. Use the `ls` command to list the contents of the current directory and use `cd` to change into the directory where the file lives.
+
+[Back to Syllabus](/README.md)
diff --git a/docs/vocab.md b/docs/vocab.md
new file mode 100644
index 0000000..d43b92b
--- /dev/null
+++ b/docs/vocab.md
@@ -0,0 +1,168 @@
+# Programming Vocab
+
+
+
+## Argument
+
+- An object passed to a function to fill one of its parameters
+
+- When a function is called, arguments are passed to fill the functions parameters
+
+## Class
+
+- A data structure which acts as a blueprint for creating objects.
+
+- All Python datatypes are created with classes.
+
+- When we create an object, we're creating an 'instance' of a pre-defined class which shares all the attributes of the class but can have properties unique to each instance
+
+- Classes have attributes which can be functions or variables
+
+## Code Block
+
+- A section of code that executes together
+
+- In Python, code blocks are defined using horizontal indentation.
+
+- The first line of code in a code block determines its indentation and all subsequent lines in that block must match that indentation.
+
+## Concatenation
+- Adding two strings together with a plus sign (`+`) to form a single string
+
+## Docstring
+
+- A multi-line string at the beginning of a function's code block that provides documentation about the function, its parameters and its return value
+
+## Function
+
+- A named code block that performs a specific task.
+
+- Functions reduce repetition in our code by allowing us to write code in a generic way and use it with multiple values.
+
+- Functions are executed with parentheses after their name. (e.g. `print()`)
+
+## Immutable (Unchangeable)
+If an object is immutable, it cannot be given a new value directly. Instead, a new copy of the object will need to be created with the desired changes applied.
+
+See "Mutable"
+
+## Index
+
+- An item's position in a sequence (list, string, etc.)
+
+- Indices are always integers and must correspond to an existing item in the sequence, otherwise an `IndexError` will be raised.
+## Iteration
+A single pass through a loop's code block. A loop is made of one or more iterations.
+
+## Loop
+
+- A code block that repeats until a certain condition is met.
+
+- With a `for` loop, the condition is that there are more items left in the `sequence`
+
+- With a `while` loop, we define the condition directly.
+
+## Method
+
+- A function that only manipulates the object to which it belongs
+
+## Module
+A Python file containing code that can be imported into another Python file to be used.
+
+All the code in the global scope of a module is run when that module is
+
+## Mutable (Changeable)
+If an object is mutable, it has the ability to be given a new value without needing to create a new instance of the object.
+
+See "Immutable"
+
+## Object
+
+- A collection of variables and methods that act on those variables.
+
+- A class is a blueprint for an object. Multiple objects can be created from the same class.
+
+- The variables and methods contained in an object are called its 'attributes'
+
+- An object's attributes are accessed with dot notation (e.g. `'abc'.upper()`)
+
+## Operand
+
+- A piece of data being used to perform an operation
+
+## Operation
+
+- Any process that manipulates data (operands)
+
+## Operator
+
+- A symbol or word that performs an operation on one or more pieces of data (operands)
+
+## Ordered Sequence
+
+- A sequence whose items can be retrieved using their position in the sequence
+
+- An item's position in a sequence is called its 'index'.
+
+- Lists (`list`) and Strings (`str`) are examples of ordered sequences.
+
+- Python Sets (`set`) are an example of an *un*-ordered sequence.
+
+## Parameter
+An empty variable in the definition of a function which will hold the values which are to be used in the function.
+
+When a function is called, values are passed through the parentheses in the function call and those values are assigned to the parameters and then passed into the function's code block.
+
+Parameters can also be given default values that will be used if no value is passed for that parameter.
+
+```python
+# 'a' and 'b' are parameters
+# 'b' has a default value of 1
+def add(a, b=1):
+ '''return the sum of two numbers, 'a' and 'b''''
+ return a + b
+```
+
+
+## Return Value
+The value that is sent back from a function to the location where the function was called.
+
+The return value takes the place of the function call as the code is evaluated.
+
+## Scope
+Four levels in which variables exist in any Python file. Data in outer scopes are available to inner scopes, but data in inner scopes isn't available to outer scopes.
+
+Data can be returned from functions to make it available to outer scopes.
+
+### Levels of scope
+**Built-in** - Everything included behind-the-scenes in a Python file
+
+**Global** - Everything created in the Python file
+
+**Enclosed** - Everything defined within the code block of a global function
+
+**Local** - Everything within the code block of an enclosed function
+
+## Sequence
+A collection of items. Sequences can be ordered (e.g. lists and strings) or unordered (e.g. sets and dictionaries)
+
+If a sequence is ordered, its items can be retrieved using their positions in the list.
+
+## Subscriptable
+The quality of being able to use an index or key to retrieve a value from an object.
+
+
+## Typecasting
+The process of converting one type of data to another.
+## Variable
+- A named storage space for data.
+
+- Variables can store objects of any datatype and can be used in operations involving that datatype.
+
+- Variables can be re-defined with new values at any time.
+
+
+
+
+
+
diff --git a/labs/grading.md b/labs/grading.md
index fc44825..e809ed7 100644
--- a/labs/grading.md
+++ b/labs/grading.md
@@ -1,13 +1,14 @@
# Grading
### Quick Links
+
- [Back to Unit 3](https://github.com/PdxCodeGuild/Programming101/blob/master/units/unit-3.md)
- [Back to Syllabus](https://github.com/PdxCodeGuild/Programming101)
-Let's convert a number grade to a letter grade, using `if` and `elif` statements and comparisons.
+Let's convert a numerical score into a letter grade, using `if` and `elif` statements and comparisons.
-1. Have the user enter a number representing the grade (0-100)
-2. Convert the number grade to a letter grade
+1. Have the user enter a number representing the score (0-100)
+2. Convert the score to a letter grade A - F
## Numeric Ranges
@@ -17,10 +18,16 @@ Let's convert a number grade to a letter grade, using `if` and `elif` statements
- 60-69: D
- 0-59: F
-## Advanced Version 1
+## Extra Challenge 1
+
+Use the `random` module's `randint()` function to determine the user's rival's score.
+1. Grade the rival's score as well
+2. Compare the user's score to the rival's score
+3. Let the user know if they did better than their rival.
+4. Display the result along with **both** student's scores and letter grades.
-Use `randint()` from the random module to determine the user's rival's score. Let the user know if they did better than their rival.
+## Extra Challenge 2
-## Advanced Version 2
+Use `%` to get the remainder of the grade when divided by ten, which is the same as the number in the ones digit. The number in the ones digit will determine whether they will get a `'+'` or a `'-'` appended to the end of their grade.
-Use `%` to get the remainder of the grade when divided by ten, which is the same as the number in the ones digit. The number in the ones digit will determine whether they will get a '+' or a '-' appended to the end of their grade. For example, the grade `81` would be a 'B'. `81 % 10` would give you 1, which is a low number, so you would add a '-' to the end of the grade.
\ No newline at end of file
+For example, the grade `81` would be a 'B'. `81 % 10` would give you `1`, which is a low number, so you would add a `'-'` to the end of the grade.
diff --git a/labs/hello.md b/labs/hello.md
index b48f647..d6cc46e 100644
--- a/labs/hello.md
+++ b/labs/hello.md
@@ -1,86 +1,39 @@
-# Hello!
+## **Lab 1**
-### Quick Links
-- [Back to Unit 01](https://github.com/PdxCodeGuild/Programming101/blob/master/units/unit-1.md)
-- [Back to Syllabus](https://github.com/PdxCodeGuild/Programming101)
-
-## Directions
-
-
-### print()
-
-1. Create a new file `hello.py` in VS Code.
-2. Say hello! with the following code:
+[Back to Unit 1](https://github.com/PdxCodeGuild/Programming101/blob/master/units/unit-1.md)
+[Back to Syllabus](https://github.com/PdxCodeGuild/Programming101)
```python
-print("Hello World!")
+print("Python is fun!")
```
-Run the following code in your terminal:
-**Mac**
-```bash
-python3 hello.py
-```
+Print the following **concatenations**:
-**Windows**
-```bash
-py hello.py
-```
-#### Result
+### **1.1**
-```bash
-Hello World!
-```
+The letters of a word, each in its own string.
-### Concatenating
+---
-1. On a new line, concatenate two strings:
+### **1.2**
-```python
-print("Hello World!")
-print("Hello" + "Mercury!")
-```
+The individual words of a sentence. Place spaces between each word using separate strings.
-Switch to your terminal and run the following command:
+---
-**Mac**
-```bash
-python3 hello.py
-```
-**Windows**
-```bash
-py hello.py
-```
+### **1.3**
-#### Result
-
-```bash
-Hello World!
-HelloMercury!
-```
+The individual characters in a sentence, including spaces and punctuation. Each and every character should be in its own string.
-Do you notice that there is no space in between `Hello` and `Mercury`?
+---
-Edit your code to include a white space:
-```python
-print("Hello World!")
-print("Hello " + "Mercury!")
-```
+### **1.4**
-#### Result
+Place comments explaining your code.
-```bash
-Hello World!
-Hello Mercury!
-```
+---
-### comments
-Now let's go back and add comments to explain the code.
+[Back to Unit 1](https://github.com/PdxCodeGuild/Programming101/blob/master/units/unit-1.md)
-```python
-# saying hello to the world
-print("Hello World!")
-# saying hellow to Mercury
-print("Hello " + "Mercury!")
-```
\ No newline at end of file
+[Back to Syllabus](https://github.com/PdxCodeGuild/Programming101)
diff --git a/labs/madlibs.md b/labs/madlibs.md
index a627446..569a8da 100644
--- a/labs/madlibs.md
+++ b/labs/madlibs.md
@@ -4,48 +4,41 @@
- [Back to Unit 2](https://github.com/PdxCodeGuild/Programming101/blob/master/units/unit-2.md)
- [Back to Syllabus](https://github.com/PdxCodeGuild/Programming101)
-Write a simple program that prompts the user for several inputs then
- prints a [Mad Lib](https://en.wikipedia.org/wiki/Mad_Libs) as the result.
+Write a simple program that prompts the user for seven inputs then
+prints a [Mad Lib](https://en.wikipedia.org/wiki/Mad_Libs) as the result.
+
+It can be a little tricky to find a plain-text Mad Lib that's easy to copy and paste. Instead, choose some song lyrics, a poem or quote, or create your own story.
## Instructions
-1. Search the interwebs for an example Mad Lib
-2. Create a new file and save it as `madlib.py`
-3. Ask the user for each word you'll put in your Mad Lib
-4. Use an `fstring` to put each word into the Mad Lib
+1. Choose some text to act as your Mad Lib
+2. Ask the user for each word you'll put in your Mad Lib
+3. Use an **f-string** to put each word into the Mad Lib
## Example:
```
->>> Give me an antonym for 'data': nonmaterial
->>> Tell me an adjective: Bearded
->>> Give me a sciency buzzword: half-stack
->>> A type of animal (plural): parrots
->>> Some Sciency thing: warp drive
->>> Another sciency thing: Trilithium crystals
->>> Sciency adjective: biochemical
-...
->>> Nonmaterial Scientist Job Description:
->>> Seeking a bearded engineer, able to work on half-stack projects with a team of parrots.
->>> Key responsibilities:
->>> - Extract patterns from non-material
->>> - Optimize warp drive
->>> - Transform trilithium crystals into biochemical material.
+Give me an antonym for 'data': nonmaterial
+Tell me an adjective: Bearded
+Give me a sciency buzzword: half-stack
+A type of animal (plural): parrots
+Some Sciency thing: warp drive
+Another sciency thing: Trilithium crystals
+Sciency adjective: biochemical
+
+Nonmaterial Scientist Job Description:
+
+Seeking a bearded engineer, able to work on half-stack projects with a team of parrots.
+
+Key responsibilities:
+ - Extract patterns from non-material
+ - Optimize warp drive
+ - Transform trilithium crystals into biochemical material.
```
-## Advanced
-* Make a functional solution that utilizes lists. For example, ask the user for 3 adjectives, separated by commas, then use the .split() function to store each adjective and later use it in your story.
-* Add randomness! Use the random module, rather than selecting which adjective goes where in the story.
-
-
-## Super Advanced
-* Make it a repeatable game. Once you're done prompting the user for words, prompt them for whether they'd like to hear the story. Use a while loop to keep asking if they'd like to hear the story again until the answer is 'no'. You could then ask them if they'd like to make another story, and so on.
-
-------------
-
-## Key Concepts
+## Extra Challenge 1
+* Make a solution that asks for a number or numbers, and does a mathematical operation printing out the result of the math
-- Variables
-- String formatting
-- Handling user input
\ No newline at end of file
+## Extra Challenge 2
+* Make it a repeatable game using a `while` loop
diff --git a/labs/magic-8-ball.md b/labs/magic-8-ball.md
index d8650d2..62251cd 100644
--- a/labs/magic-8-ball.md
+++ b/labs/magic-8-ball.md
@@ -28,10 +28,10 @@ Searching my magic globe...
Sorry, it is highly unlikely :(
```
-## Advanced version 1
+## Extra Challenge 1
- Let the user choose if they want to ask a second question.
-## Advanced version 2
+## Extra Challenge 2
- Ask the user if they want to ask another question, using a while loop.
diff --git a/labs/password_generator.md b/labs/password_generator.md
index 5218e58..166f2be 100644
--- a/labs/password_generator.md
+++ b/labs/password_generator.md
@@ -1,14 +1,20 @@
# Password Generator
-Let's generate a password ten characters long using a loop (`while` loop or `for` loop) and `random.choice`, this will be a string of random characters.
+Let's generate a ten-character password using a `while` loop and `random.choice()`.
+The final result will be a string of random characters all on one line.
-## Advanced Version 1
+Example output:
+```
+Your password: Q45pA%x9PJ
+```
+
+## Extra Challenge 1
Allow the user to choose how many characters the password will be.
-## Advanced Version 2
+## Extra Challenge 2
Allow the user to choose how many letters, numbers, and punctuation characters they want in their password. Mix everything up using `list()`, `random.shuffle()`, and `''.join()`.
diff --git a/labs/pdxfolder.md b/labs/pdxfolder.md
index 47df460..66c9af9 100644
--- a/labs/pdxfolder.md
+++ b/labs/pdxfolder.md
@@ -16,7 +16,7 @@ Note: folder names are case sensitive!
4. Minimize your terminal and check your Desktop. Is there a folder called _pdxcode_?
- If yes, congrats! You have completed Lab 01.
- If no, are you in the Desktop folder? Make sure the **"D"** in Desktop is capitalized. Start over, and try again.
- - If you are still lost, checkout the [step-by-step guide](lab01-completed.md) for Lab 01.
+ - If you are still lost, checkout the [step-by-step guide](pdxfolder_completed.md) for Lab 01.
### Takeaways
- You should be comfortable with navigating to the _pdxcode_ folder upon starting terminal.
diff --git a/labs/rps.md b/labs/rps.md
index a6aa82c..48554b2 100644
--- a/labs/rps.md
+++ b/labs/rps.md
@@ -3,31 +3,50 @@
Let's play rock-paper-scissors with the computer.
-1. The computer will ask the user for their choice (rock, paper, scissors)
-2. The computer will randomly choose rock, paper or scissors
-3. Determine who won and tell the user
-
-Let's list all the cases:
-- rock vs rock (tie)
-- rock vs paper
-- rock vs scissors
-- paper vs rock
-- paper vs paper
-- paper vs scissors
-- scissors vs rock
-- scissors vs paper
-- scissors vs scissors
-
-## Advanced Version 1
+1. Greet the user and use a `for` loop to display their possible choices.
+
+```
+Welcome to Rock, Paper, Scissors!
+
+Your options are:
+
+- Rock
+- Paper
+- Scissors
+
+Enter your selection:
+```
+
+2. The computer will ask the user for their choice (rock, paper, scissors).
+3. The computer will randomly choose rock, paper or scissors.
+4. Compare the players' choices and determine who won and tell the user.
+
+NOTE: Do not use index positions during the lab to target any values
+
+## Possible Combinations
+| Human | Computer | Winner
+|-|-|-|
+|rock |rock | Tie
+|rock |paper|Computer|
+|rock |scissors|Human|
+|paper |paper|Tie|
+|paper |rock|Human|
+|paper |scissors|Computer|
+|scissors |scissors|Tie|
+|scissors |rock|Computer|
+|scissors |paper|Human|
+
+
+## Extra Challenge 1
Catch all tie conditions using a single if conditional.
-## Advanced Version 2
+## Extra Challenge 2
Ask the user if they want to play again, using a while loop.
-## Advanced Version 3
+## Extra Challenge 3
-Use a dictionary where each key is one of the choices, and the value associated with the key is a list containing the two other choices.
+We can catch all the win conditions for a Rock, Paper, Scissors game with three conditional statements. To do this, we will need to make a dictionary with three key-value pairs. Each key will represent either Rock, Paper, or Scissors, and the corresponding value for each key will indicate what that key loses to. For example, if the key is Rock, the value will be Paper.
-[//]: # (instructor note: write the tie case, the first case, have them write the others using elif)
\ No newline at end of file
+[//]: # (instructor note: write the tie case, the first case, have them write the others using elif)
diff --git a/practice/README.md b/practice/README.md
new file mode 100644
index 0000000..3ef504e
--- /dev/null
+++ b/practice/README.md
@@ -0,0 +1,15 @@
+# Programming 101
+
+## Practice Problems
+
+### [Unit 0](unit_0/)
+
+### [Unit 1](unit_1/)
+
+### [Unit 2](unit_2/)
+
+### [Unit 3](unit_3/)
+
+### [Unit 4](unit_4/)
+
+### [Unit 5](unit_5/)
diff --git a/practice/unit_0/exercise_1.md b/practice/unit_0/exercise_1.md
new file mode 100644
index 0000000..f9c90c3
--- /dev/null
+++ b/practice/unit_0/exercise_1.md
@@ -0,0 +1,40 @@
+# Unit 0 Practice
+
+## **Exercise 1**
+
+### **1.1**
+
+- Using your choice of **_terminal_**, create a directory for your PDX Code Guild projects. Name it something like `pdx_code`. **Avoid spaces in directory and file names**, you'll save yourself headaches later.
+
+- Inside your directory, **create a directory** for `programming_101` and a directory called `extra`
+
+- Inside the `programming_101` directory, create directories for each of the five units for the course: `unit_1`, `unit_2`, `unit_3`, `unit_4` and `unit_5`.
+
+- Navigate back up to the `pdx_code` directory and create a `programming_102` directory. Create a directory for each unit in Programming 102: `unit_1`, `unit_2`, `unit_3`, `unit_4` and `unit_5`
+
+The final structure of your `pdx_code` directory should be:
+
+```bash
+pdx_code
+ ├── extra
+ ├── programming_101
+ │ ├── unit_1
+ │ ├── unit_2
+ │ ├── unit_3
+ │ ├── unit_4
+ │ └── unit_5
+ └── programming_102
+ ├── unit_1
+ ├── unit_2
+ ├── unit_3
+ ├── unit_4
+ └── unit_5
+```
+
+- We actually don't need our `extra` directory. Navigate to the `pdx_code` directory using the terminal and delete it using terminal commands.
+
+### Exercise 1 [solution](solutions/exercise_1_solution.md)
+
+---
+
+### [<< Back to syllabus](https://github.com/PdxCodeGuild/Programming101/)
diff --git a/practice/unit_0/solutions/exercise_1_solution.md b/practice/unit_0/solutions/exercise_1_solution.md
new file mode 100644
index 0000000..1fca4e4
--- /dev/null
+++ b/practice/unit_0/solutions/exercise_1_solution.md
@@ -0,0 +1,100 @@
+# Unit 0 Practice Solutions
+
+## Exercise 1
+
+This solution was created using a Linux terminal. A terminal on a Mac OS will look similar. If you're on Windows, instead of
+
+ [myComputer Desktop]$
+
+You may see something more like:
+
+ C:\Users\currentUser\Desktop>
+
+### 1.1
+
+**Solution**
+
+Make sure the terminal is navigated on the `Desktop`
+
+ [myComputer Desktop]$
+
+If you type `ls`, you should see the contents of the `Desktop`.
+
+If you are not on the `Desktop` or would like to place your `pdx_code` directory somewhere else, use `cd ` to change directory.
+
+ [myComputer ~]$ ls
+ Desktop Documents Downloads Music Pictures Public Templates Videos
+
+ [myComputer ~]$ cd Desktop
+
+ [myComputer Desktop]$
+
+Once you've navigated to the desired directory, use the command `mkdir` to create a directory named `pdx_code`.
+
+ [myComputer Desktop]$ mkdir pdx_code
+
+ [myComputer Desktop]$ ls
+ pdx_code
+
+Now we can navigate into our `pdx_code` directory
+
+ [myComputer Desktop]$ cd pdx_code
+
+ [myComputer pdx_code]$
+
+Inside your directory, create a directory for `programming_101` and a directory called `extra`
+
+ [myComputer pdx_code]$ mkdir programming_101 extra
+
+Notice `mkdir` is only executed once, but multiple directories are created by separating their names with spaces
+
+Now if we type `ls` we see our new directories
+
+ [myComputer pdx_code]$ ls
+ extra programming_101
+
+Navigate into the `programming_101` directory
+
+ [myComputer pdx_code]$ cd programming_101
+
+ [myComputer programming_101]$
+
+Inside the `programming_101` directory, create directories for each of the five units for the course: `unit_1`, `unit_2`, `unit_3`, `unit_4` and `unit_5`. Type `ls` to see the new directories.
+
+ [myComputer programming_101]$ mkdir unit_1 unit_2 unit_3 unit_4 unit_5
+
+ [myComputer programming_101]$ ls
+ unit_1 unit_2 unit_3 unit_4 unit_5
+
+Using `cd ..` navigate back up to the `pdx_code` directory. The `..` refers to the parent directory of the current directory
+
+ [myComputer programming_101]$ cd ..
+
+ [myComputer pdx_code]$
+
+Create a `programming_102` directory. Create a directory for each unit in Programming 102: `unit_1`, `unit_2`, `unit_3`, `unit_4` and `unit_5`
+
+ [myComputer pdx_code]$ mkdir programming_102
+
+ [myComputer pdx_code]$ ls
+ extra programming_101 programming_102
+
+ [myComputer pdx_code]$ cd programming_102
+
+ [myComputer programming_102]$ mkdir unit_1 unit_2 unit_3 unit_4 unit_5
+
+We actually don't need our `extra` directory. Navigate to the `pdx_code` directory using the terminal and delete it using `rm -r `.
+
+ [myComputer programming_102]$ cd ..
+
+ [myComputer pdx_code]$ ls
+ extra programming_101 programming_102
+
+ [myComputer programming_102]$ rm -r extra
+
+ [myComputer programming_102]$ ls
+ programming_101 programming_102
+
+## [< Exercise 1](../exercise_1.md)
+
+### [<< Back to syllabus](https://github.com/PdxCodeGuild/Programming101/)
diff --git a/practice/unit_1/README.md b/practice/unit_1/README.md
new file mode 100644
index 0000000..8356cf5
--- /dev/null
+++ b/practice/unit_1/README.md
@@ -0,0 +1,8 @@
+# Unit 1 Practice
+
+| Exercise | Description | Concepts | Solutions |
+| ------------------- | ------------------------------------------------ | ---------------------------------------------------------------------------------------------------------- | ---------------------------------------- |
+| [01](exercise_1.md) | Code Signature |
comments
`print()`
| [01](./solutions/exercise_1_solution.md) |
+| [02](exercise_2.md) | Comment out the appropriate lines to make a poem |
| [04](./solutions/exercise_4_solution.md) |
diff --git a/practice/unit_1/exercise_1.md b/practice/unit_1/exercise_1.md
new file mode 100644
index 0000000..8facb92
--- /dev/null
+++ b/practice/unit_1/exercise_1.md
@@ -0,0 +1,38 @@
+# Unit 1 Practice
+
+## **Exercise 1**
+
+### **1.1**
+
+- Create a code signature to place in a comment at the top of your project to tell other developers who wrote the code.
+- The signature should contain:
+
+ - Project name
+ - Version number
+ - Author
+ - Email
+ - Date
+
+- Add it to your code once as _single_-line comments, and once as a _multi_-line comment
+
+ *'-.-'*'-.-'*'-.-'*'--'*
+ Project: Python
+ Version: 1.0
+ Author: Guido van Rossum
+ Email: bdfl@python.com
+ Date: Jan, 1994
+ *'-.-'*'-.-'*'-.-'*'--'*
+
+### **1.2**
+
+`print` the signature under its
+respective comment using the same format as the comment -
+single lines under the single line comments, multi-line under the multi-line comment
+
+### Exercise 1 [solution](solutions/exercise_1_solution.md)
+
+---
+
+## [Exercise 2 >](exercise_2.md)
+
+### [<< Back to Unit 1 Practice](/practice/unit_1/)
diff --git a/practice/unit_1/exercise_2.md b/practice/unit_1/exercise_2.md
new file mode 100644
index 0000000..3f321cb
--- /dev/null
+++ b/practice/unit_1/exercise_2.md
@@ -0,0 +1,39 @@
+## **Exercise 2**
+
+**"Comment out"** lines of code until you achieve
+the following output:
+
+ 'The time has come,' the Walrus said,
+ To talk of many things:
+ Of shoes and ships and sealing-wax —
+ Of cabbages and kings —
+ And why the sea is boiling hot —
+ And whether pigs have wings!'
+
+Also, add `comments` on the lines of code you keep
+that denote the number of the line in the poem. These can be
+added on the same line as the code.
+
+**The code**:
+
+```python
+print("'The time has come,' the Walrus said,")
+print("'Twas brillig, and the slithy toves")
+print("'To talk of many things:")
+print("Did gyre and gimble in the wabe:")
+print("Of shoes — and ships — and sealing-wax —")
+print("All mimsy were the borogoves, ")
+print("Of cabbages — and kings —")
+print("And the mome raths outgrabe. ")
+print("And why the sea is boiling hot —")
+print("O frabjous day! Callooh! Callay!")
+print("And whether pigs have wings!'")
+```
+
+### Exercise 2 [solution](solutions/exercise_2_solution.md)
+
+---
+
+## [< Exercise 1](exercise_1.md) | [Exercise 3 >](exercise_3.md)
+
+### [<< Back to Unit 1 Practice](/practice/unit_1/)
diff --git a/practice/unit_1/exercise_3.md b/practice/unit_1/exercise_3.md
new file mode 100644
index 0000000..9fb51e3
--- /dev/null
+++ b/practice/unit_1/exercise_3.md
@@ -0,0 +1,43 @@
+# Unit 1 Practice
+
+## **Exercise 3**
+
+Using one or more string methods:
+
+### **3.1**
+
+Capitalize a word
+
+ word: bicycle
+ output: Bicycle
+
+ word: guitar
+ output: Guitar
+
+ word: envelope
+ output: Envelope
+
+### **3.2**
+
+Display a word in all capital letters and all lowercase letters
+
+ word: vIoLiN
+ output: VIOLIN violin
+
+### **3.3**
+
+Exchange all instances of a letter within a word with a different
+
+ word: Mississippi
+
+ ...exchange 's' for 'z'...
+
+ output: Mizzizzippi
+
+### Exercise 3 [solution](solutions/exercise_3_solution.md)
+
+---
+
+## [< Exercise 2](exercise_2.md) | [Exercise 4 >](exercise_4.md)
+
+### [<< Back to Unit 1 Practice](/practice/unit_1/)
diff --git a/practice/unit_1/exercise_4.md b/practice/unit_1/exercise_4.md
new file mode 100644
index 0000000..0156732
--- /dev/null
+++ b/practice/unit_1/exercise_4.md
@@ -0,0 +1,30 @@
+# Unit 1 Practice
+
+## **Exercise 4**
+
+Print a famous quote with the following criteria
+
+- Use only one `print()`
+
+- Using escape characters:
+
+ - Place the quote and its author's name on separate lines.
+
+ - Indent the author's name
+
+ - Break the quote up onto multiple lines, if appropriate.
+
+- Include quotation marks around the quote
+
+ Output:
+ "The secret of genius is to carry the spirit of the child into old age, which means never losing your enthusiasm."
+
+ - Aldous Huxley
+
+### Exercise 4 [solution](solutions/exercise_4_solution.md)
+
+---
+
+## [< Exercise 3](exercise_3.md)
+
+### [<< Back to Unit 1 Practice](/practice/unit_1/)
diff --git a/practice/unit_1/solutions/exercise_1_solution.md b/practice/unit_1/solutions/exercise_1_solution.md
new file mode 100644
index 0000000..28f1b17
--- /dev/null
+++ b/practice/unit_1/solutions/exercise_1_solution.md
@@ -0,0 +1,67 @@
+# Unit 1 Practice Solutions
+
+## Exercise 1
+
+### 1.1
+
+**Solution**
+
+```python
+# As single line comments:
+
+# *'-.-'*'-.-'*'-.-'*'--'*
+# Project: Python
+# Version: 1.0
+# Author: Guido van Rossum
+# Email: bdfl@python.com
+# Date: Jan, 1994
+# *'-.-'*'-.-'*'-.-'*'--'*
+
+
+# As multi-line comment:
+
+'''
+*'-.-'*'-.-'*'-.-'*'--'*
+ Project: Python
+ Version: 1.0
+Author: Guido van Rossum
+Email: bdfl@python.com
+ Date: Jan, 1994
+*'-.-'*'-.-'*'-.-'*'--'*
+'''
+```
+
+### 1.2
+
+**Solution**
+
+```python
+# Single lines:
+
+print("*'-.-'*'-.-'*'-.-'*'--'*")
+print(" Project: Python")
+print(" Version: 1.0")
+print("Author: Guido van Rossum")
+print(" Email: bdfl@python.com")
+print(" Date: Jan, 1994")
+print("*'-.-'*'-.-'*'-.-'*'--'*")
+
+
+# Multi-line
+
+print('''
+ *'-.-'*'-.-'*'-.-'*'--'*
+ Project: Python
+ Version: 1.0
+ Author: Guido van Rossum
+ Email: bdfl@python.com
+ Date: Jan, 1994
+ *'-.-'*'-.-'*'-.-'*'--'*
+ '''
+) # notice how this parenthesis
+#is at the same indentation as print()
+```
+
+## [< Exercise 1](../exercise_1.md)
+
+### [<< Back to Unit 1 Practice](/practice/unit_1/)
diff --git a/practice/unit_1/solutions/exercise_2_solution.md b/practice/unit_1/solutions/exercise_2_solution.md
new file mode 100644
index 0000000..af89e45
--- /dev/null
+++ b/practice/unit_1/solutions/exercise_2_solution.md
@@ -0,0 +1,25 @@
+# Unit 1 Practice Solutions
+
+## Exercise 2
+
+### 2.1
+
+**Solution**
+
+```python
+print("The time has come,' the Walrus said,") # line 1
+# print("'Twas brillig, and the slithy toves")
+print("To talk of many things:") # line 2
+# print("Did gyre and gimble in the wabe:")
+print("Of shoes — and ships — and sealing-wax —") # line 3
+# print("All mimsy were the borogoves, ")
+print("Of cabbages — and kings —") # line 4
+# print("And the mome raths outgrabe. ")
+print("And why the sea is boiling hot —") # line 5
+# print("O frabjous day! Callooh! Callay!")
+print("And whether pigs have wings.'") # line 6
+```
+
+## [< Exercise 2](../exercise_2.md) | [Exercise 3 >](../exercise_3.md)
+
+### [<< Back to Unit 1 Practice](/practice/unit_1/)
diff --git a/practice/unit_1/solutions/exercise_3_solution.md b/practice/unit_1/solutions/exercise_3_solution.md
new file mode 100644
index 0000000..9e95b91
--- /dev/null
+++ b/practice/unit_1/solutions/exercise_3_solution.md
@@ -0,0 +1,52 @@
+# Unit 1 Practice Solutions
+
+## Exercise 3
+
+### 3.1
+
+Capitalize a word
+
+`.capitalize()` will convert the first letter in a string to uppercase.
+
+`.title()` will convert the first letter of _each word_ in a string to uppercase.
+
+**Solution**
+
+```python
+# Bicycle - using .capitalize()
+print('bicycle'.capitalize()))
+
+# Guitar - using .title()
+print('guitar'.title())
+```
+
+### 3.2
+
+Display a word in all capital letters and all lowercase letters
+
+`.upper()` will convert all letters in a string to uppercase.
+`.lower()` will convert all letters in a string to lowercase.
+
+**Solution**
+
+```python
+# word: vIoLiN
+print('vIoLiN'.upper() + ' ' + vIoLiN.lower())
+```
+
+### 3.3
+
+**Solution**
+
+Exchange all instances of a letter within a word with a different
+
+The string method `.replace(old, new)` will replace the `old` character with the `new` character.
+
+```python
+# Mizzizzippi
+print('Mississippi'.replace('s','z'))
+```
+
+## [< Exercise 2](../exercise_2.md) | [Exercise 4 >](../exercise_4.md)
+
+### [<< Back to Unit 1 Practice](/practice/unit_1/)
diff --git a/practice/unit_1/solutions/exercise_4_solution.md b/practice/unit_1/solutions/exercise_4_solution.md
new file mode 100644
index 0000000..80bc45b
--- /dev/null
+++ b/practice/unit_1/solutions/exercise_4_solution.md
@@ -0,0 +1,33 @@
+# Unit 1 Practice Solutions
+
+## Exercise 4
+
+Print a famous quote:
+
+### **Solution 1**
+
+Escape characters can be used in a string to:
+
+- break it up onto new lines `\n`
+- insert tabs `\t`
+- place quotes within the string `\"`
+
+```python
+print("\"The secret of genius is to carry the spirit of the child into old age, which means never losing your enthusiasm.\"\n\n\t- Aldous Huxley")
+```
+
+### **Solution 2**
+
+Using a multi-line string
+
+```python
+print('''
+The secret of genius is to carry the spirit of the child into old age, which means never losing your enthusiasm."
+
+ - Aldous Huxley
+''')
+```
+
+## [< Exercise 4](../exercise_4.md)
+
+### [<< Back to Unit 1 Practice](/practice/unit_1/)
diff --git a/practice/unit_2/README.md b/practice/unit_2/README.md
new file mode 100644
index 0000000..faad651
--- /dev/null
+++ b/practice/unit_2/README.md
@@ -0,0 +1,7 @@
+# Unit 2 Practice
+
+| Exercise | Description | Concepts | Solutions |
+|----------|-------------|----------|-----------|
+|[01](exercise_1.md) | Mailing address |
|[03](solutions/exercise_3_solution.md)
diff --git a/practice/unit_2/exercise_1.md b/practice/unit_2/exercise_1.md
new file mode 100644
index 0000000..0d9d506
--- /dev/null
+++ b/practice/unit_2/exercise_1.md
@@ -0,0 +1,47 @@
+# Unit 2 Practice
+
+## **Exercise 1 - Mailing Address**
+
+### **1.1**
+
+- Ask the user to enter a mailing address
+ - Street
+ - City
+ - State
+ - Zip Code
+
+- Assign the value of each field to a *variable*
+
+- Display the address back to the user using an `f-string`
+
+ Enter street: 231 Faux Ave.
+ Enter city: Portland
+ Enter state: Oregon
+ Enter zip code: 97211
+
+ Output:
+ 231 Faux Ave.
+ Portland, Oregon
+ 97211
+
+### **1.2**
+
+Using string methods, ensure that the address will be properly capitalized, no matter how it's entered.
+
+ Enter address: 231 fAUx aVE.
+ Enter city: poRtlANd
+ Enter state: orEGOn
+ Enter zip code: 97211
+
+ Output:
+ 231 Faux Ave.
+ Portland, Oregon
+ 97211
+
+### Exercise 1 [solution](solutions/exercise_1_solution.md)
+
+---
+
+## [Exercise 2 >](exercise_2.md)
+
+### [<< Back to Unit 1 Practice](/practice/unit_2/)
\ No newline at end of file
diff --git a/practice/unit_2/exercise_2.md b/practice/unit_2/exercise_2.md
new file mode 100644
index 0000000..155766a
--- /dev/null
+++ b/practice/unit_2/exercise_2.md
@@ -0,0 +1,39 @@
+# Unit 2 Practice
+
+## **Excercise 2 - Count Letters**
+
+### **2.1**
+
+Use string methods to determine the number of times
+a `letter` occurs in a `word`
+
+**Output**
+
+ word: bookkeeper
+ letter: k
+
+ output: 2
+ The letter 'k' occurs in the word 'bookkeeper' 2 times.
+
+### **2.2**
+
+- Ask the user for a `word`
+- Ask the user for a `letter`
+- Assign the `word` and the `letter` to _variables_
+- Determine how many times the `letter` occurs in the `word`
+
+**Output**
+
+ Enter a word: hippopotamus
+ Enter a letter to count: p
+
+ Output:
+ The letter 'p' occurs 3 times in 'hippopotamus'
+
+### Exercise 2 [solution](solutions/exercise_2_solution.md)
+
+---
+
+## [< Exercise 1](exercise_1.md) | [Exercise 3 >](exercise_3.md)
+
+### [<< Back to Unit 2 Practice](/practice/unit_2/)
diff --git a/practice/unit_2/exercise_3.md b/practice/unit_2/exercise_3.md
new file mode 100644
index 0000000..468368f
--- /dev/null
+++ b/practice/unit_2/exercise_3.md
@@ -0,0 +1,30 @@
+# Unit 2 Practice
+
+## **Exercise 3 - Flip Letter Casing**
+
+Have the user enter a word or phrase. Print out the word or phrase with the cases of all the letters flipped.
+
+ Enter a word or phrase: HeLlO wOrLd
+
+ output:
+ hElLo WoRlD
+
+ ------------------------------------------
+ Enter a word or phrase: UPPER lower
+
+ output:
+ upper LOWER
+
+ ------------------------------------------
+ Enter a word or phrase: supERCaliFRagIliSticEXpiAliDoCIOus
+
+ output:
+ SUPercALIfrAGiLIsTICexPIaLIdOcioUS
+
+### Exercise 3 [solution](solutions/exercise_3_solution.md)
+
+---
+
+## [< Exercise 2](exercise_2.md)
+
+### [<< Back to Unit 1 Practice](/practice/unit_1/)
\ No newline at end of file
diff --git a/practice/unit_2/solutions/exercise_1_solution.md b/practice/unit_2/solutions/exercise_1_solution.md
new file mode 100644
index 0000000..dff2318
--- /dev/null
+++ b/practice/unit_2/solutions/exercise_1_solution.md
@@ -0,0 +1,74 @@
+# Unit 2 Practice Solutions
+
+## Exercise 1 - Mailing Address
+
+### **1.1**
+
+**Solution**
+
+```python
+# display a welcome message to the user, for some context
+print("Welcome! Please enter your address:")
+
+# collect address fields
+street = input("Street number: ")
+city = input("City: ")
+state = input("State: ")
+zip_code = input('Zip: ')
+
+# format address using an f-string
+print(f'''
+{street}
+{city}, {state}
+{zip_code}
+''')
+```
+
+**Output**
+
+ Enter street: 231 Faux Ave.
+ Enter city: Portland
+ Enter state: Oregon
+ Enter zip code: 97211
+
+ 231 Faux Ave.
+ Portland, Oregon
+ 97211
+
+### **1.2**
+
+Using string methods, ensure that the address will be properly capitalized, no matter how it's entered.
+
+```python
+street = input("Street number: ")
+city = input("City: ")
+state = input("State: ")
+zip_code = input('Zip: ')
+
+street = street.title()
+city = city.title()
+
+# format address using an f-string
+print(f'''
+{street}
+{city}, {state}
+{zip_code}
+''')
+```
+
+**Output**
+
+ Enter address: 231 fAUx aVE.
+ Enter city: poRtlANd
+ Enter state: orEGOn
+ Enter zip code: 97211
+
+ 231 Faux Ave.
+ Portland, Oregon
+ 97211
+
+Keep in mind that this is just one potential solution.
+
+## [< Exercise 1](../exercise_1.md)
+
+### [<< Back to Unit 2 Practice](/practice/unit_2/)
diff --git a/practice/unit_2/solutions/exercise_2_solution.md b/practice/unit_2/solutions/exercise_2_solution.md
new file mode 100644
index 0000000..2cfa11e
--- /dev/null
+++ b/practice/unit_2/solutions/exercise_2_solution.md
@@ -0,0 +1,54 @@
+# Unit 2 Practice Solutions
+
+## **Exercise 2 - Count letters**
+
+Use string methods to determine the number of times a `letter` occurs in a `word`
+
+### **2.1**
+
+**Solution**
+
+```python
+word = 'bookkeeper'
+letter = 'k'
+
+# use the .count() string method to count the occurrences of the letter in the word
+letter_count = word.count(letter)
+
+print(f"The letter '{letter}' occurs in the word '{word}' {letter_count} times.")
+```
+
+**Output**
+
+ Output:
+ The letter 'k' occurs 2 times in 'bookkeeper'
+
+### **2.2**
+
+In version 2.2, the user enters values for `word` and `letter` using `input()`.
+
+**Solution**
+
+```python
+# get a word and a letter from the user
+word = input('Please enter a word: ')
+letter = input('Please enter a letter: ')
+
+# use the .count() string method to count the occurrences of the letter in the word
+letter_count = word.count(letter)
+
+print(f"The letter '{letter}' occurs in the word '{word}' {letter_count} times.")
+```
+
+**Output**
+
+ Enter a word: hippopotamus
+ Enter a letter to count: p
+
+ The letter 'p' occurs 3 times in 'hippopotamus'
+
+Keep in mind that this is just one potential solution.
+
+## [< Exercise 2](../exercise_2.md)
+
+### [<< Back to Unit 2 Practice](/practice/unit_2/)
diff --git a/practice/unit_2/solutions/exercise_3_solution.md b/practice/unit_2/solutions/exercise_3_solution.md
new file mode 100644
index 0000000..0a76b60
--- /dev/null
+++ b/practice/unit_2/solutions/exercise_3_solution.md
@@ -0,0 +1,32 @@
+# Unit 2 Practice Solutions
+
+## **Exercise 3 - Flip Letter Casing**
+
+**Solution**
+
+```python
+# ask the user for some text
+text = input('Please enter a word or phrase: ')
+
+# use the .swapcase() string method to swap uppercase with lowercase and vice versa
+print(text.swapcase())
+```
+
+**Output**
+
+ Enter a word or phrase: HeLlO wOrLd
+ hElLo WoRlD
+
+ ------------------------------------------
+ Enter a word or phrase: UPPER lower
+ upper LOWER
+
+ ------------------------------------------
+ Enter a word or phrase: supERCaliFRagIliSticEXpiAliDoCIOus
+ SUPercALIfrAGiLIsTICexPIaLIdOcioUS
+
+Keep in mind that this is just one potential solution.
+
+## [< Exercise 3](../exercise_3.md)
+
+### [<< Back to Unit 2 Practice](/practice/unit_2/)
diff --git a/practice/unit_3/README.md b/practice/unit_3/README.md
new file mode 100644
index 0000000..2cc5e87
--- /dev/null
+++ b/practice/unit_3/README.md
@@ -0,0 +1,8 @@
+# Unit 3 Practice
+
+| Exercise | Concepts | Solutions |
+| ---------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------- |
+| [01 - Geometry! ](exercise_1.md) |
| [04 - Number Proximity](./solutions/exercise_4_solution.md) |
diff --git a/practice/unit_3/exercise_1.md b/practice/unit_3/exercise_1.md
new file mode 100644
index 0000000..a32517f
--- /dev/null
+++ b/practice/unit_3/exercise_1.md
@@ -0,0 +1,109 @@
+# Unit 3 Practice
+
+## **Exercise 1 - Geometry**
+
+Let's do a little geometry!
+
+### **1.1**
+
+- Create three variables `a`, `b` and `c`.
+
+- Assign a number to each to represent the lengths of the sides of a **triangle**.
+
+- Calculate the `perimeter` of the triangle
+
+ **Output**
+
+ A triangle with sides of 3, 4, and 5 has a perimeter of 12.
+
+---
+
+### **1.2**
+
+- Create variables with numbers representing the `base` and `height` measurements of the **triangle**. Select `a`, `b` or `c` to represent the `base`.
+
+- Calculate the `area` of the triangle.
+
+ **Output**
+
+ A triangle with a base of 5 and a height of 8 has an area of 20.0.
+ ---
+
+ A triangle with a base of 2.8 and a height of 2.02 has an area of 2.828.
+
+---
+
+### **1.3**
+
+- Assign a number to a variable to represent the `radius` of a circle.
+- Use the constant for `pi` contained within the `math` module and the `radius` _variable_ to calculate the `circumference` and `area` of a **_circle_**.
+
+ **Output**
+
+ Circle
+
+ Radius: 5
+ Circumference: 31.4159...
+ Area: 78.5398...
+
+---
+
+### **1.4**
+
+- Calculate the `volume` of a **_sphere_** with the same `radius`.
+
+ **Output**
+
+ Sphere
+
+ Radius: 5
+ Volume: 523.5987...
+
+---
+
+### **1.5**
+
+- Assign a number to a variable to represent the `radius` of a **second** circle.
+- Use the two radii to calculate the area of an [annulus](https://www.google.com/search?q=annulus%20area).
+
+ **Output**
+
+ Annulus
+
+ Outer Radius: 5
+ Inner Radius: 3
+ Area: 50.26548245743669
+
+---
+
+### **Extra challenges**
+
+### **1.6**
+
+- Create two variables, `a` and `b` to represent the adjacent sides of a right triangle.
+
+- Find the **hypotenuse** of a triangle using `a` and `b`. Assign the value to a variable `c`.
+
+- Display the result to the user
+
+ A triangle with sides of 65 and 72 has a hypotenuse of 97.
+
+---
+
+### **1.7**
+
+Use the `random` module to generate **random integer** values for the circle and sphere's `radius` and the triangle's `base` and `height`.
+
+---
+
+### **1.8**
+
+Have the user enter all number values used in previous versions. Don't forget that `input()` always returns a `string`.
+
+### Exercise 1 [solution](./solutions/exercise_1_solution.md)
+
+---
+
+## [Exercise 2 >](exercise_2.md)
+
+### [<< Back to Unit 3 Practice](/practice/unit_3/)
diff --git a/practice/unit_3/exercise_2.md b/practice/unit_3/exercise_2.md
new file mode 100644
index 0000000..9d216bd
--- /dev/null
+++ b/practice/unit_3/exercise_2.md
@@ -0,0 +1,56 @@
+# Unit 3 Practice
+
+## Exercise 2 - String Comparisons
+
+### **2.1**
+
+- Assign a letter to a variable to serve as the secret `answer`
+
+- Ask the user to enter a `letter`, assign it to a variable
+
+- `if` the user's `letter` is the same as the `answer`, inform the user they've guessed correctly. Otherwise, inform them they've erred and display the correct answer.
+
+### **2.2**
+
+- Ask the user for a `word`
+- Ask the user for a `letter`
+- Assign the `word` and the `letter` to variables
+- Use the keyword `in` to determine if the `letter` is `in` the `word`
+- Tell the user `if` the `letter` is `in` the `word`. Display the letter in uppercase
+
+ Enter a word: umbrella
+ Enter a letter: b
+
+ output:
+ The word "umbrella" contains the letter "B".
+
+ -------------------
+ Enter a word: umbrella
+ Enter a letter: z
+
+ output:
+ The word "umbrella" does not contain the letter "Z".
+
+### **2.3**
+
+ If the word contains the letter, tell the user how many times the letter is in the word
+
+ Enter a word: giraffe
+ Enter a letter: f
+
+ output:
+ The word "giraffe" contains the letter "F" 2 times.
+
+### **2.4**
+
+ Using string methods, determine if the string the user entered contains only letters, no spaces, numbers or special characters.
+
+ `if` the string contains characters **other than letters**, inform the user that those characters aren't allowed.
+
+### Exercise 2 [solution](./solutions/exercise_2_solution.md)
+
+---
+
+## [< Exercise 1](exercise_1.md) | [Exercise 3 >](exercise_3.md)
+
+### [<< Back to Unit 3 Practice](/practice/unit_3/)
\ No newline at end of file
diff --git a/practice/unit_3/exercise_3.md b/practice/unit_3/exercise_3.md
new file mode 100644
index 0000000..45b4737
--- /dev/null
+++ b/practice/unit_3/exercise_3.md
@@ -0,0 +1,29 @@
+# Unit 3 Practice
+
+## **Exercise 3**
+
+You've got a very important message to get out to all your followers on Twitter. Unfortunately, Twitter only allows **280** characters per Tweet. Your message is **over 1,000** characters long and you're wondering **how many** Tweets it will take to get your whole message out.
+
+### **3.1**
+
+Calculate the number of Tweets required, **rounding up** to the nearest integer.
+
+### **3.2**
+
+Ask the user for the `number of characters` in their message
+
+- `if` the length of the message is **less than** the `max_length` allowed for a Tweet, output a `message` telling the user they only need one Tweet
+
+- Otherwise, calculate the number of Tweets required, **rounding up** to the nearest integer and output a `message` telling the user the number of Tweets they will need.
+
+### **3.3**
+
+Display different messages to the user depending on how many Tweets their message requires.
+
+### Exercise 3 [solution](./solutions/exercise_3_solution.md)
+
+---
+
+## [< Exercise 2](exercise_2.md) | [Exercise 4 >](exercise_4.md)
+
+### [<< Back to Unit 3 Practice](/practice/unit_3/)
diff --git a/practice/unit_3/exercise_4.md b/practice/unit_3/exercise_4.md
new file mode 100644
index 0000000..8991b7e
--- /dev/null
+++ b/practice/unit_3/exercise_4.md
@@ -0,0 +1,78 @@
+# **Unit 3 Practice**
+
+## **Exercise 4 - Number Proximity**
+
+### **4.1**
+
+- Assign a `number` to a variable.
+
+- Determine whether the number is within 10 of 100.
+
+**Output**
+
+ number: 92
+ output: 92 is within 10 of 100.
+
+ number: 108
+ output: 108 is within 10 of 100.
+
+ number: 51
+ output: 51 is not within 10 of 100.
+
+### **4.2**
+
+- Have the user enter values for `number_1` and `number_2`.
+
+- Determine whether `number_1` is within 10 of `number_2`.
+
+**Output**
+
+ Enter the first number: 36
+ Enter the second number: 28
+ output: 36 is within 10 of 28.
+ ---
+
+ Enter the first number: 251
+ Enter the second number: 260
+ output: 251 is within 10 of 260.
+ ---
+
+ Enter the first number: 95
+ Enter the second number: 15
+ output: 95 is not within 10 of 15.
+
+### **4.3**
+
+- Have the user enter values for `number_1` and `number_2`.
+
+- Have the user choose the `limit` of how many numbers may be in between the two.
+
+- Determine whether `number_1` and `number_2` are within the limit set by the user.
+
+ Enter the first number: 235
+ Enter the second number: 555
+ Enter how far apart the numbers are allowed to be: 1000
+
+ 235 is within 1000 of 555.
+ ---
+
+ Enter the first number: 66
+ Enter the second number: 62
+ Enter how far apart the numbers are allowed to be: 5
+
+ 66 is within 5 of 62.
+ ---
+
+ Enter the first number: 34
+ Enter the second number: 101
+ Enter how far apart the numbers are allowed to be: 20
+
+ 34 is not within 20 of 101.
+
+### Exercise 4 [solution](./solutions/exercise_4_solution.md)
+
+---
+
+## [< Exercise 3](exercise_3.md)
+
+### [<< Back to Unit 3 Practice](/practice/unit_3/)
diff --git a/practice/unit_3/solutions/exercise_1_solution.md b/practice/unit_3/solutions/exercise_1_solution.md
new file mode 100644
index 0000000..76adec0
--- /dev/null
+++ b/practice/unit_3/solutions/exercise_1_solution.md
@@ -0,0 +1,194 @@
+# Unit 3 Practice Solutions
+
+## Exercise 1 - Geometry
+
+### **1.1**
+
+**Solution**
+
+```python
+# Create three variables a, b and c
+# Assign a number to each to represent the lengths of the sides of a triangle
+a = 3
+b = 4
+c = 5
+
+# Calculate the perimeter of the triangle
+perimeter = a + b + c
+
+# print using an f-string
+print(f'A triangle with sides of {a}, {b}, and {c} has a perimeter of {perimeter}.')
+```
+
+**Output**
+
+ A triangle with sides of 3, 4, and 5 has a perimeter of 12.
+
+---
+
+### **1.2**
+
+**Solution**
+
+```python
+# Create three variables a, b and c
+# Assign a number to each to represent the lengths of the sides of a triangle
+a = 3
+b = 4
+c = 5
+
+# Select a, b or c to represent the base
+base = c
+# Create variables representing the height
+height = 8
+
+
+# Calculate the area
+area = .5 * (base * height)
+
+# print using an f-string
+print(f'A triangle with a base of {base} and a height of {height} has an area of {area}.')
+```
+
+**Output**
+
+ A triangle with a base of 5 and a height of 8 has an area of 20.0.
+
+---
+
+### **1.3**
+
+**Solution**
+
+```python
+import math # for pi constant
+
+#Assign a number to a variable torepresent the radius of a circle.
+radius = 5
+
+# calculate the circumference and area
+circumference = 2 * math.pi * radius
+
+area = math.pi * (radius ** 2)
+
+print(f'''
+Circle
+
+Radius: {radius}
+Circumference: {circumference}
+Area: {area}
+''')
+```
+
+**Output**
+
+ Circle
+
+ Radius: 5
+ Circumference: 31.41592653589793
+ Area: 78.53981633974483
+
+---
+
+### **1.4**
+
+**Solution**
+
+```python
+import math # for pi constant
+
+#Assign a number to a variable torepresent the radius of a sphere.
+radius = 5
+
+# calculate spherical volume
+
+volume = (4/3) * math.pi * (radius ** 3)
+
+print(f'''
+Sphere
+
+Radius: {radius}
+Volume: {volume}
+''')
+```
+
+**Output**
+
+ Sphere
+
+ Radius: 5
+ Volume: 523.5987755982989
+
+---
+
+### **1.5**
+
+**Solution**
+
+```python
+import math # for pi constant
+
+# outer and inner radii
+outer_radius = 5
+inner_radius = 3
+
+# calculate the area
+annulus_area = math.pi * (outer_radius ** 2 - inner_radius ** 2)
+
+print(f'''
+Annulus
+
+Outer radius: {outer_radius}
+Inner radius: {inner_radius}
+
+Area: {annulus_area}
+''')
+```
+
+**Output**
+
+ Annulus
+
+ Outer Radius: 5
+ Inner Radius: 3
+ Area: 50.26548245743669
+
+---
+
+### **1.6**
+
+**Solution**
+
+```python
+import math # for the square root function sqrt()
+
+# Assign a number to each to represent two sides adjacent sides of a triangle
+a = 3
+b = 4
+
+# calculate the hypotenuse with Pythagorean Theorem
+hypotenuse = math.sqrt(a**2 + b**2)
+
+# print using an f-string
+print(f'A triangle adjacent sides of {a} and {b} has a hypotenuse of {hypotenuse}.')
+```
+
+**Output**
+
+ A triangle adjacent sides of 3 and 4 has a hypotenuse of 5.0.
+
+---
+
+### **1.7**
+
+The solution will be the same except with all numbers fulfilled by `random.randint()`
+
+### **1.8**
+
+The solution will be the same except with all numbers collected from the user using `input()`. You can then convert the number to an integer using `int()` or a float using `float()`.
+
+Keep in mind that this is just one potential solution.
+
+## [< Exercise 1](../exercise_1.md)
+
+### [<< Back to Unit 3 Practice](/practice/unit_3/)
diff --git a/practice/unit_3/solutions/exercise_2_solution.md b/practice/unit_3/solutions/exercise_2_solution.md
new file mode 100644
index 0000000..573a0af
--- /dev/null
+++ b/practice/unit_3/solutions/exercise_2_solution.md
@@ -0,0 +1,115 @@
+# Unit 3 Practice Solutions
+
+## Exercise 2 - String Comparisons
+
+### **2.1**
+
+**Solution**
+
+```python
+#Assign a letter to a variable to serve as the secret answer
+secret = 'a'
+
+# Ask the user to enter a letter, assign it to a variable
+guess = input('Please guess a letter a-z: ')
+
+# if the user's letter is the same as the answer, inform the user they've guessed correctly. Otherwise, inform them they've erred and display the correct answer.
+if guess == secret:
+message = f"You guessed the secret letter '{secret}'!"
+else:
+message = f"Your guess of '{guess}' was incorrect."
+
+print(message)
+```
+
+**Output**
+
+ Please guess a letter a-z: a
+ You guessed the secret letter 'a'!
+ ---
+
+ Please guess a letter a-z: z
+ Your guess of 'z' was incorrect.
+
+---
+
+### **2.2**
+
+**Solution**
+
+```python
+#Ask the user for a word
+word = input("Enter a word: ")
+
+# Ask the user for a letter
+letter = input("Enter a letter: ")
+
+# Use the keyword in to determine if the letter is in the word
+# Tell the user if the letter is in the word. Display the letter in uppercase
+
+if letter in word:
+ message = f'The letter "{letter.upper()}" is in the word {word}.'
+else:
+ message = f'The letter "{letter.upper()}" is not in the word {word}.'
+
+
+print(message)
+```
+
+**Output**
+
+ Enter a word: umbrella
+ Enter a letter: b
+
+ The word "umbrella" contains the letter "B".
+ -------------------
+
+ Enter a word: umbrella
+ Enter a letter: z
+
+ The word "umbrella" does not contain the letter "Z".
+
+---
+
+### **2.3**
+
+**Solution**
+
+```python
+#Ask the user for a word
+word = input("Enter a word: ")
+
+# Ask the user for a letter
+letter = input("Enter a letter: ")
+
+# Use the keyword in to determine if the letter is in the word
+# Tell the user if the letter is in the word. Display the letter in uppercase
+
+if letter in word:
+
+ # count the occurances of the letter in the word
+ letter_count = word.count(letter)
+
+ message = f'The word "{word}" contains the letter "{letter.upper()}" {letter_count} times.'
+else:
+ message = f'The letter "{letter.upper()}" is not in the word {word}.'
+
+print(message)
+```
+
+**Output**
+
+ Enter a word: giraffe
+ Enter a letter: f
+
+ The word "giraffe" contains the letter "F" 2 times.
+ ---
+
+ Enter a word: hippopotamus
+ Enter a letter: f
+
+ The word "hippopotamus" does not contain the letter "F".
+
+## [< Exercise 2](../exercise_2.md)
+
+### [<< Back to Unit 3 Practice](/practice/unit_3/)
diff --git a/practice/unit_3/solutions/exercise_3_solution.md b/practice/unit_3/solutions/exercise_3_solution.md
new file mode 100644
index 0000000..36f321c
--- /dev/null
+++ b/practice/unit_3/solutions/exercise_3_solution.md
@@ -0,0 +1,143 @@
+# Unit 3 Practice Solutions
+
+## Exercise 3 - How many Tweets?
+
+### **3.1**
+
+**Solution**
+
+```python
+import math
+
+# number of characters in message
+num_characters = 1345
+
+# Tweets are 280 characters max
+max_per_tweet = 280
+
+# calculate the number of Tweets needed, rounding up
+# with math.ceil()
+tweets_needed = math.ceil(num_characters/max_per_tweet)
+
+# place commas in appropriate places in characters with :,
+message = f'''A message containing {num_characters:,} characters will require {tweets_needed} Tweets.'''
+```
+
+**Output**
+
+ A message containing 1,345 characters will require 5 Tweets.
+
+---
+
+### **3.2**
+
+**Solution**
+
+```python
+import math
+
+# ask the user for number of characters in message
+num_characters = input("Enter the number of characters: ")
+
+# convert to an integer to perform math operations and comparisons
+num_characters = int(num_characters)
+
+# Tweets are 280 characters max
+max_per_tweet = 280
+
+# the user's message has less than 280 characters,
+# they only need one Tweet
+if num_characters < max_per_tweet:
+ message = f'A message with {num_characters} characters only requires one Tweet!'
+else:
+ # calculate the number of Tweets needed, rounding up
+ # with math.ceil()
+ tweets_needed = math.ceil(num_characters/max_per_tweet)
+
+
+ # place commas in appropriate places in characters with :,
+ message = f'''A message containing {num_characters:,} characters will require {tweets_needed} Tweets.'''
+
+print(message)
+```
+
+**Output**
+
+ Enter the number of characters: 12
+
+ A message with 12 characters only requires one Tweet!
+ ---
+
+ Enter the number of characters: 12345
+
+ A message containing 12,345 characters will require 45 Tweets.
+
+---
+
+### **3.3**
+
+**Solution**
+
+```python
+import math
+
+# ask the user for number of characters in message
+num_characters = input("Enter the number of characters: ")
+
+# convert to an integer to perform math operations and comparisons
+num_characters = int(num_characters)
+
+# Tweets are 280 characters max
+max_per_tweet = 280
+
+# the user's message has less than 280 characters,
+# they only need one Tweet
+if num_characters < max_per_tweet:
+ message = f'A message with {num_characters} characters only requires one Tweet!'
+else:
+ # calculate the number of Tweets needed, rounding up
+ # with math.ceil()
+ tweets_needed = math.ceil(num_characters/max_per_tweet)
+
+
+if tweets_needed < 3:
+ comment = '\n\nThat should\'t take you too long!'
+elif tweets_needed < 10:
+ comment = '\n\nYou\'d better get typing!'
+elif tweets_needed >= 10:
+ comment = '\n\nMaybe you should find a different medium...'
+
+# place commas in appropriate places in characters with :,
+message = f'''A message containing {num_characters:,} characters will require {tweets_needed} Tweets.'''
+
+# add the comment to the message
+message += comment
+
+print(message)
+```
+
+**Output**
+
+ Enter the number of characters: 300
+
+ A message containing 300 characters will require 2 Tweets.
+
+ That should't take you too long!
+ ---
+
+ Enter the number of characters: 1000
+
+ A message containing 1,000 characters will require 4 Tweets.
+
+ You'd better get typing!
+ ---
+
+ Enter the number of characters: 10000
+
+ A message containing 10,000 characters will require 36 Tweets.
+
+ Maybe you should find a different medium...
+
+## [< Exercise 3](../exercise_3.md)
+
+### [<< Back to Unit 3 Practice](/practice/unit_3/)
diff --git a/practice/unit_3/solutions/exercise_4_solution.md b/practice/unit_3/solutions/exercise_4_solution.md
new file mode 100644
index 0000000..b4b770c
--- /dev/null
+++ b/practice/unit_3/solutions/exercise_4_solution.md
@@ -0,0 +1,136 @@
+# Unit 3 Practice Solutions
+
+## Exercise 4 - Number Proximity
+
+### **4.1**
+
+**Solution**
+
+```python
+#Assign a number to a variable.
+number = 95
+
+#Determine whether the number is within 10 of 100.
+if number >= 90 and number <= 110:
+ message = f'{number} is within 10 of 100.'
+else:
+ message = f'{number} is not within 10 of 100.'
+
+print(message)
+```
+
+**Output**
+
+ number: 92
+ output: 92 is within 10 of 100.
+
+ number: 108
+ output: 108 is within 10 of 100.
+
+ number: 51
+ output: 51 is not within 10 of 100.
+
+---
+
+### **4.2**
+
+**Solution**
+
+ # Ask the user for two numbers, convert them to integers
+
+ number_1 = input('Enter the first number: ')
+ number_1 = int(number_1)
+
+ number_2 = input('Enter the second number: ')
+ number_2 = int(number_2)
+
+ # check to see which number is larger,
+ # then subtract one from the other. Check if the
+ # result is less than or equal to 10
+ if number_1 >= number_2:
+ if number_1 - number_2 <= 10:
+ message = f'{number_1} is within 10 of {number_2}.'
+ else:
+ message = f'{number_1} is not within 10 of {number_2}'
+ elif number_2 >= number_1:
+ if number_2 - number_1 <= 10:
+ message = f'{number_1} is within 10 of {number_2}.'
+ else:
+ message = f'{number_1} is not within 10 of {number_2}'
+
+
+ print(message)
+
+**Output**
+
+ Enter the first number: 4
+ Enter the second number: 12
+
+ 4 is within 10 of 12.
+ ----
+
+ Enter the first number: 66
+ Enter the second number: 57
+
+ 66 is within 10 of 57.
+ ----
+
+ Enter the first number: 36
+ Enter the second number: 245
+
+ 36 is not within 10 of 245.
+
+---
+
+### **4.3**
+
+This solution uses Python's built-in `abs()` function to find the **absolute value** of the subtraction of `number_2` from `number_1`. The **absolute value** is then used to determine if the numbers are within a certain value of each other.
+
+Alternatively, the solution from **4.2** can be used and 10 can be replaced with the user's value for how far apart the numbers are allowed to be.
+
+**Solution**
+
+ # Ask the user for two numbers, and how far apart they're allowed to be. # convert to integers
+ number_1 = input('Enter the first number: ')
+ number_1 = int(number_1)
+
+ number_2 = input('Enter the second number: ')
+ number_2 = int(number_2)
+
+ threshold = input('Enter how far apart the numbers are allowed to be: ')
+ threshold = int(threshold)
+
+ # use abs() to find the absolute value,
+ # check if the absolute value is within the threshold
+ if abs(number_1 - number_2) <= threshold:
+ message = f'{number_1} is within {threshold} of {number_2}.'
+ else:
+ message = f'{number_1} is not within {threshold} of {number_2}.'
+
+ print(message)
+
+**Output**
+
+ Enter the first number: 235
+ Enter the second number: 555
+ Enter how far apart the numbers are allowed to be: 1000
+
+ 235 is within 1000 of 555.
+ ---
+
+ Enter the first number: 66
+ Enter the second number: 62
+ Enter how far apart the numbers are allowed to be: 5
+
+ 66 is within 5 of 62.
+ ---
+
+ Enter the first number: 34
+ Enter the second number: 101
+ Enter how far apart the numbers are allowed to be: 20
+
+ 34 is not within 20 of 101.
+
+## [< Exercise 4](../exercise_4.md)
+
+### [<< Back to Unit 3 Practice](/practice/unit_3/)
diff --git a/practice/unit_4/README.md b/practice/unit_4/README.md
new file mode 100644
index 0000000..5589ef9
--- /dev/null
+++ b/practice/unit_4/README.md
@@ -0,0 +1,9 @@
+# Unit 4 Practice
+
+| Exercise | Concepts | Solution |
+| --------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------ |
+| [01 - Number Lists ](exercise_1.md) |
| [05 - More Number Lists](./solutions/exercise_5_solution.md) |
diff --git a/practice/unit_4/exercise_1.md b/practice/unit_4/exercise_1.md
new file mode 100644
index 0000000..d2872ac
--- /dev/null
+++ b/practice/unit_4/exercise_1.md
@@ -0,0 +1,43 @@
+# **Unit 4 Practice**
+
+## **Exercise 1 - Number Lists**
+
+Create a list of 10 `numbers` between 1 and 10.
+
+### **1.1**
+
+Print all the number in the list that are less than or equal to 5.
+
+**Output**
+
+numbers: [3, 3, 10, 5, 4, 5, 6, 5, 7, 2]
+
+ Less than five: [3, 3, 5, 4, 5, 5, 2]
+
+### **1.2**
+
+Count the number of times the number 5 occurs in your list.
+
+**Output**
+
+ numbers: [3, 3, 10, 5, 4, 5, 6, 5, 7, 2]
+
+ The number 5 occurs 3 times.
+
+### **1.3**
+
+Change the value of each number in the list to be the square of itself. Then print the new list.
+
+**Output**
+
+ numbers: [3, 3, 10, 5, 4, 5, 6, 5, 7, 2]
+
+ [9, 9, 100, 25, 16, 25, 36, 25, 49, 4]
+
+### Exercise 1 [solution](./solutions/exercise_1_solution.md)
+
+---
+
+## [Exercise 2 >](exercise_2.md)
+
+### [<< Back to Unit 4 Practice](/practice/unit_4/)
diff --git a/practice/unit_4/exercise_2.md b/practice/unit_4/exercise_2.md
new file mode 100644
index 0000000..eb6e365
--- /dev/null
+++ b/practice/unit_4/exercise_2.md
@@ -0,0 +1,38 @@
+# **Unit 4 Practice**
+
+## **Exercise 2 - Sum, Mean, Mode**
+
+Use a loop to create a list of 10 random numbers between 1 and 10.
+
+### **2.1**
+
+Loop through the list of numbers and calculate the `sum`.
+
+ numbers: 1, 4, 6, 4, 6, 4, 5, 9
+ sum: 39
+
+### **2.2**
+
+Loop through the list of numbers and calculate the `mean` (average).
+
+ numbers: 1, 4, 6, 4, 6, 4, 5, 9
+ mean: 4.875
+
+### **2.3**
+
+Have your loop generate a list of 20 numbers instead.
+
+Loop through the list of numbers and calculate the `mode`.
+
+ numbers: [4, 2, 7, 7, 5, 2, 6, 7, 8, 3, 7, 8, 5, 10, 8, 8, 9, 2, 6, 9]
+
+ mode: 8
+ The number 8 appears 4 times.
+
+### Exercise 2 [solution](./solutions/exercise_2_solution.md)
+
+---
+
+## [< Exercise 1](exercise_1.md) | [Exercise 3 >](exercise_3.md)
+
+### [<< Back to Unit 4 Practice](/practice/unit_4/)
diff --git a/practice/unit_4/exercise_3.md b/practice/unit_4/exercise_3.md
new file mode 100644
index 0000000..a15d29c
--- /dev/null
+++ b/practice/unit_4/exercise_3.md
@@ -0,0 +1,20 @@
+# **Unit 4 Practice**
+
+## **Exercise 3 - Flip the Numbers**
+
+Use a loop to create a list of 10 random numbers between -100 and 100.
+
+### **3.1**
+
+Loop through the list of numbers and switch each number to its opposite sign. Negatives become positives, positives become negatives.
+
+ numbers: [10, -36, 6, -39, -96, 13, -35, 83, -52, 86]
+ flipped: [-10, 36, -6, 39, 96, -13, 35, -83, 52, -86]
+
+### Exercise 3 [solution](./solutions/exercise_3_solution.md)
+
+---
+
+## [< Exercise 2](exercise_2.md) | [Exercise 4 >](exercise_4.md)
+
+### [<< Back to Unit 4 Practice](/practice/unit_4/)
diff --git a/practice/unit_4/exercise_4.md b/practice/unit_4/exercise_4.md
new file mode 100644
index 0000000..313de1f
--- /dev/null
+++ b/practice/unit_4/exercise_4.md
@@ -0,0 +1,58 @@
+# **Unit 4 Practice**
+
+## **Exercise 4 - Looping Strings**
+
+### **4.1**
+
+Using a `for` loop, ask the user for the name of three items (animals, colors, fruits, or whatever you'd like).
+
+### **4.2**
+
+Loop through the user's list and with iteration, print both the item and all the letters in the item.
+
+ Enter an animal: lynx
+ Enter an animal: ocelot
+ Enter an animal: puma
+
+ lynx
+ l
+ y
+ n
+ x
+ ocelot
+ o
+ c
+ e
+ l
+ o
+ t
+ puma
+ p
+ u
+ m
+ a
+
+### **4.3**
+
+Loop through the list.
+
+Loop through the letters of each word.
+
+Create a list of the characters that occur in the words. If a letter has already been added to the list, skip it.
+
+**Output**
+
+ Enter an animal: lynx
+ Enter an animal: ocelot
+ Enter an animal: puma
+
+ Letters used:
+ ['l', 'y', 'n', 'x', 'o', 'c', 'e', 't', 'p', 'u', 'm', 'a']
+
+### Exercise 4 [solution](./solutions/exercise_4_solution.md)
+
+---
+
+## [< Exercise 3](exercise_3.md) | [Exercise 5 >](exercise_5.md)
+
+### [<< Back to Unit 4 Practice](/practice/unit_4/)
diff --git a/practice/unit_4/exercise_5.md b/practice/unit_4/exercise_5.md
new file mode 100644
index 0000000..5e63f1a
--- /dev/null
+++ b/practice/unit_4/exercise_5.md
@@ -0,0 +1,47 @@
+# **Unit 4 Practice**
+
+## **Exercise 5 - More Number Lists**
+
+Use a loop and `random.randint()` to generate a list of ten `random_numbers` between 1 and 100.
+
+### **5.1**
+
+Count the number of even numbers in the list. **Hint**: You can use `% 2` to determine if a number is even or odd.
+
+**Output**
+
+ Numbers: [64, 3, 55, 94, 40, 56, 40, 69, 54, 3]
+ There are 6 evens: [64, 94, 40, 56, 40, 54]
+
+### **5.2**
+
+Reverse the list using a loop and without any methods or built-in functions
+
+**Output**
+
+ numbers: 5, 90, 43, 52, 21, 49, 92, 40, 33, 84
+
+ [25, 8100, 1849, 2704, 441, 2401, 8464, 1600, 1089, 7056]
+
+### **5.3**
+
+Sort the list of numbers in ascending order without using methods or built-in functions.
+
+**Output**
+
+ numbers: [62, 23, 56, 30, 55, 60, 31, 91, 93, 45]
+ sorted: [23, 30, 31, 45, 55, 56, 60, 62, 91, 93]
+
+### **Hint:**
+
+One way to accomplish this is by implementing a **bubble sort** algorithm.
+
+View bubble sort pseudocode [here](./solutions/exercise_5_pseudocode.md).
+
+### Exercise 5 [solution](./solutions/exercise_5_solution.md)
+
+---
+
+## [< Exercise 4](exercise_4.md)
+
+### [<< Back to Unit 4 Practice](/practice/unit_4/)
diff --git a/practice/unit_4/solutions/exercise_1_solution.md b/practice/unit_4/solutions/exercise_1_solution.md
new file mode 100644
index 0000000..5647cd9
--- /dev/null
+++ b/practice/unit_4/solutions/exercise_1_solution.md
@@ -0,0 +1,84 @@
+# Unit 4 Practice Solutions
+
+## Exercise 1 - Number Lists
+
+### **1.1**
+
+```python
+# Create a list of 10 numbers between 1 and 10.
+numbers = [4, 9, 3, 9, 5, 7, 2, 5, 1, 7]
+
+#Print all the number in the list that are less than or equal to 5.
+
+# empty string for result
+result = []
+
+# loop through the numbers
+for number in numbers:
+ # if the current number is less than 5,
+ if number <= 5:
+ # convert the number to a string
+ number = str(number)
+
+ # add it to the list
+ result.append(number)
+
+
+# display the result
+print(f'numbers: {numbers}')
+print(f'less than five: {result}')
+```
+
+**Output**
+
+ numbers: [3, 3, 10, 5, 4, 5, 6, 5, 7, 2]
+ less than five: [3, 3, 4, 2]
+
+### **1.2**
+
+```python
+# Create a list of 10 numbers between 1 and 10.
+numbers = [4, 9, 3, 9, 5, 7, 2, 5, 1, 7]
+
+# determine how many 5s
+fives = numbers.count(5)
+
+# display the result
+print(f'numbers: {numbers}')
+print(f'The number 5 occurs {numbers.count(5)} times')
+```
+
+**Output**
+
+ numbers: [3, 3, 10, 5, 4, 5, 6, 5, 7, 2]
+ The number 5 occurs 3 times.
+
+### **1.3**
+
+```python
+# numbers list
+numbers = [3, 3, 10, 5, 4, 5, 6, 5, 7, 2]
+
+# display numbers before transformation
+print(f'numbers: {numbers}')
+
+# get the length of the numbers list
+numbers_length = len(numbers)
+# loop the length of the list
+for i in range(numbers_length):
+ # using i as the index for the current number,
+ # change the value at i to the itself squared
+ numbers[i] = numbers[i] ** 2
+
+# display the result
+print(f'squares: {numbers}')
+```
+
+**Output**
+
+ numbers: [3, 3, 10, 5, 4, 5, 6, 5, 7, 2]
+ squares: [9, 9, 100, 25, 16, 25, 36, 25, 49, 4]
+
+Keep in mind that is is just one potential solution
+
+## [< Exercise 1](../exercise_1.md)
diff --git a/practice/unit_4/solutions/exercise_2_solution.md b/practice/unit_4/solutions/exercise_2_solution.md
new file mode 100644
index 0000000..b939914
--- /dev/null
+++ b/practice/unit_4/solutions/exercise_2_solution.md
@@ -0,0 +1,138 @@
+# Unit 4 Practice Solutions
+
+## Exercise 2 - Sum, Mean, Mode
+
+### **2.1**
+
+Find the sum of the list of numbers
+
+**Solution**
+
+```python
+import random
+
+# Use a loop to create a list of 10 random numbers between 1 and 10.
+
+# create empty list
+numbers = []
+# loop ten times
+for i in range(10):
+ # generate random number between 1 and 10
+ random_number = random.randint(1, 10)
+ # add the number to the list
+ numbers.append(random_number)
+
+# Loop through the list of numbers and calculate the sum
+# set the total to zero
+total = 0
+# loop through the numbers
+for number in numbers:
+ # add the number to the total
+ total += number
+
+# display the result
+print(f'numbers: {numbers}')
+print(f'sum: {total}')
+```
+
+**Output**
+
+ numbers: [1, 4, 6, 4, 6, 4, 5, 9]
+ sum: 39
+
+### **2.2**
+
+Find the mean (average) of the list of numbers
+
+**Solution**
+
+```python
+import random
+
+# Use a loop to create a list of 10 random numbers between 1 and 10.
+
+# create empty list
+numbers = []
+# loop ten times
+for i in range(10):
+# generate random number between 1 and 10
+random_number = random.randint(1, 10)
+# add the number to the list
+numbers.append(random_number)
+
+# Loop through the list of numbers and calculate the sum
+# set the total to zero
+total = 0
+# loop through the numbers
+for number in numbers:
+ # add the number to the total
+ total += number
+
+# calculate the average
+average = total / len(numbers)
+
+# display the result
+print(f'numbers: {numbers}')
+print(f'average: {average}')
+```
+
+**Output**
+
+ numbers: [1, 4, 6, 4, 6, 4, 5, 9]
+ average: 4.875
+
+### **2.3**
+
+Find the mode
+
+**Solution**
+
+```python
+import random
+
+# Use a loop to create a list of 20 random numbers between 1 and 10.
+
+# create empty list
+numbers = []
+# loop twenty times
+for i in range(20):
+ # generate random number between 1 and 10
+ random_number = random.randint(1, 10)
+ # add the number to the list
+ numbers.append(random_number)
+
+# Loop through the list of numbers and calculate the mode
+
+# set the first element as the default mode
+mode = numbers[0]
+# number of occurances of the mode
+mode_count = numbers.count(mode)
+
+# loop through the list of numbers
+for number in numbers:
+ # calculate the number of times the old mode appears
+ old_count = numbers.count(mode)
+
+ # calculate the number of times the current number appears
+ new_count = numbers.count(number)
+
+ # if the current number occurs more times than the previous mode
+ if new_count > old_count:
+ # set the mode to the current number
+ mode = number
+ # count the occurances of the new mode
+ mode_count = new_count
+
+# display the result
+result = f'''
+numbers: {numbers}
+mode: {mode}
+The number {mode} appears {mode_count} times.
+'''
+
+print(result)
+```
+
+Keep in mind that is is just one potential solution
+
+## [< Exercise 2](../exercise_2.md)
diff --git a/practice/unit_4/solutions/exercise_3_solution.md b/practice/unit_4/solutions/exercise_3_solution.md
new file mode 100644
index 0000000..f30f0d6
--- /dev/null
+++ b/practice/unit_4/solutions/exercise_3_solution.md
@@ -0,0 +1,45 @@
+# Unit 4 Practice Solutions
+
+## Exercise 3 - Flip the Numbers
+
+### **3.1**
+
+**Solution**
+
+```python
+import random
+
+#Use a loop to create a list of 10 random numbers between -100 and 100.
+
+# create empty list
+numbers = []
+# loop 10 times
+for i in range(10):
+ # generate a random number between -100 and 100
+ random_number = random.randint(-100,100)
+ # add the random number to the list
+ numbers.append(random_number)
+
+#Loop through the list of numbers and switch each number to its opposite sign.
+
+# create empty list
+flipped = []
+# loop through each number
+for number in numbers:
+ # flip the sign of the number
+ flipped_number = number * -1
+ # add to the new list
+ flipped.append(flipped_number)
+
+# display results
+print(f'numbers: {numbers}')
+print(f'flipped {flipped}')
+```
+
+Keep in mind that is is just one potential solution
+
+## [< Exercise 3](../exercise_3.md)
+
+---
+
+### [<< Back to Unit 4 Practice](/practice/unit_4/)
diff --git a/practice/unit_4/solutions/exercise_4_solution.md b/practice/unit_4/solutions/exercise_4_solution.md
new file mode 100644
index 0000000..09bfb71
--- /dev/null
+++ b/practice/unit_4/solutions/exercise_4_solution.md
@@ -0,0 +1,132 @@
+# Unit 4 Practice Solutions
+
+## **w**
+
+### **4.1**
+
+Using a for loop, ask the user for the name of three items (animals, colors, fruits, or whatever you'd like).
+
+**Solution**
+
+```python
+# empty list
+animals = []
+
+for i in range(3):
+ # ask the user for an animal
+ animal = input("Enter an animal: ")
+ # add it to the list
+ animals.append(animal)
+
+print(f'animals: {animals}')
+```
+
+**Output**
+
+ Enter an animal: lynx
+ Enter an animal: ocelot
+ Enter an animal: jaguar
+
+ animals: ['lynx', 'ocelot', 'puma']
+
+### **4.2**
+
+Loop through the user's list and with iteration, print both the item and all the letters in the item
+
+**Solution**
+
+```python
+# empty list
+animals = []
+
+# ask the user for three animals
+for i in range(3):
+ # ask the user for an animal
+ animal = input("Enter an animal: ")
+ # add it to the list
+ animals.append(animal)
+
+# loop through the animals
+for animal in animals:
+ # print the current animal name
+ print(animal)
+
+# loop through the letters in the animal name
+for letter in animal:
+ # print the current letter
+ print(letter)
+```
+
+**Output**
+
+ Enter an animal: lynx
+ Enter an animal: ocelot
+ Enter an animal: puma
+
+ lynx
+ l
+ y
+ n
+ x
+ ocelot
+ o
+ c
+ e
+ l
+ o
+ t
+ puma
+ p
+ u
+ m
+ a
+
+### **4.3**
+
+**Solution**
+
+```python
+# empty list
+animals = []
+
+# ask the user for three animals
+for i in range(3):
+ # ask the user for an animal
+ animal = input("Enter an animal: ")
+ # add it to the list
+ animals.append(animal)
+
+# empty list
+letters_used = []
+
+# loop through the animals
+for animal in animals:
+
+ # loop through the letters in the animal name
+ for letter in animal:
+
+ # if the letter isn't in the characters list,
+ if letter not in letters_used:
+ # add it
+ letters_used.append(letter)
+
+# display result
+print(f'letters used: {letters_used}')
+```
+
+**Output**
+
+ Enter an animal: lynx
+ Enter an animal: ocelot
+ Enter an animal: puma
+
+ Letters used:
+ ['l', 'y', 'n', 'x', 'o', 'c', 'e', 't', 'p', 'u', 'm', 'a']
+
+Keep in mind that is is just one potential solution
+
+## [< Exercise 4](../exercise_4.md)
+
+---
+
+### [<< Back to Unit 4 Practice](/practice/unit_4/)
diff --git a/practice/unit_4/solutions/exercise_5_pseudocode.md b/practice/unit_4/solutions/exercise_5_pseudocode.md
new file mode 100644
index 0000000..042e205
--- /dev/null
+++ b/practice/unit_4/solutions/exercise_5_pseudocode.md
@@ -0,0 +1,27 @@
+# Unit 4 Practice Solutions
+
+## **Exercise 5 - More Number Lists**
+
+### Pseudocode
+
+ loop: i = 0 -> (length of list - 1)
+ set 'swap' variable to False
+
+ loop: j = 0 -> (length of list - 1)
+ if list[j] is greater than list[j+1]
+ place list[j] in a 'bubble' variable
+
+ put list[j] at list[j+1]
+
+ put bubble at list[j+1]
+
+ since a swap occured this loop,
+ set swap to True
+
+ if no swap occured, break the outer loop
+
+### Exercise 5 [solution](./exercise_5_solution.md)
+
+---
+
+## [< Exercise 5](../exercise_5.md)
diff --git a/practice/unit_4/solutions/exercise_5_solution.md b/practice/unit_4/solutions/exercise_5_solution.md
new file mode 100644
index 0000000..ed88856
--- /dev/null
+++ b/practice/unit_4/solutions/exercise_5_solution.md
@@ -0,0 +1,140 @@
+# Unit 4 Practice Solutions
+
+## **Exercise 5 - More Number Lists**
+
+Use a loop and `random.randint()` to generate a list of ten `random_numbers` between 1 and 100.
+
+### **5.1**
+
+Count the even numbers
+
+**Solution**
+
+```python
+import random
+
+# generate 10 random numbers between 1 and 100
+numbers = []
+for i in range(10):
+ numbers.append(random.randint(1,100))
+
+# count the even numbers in the list
+# create empty list for evens
+evens = []
+
+# loop through the numbers
+for number in numbers:
+ # check if the number is even
+ if number % 2 == 0:
+ # add it to the evens list
+ evens.append(number)
+
+# calculate the number of evens
+evens_count = len(evens)
+
+# display result
+result = f'''Numbers: {numbers}
+There are {evens_count} evens: {evens}'''
+
+print(result)
+```
+
+**Output**
+
+ Numbers: [64, 3, 55, 94, 40, 56, 40, 69, 54, 3]
+
+ There are 6 evens: [64, 94, 40, 56, 40, 54]
+
+### **5.2**
+
+Reverse the list using a loop and without any methods or built-in functions
+
+**Solution**
+
+```python
+import random
+
+# generate 10 random numbers between 1 and 100
+numbers = []
+for i in range(10):
+ numbers.append(random.randint(1,100))
+
+# calculate the length of the numbers list
+numbers_length = len(numbers)
+
+# blank list for reverse
+numbers_reversed = []
+# loop backwards over one less than the length
+for index in range(numbers_length - 1, -1, -1):
+ # get the current number
+ number = numbers[index]
+
+ # add it to the reversed list
+ numbers_reversed.append(number)
+
+# display result
+result = f'''numbers: {numbers}
+reversed: {numbers_reversed}'''
+
+print(result)
+```
+
+**Output**
+
+ numbers: [62, 23, 56, 30, 55, 60, 31, 91, 93, 45]
+ reversed: [45, 93, 91, 31, 60, 55, 30, 56, 23, 62]
+
+### **5.3**
+
+Sort the list of numbers in ascending order without using methods or built-in functions.
+
+**Solution**
+
+```python
+numbers = [62, 23, 56, 30, 55, 60, 31, 91, 93, 45]
+
+# print before sorting
+print(f'numbers: {numbers}')
+
+
+# loop: i = 0 -> (length of list - 1)
+for i in range(len(numbers) - 1):
+ # set 'swap' variable to False
+ swap = False
+
+ # loop: j = 0 -> (length of list - 1)
+ for j in range(len(numbers) - 1):
+
+ #if list[j] is less than list[j+1]
+ if numbers[j] > numbers[j+1]:
+ #place list[j] in a 'bubble' variable
+ bubble = numbers[j]
+ # put list[j+1] at list[j]
+ numbers[j] = numbers[j+1]
+ # put bubble at list[j+1]
+ numbers[j+1] = bubble
+
+ # since a swap occured this loop,
+ # set swap to True
+ swap = True
+
+ # if no swap occured, break the outer loop
+ if not swap:
+ break
+
+# print after sorting
+print(f'sorted: {numbers}')
+```
+
+**Output**
+
+ numbers: [62, 23, 56, 30, 55, 60, 31, 91, 93, 45]
+ sorted: [23, 30, 31, 45, 55, 56, 60, 62, 91, 93]
+
+Keep in mind that is is just one potential solution
+
+## [< Exercise 5](../exercise_5.md)
+
+---
+
+### [<< Back to Unit 4 Practice](/practice/unit_4/)
diff --git a/practice/unit_5/README.md b/practice/unit_5/README.md
new file mode 100644
index 0000000..c8c72c7
--- /dev/null
+++ b/practice/unit_5/README.md
@@ -0,0 +1,9 @@
+# Unit 5 Practice
+
+| Exercise | Concepts | Solution |
+| -------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------- |
+| [01 - Count Sheep](exercise_1.md) |
| [05 - First Non-consecutive Number](./solutions/exercise_5_solution.md) |
diff --git a/practice/unit_5/exercise_1.md b/practice/unit_5/exercise_1.md
new file mode 100644
index 0000000..98135d2
--- /dev/null
+++ b/practice/unit_5/exercise_1.md
@@ -0,0 +1,37 @@
+# Unit 5 Practice
+
+## **Exercise 1 - Count Sheep**
+
+It's past your bedtime! Let's count some sheep to lull you to sleep.
+
+### **1.1**
+
+- Generate a random number between 1 and 10 to represent the number of sheep needed to fall asleep.
+
+- Set a variable called `awake` to `True`
+
+- Using a `while` loop, count sheep until you fall asleep
+
+- Fall asleep by setting `awake` to `False`
+
+**Output**
+
+ 1 sheep - baa!
+ 2 sheep - baa!
+ 3 sheep - baa!
+ 4 sheep - baa!
+ 5 sheep - baa!
+ 6 sheep - baa!
+ 7 sheep - baa!
+ 8 sheep - baa!
+ 9 sheep - baa!
+
+ ...zZzZzZzZ...
+
+### Exercise 1 [solution](./solutions/exercise_1_solution.md)
+
+---
+
+## [Exercise 2 >](exercise_2.md)
+
+### [<< Back to Unit 5 Practice](/practice/unit_5/)
diff --git a/practice/unit_5/exercise_2.md b/practice/unit_5/exercise_2.md
new file mode 100644
index 0000000..5cefd0d
--- /dev/null
+++ b/practice/unit_5/exercise_2.md
@@ -0,0 +1,129 @@
+# Unit 5 Practice
+
+## **Exercise 2 - Fizz Buzz**
+
+This is a classic question in the coding industry to test one's fundamentals.
+
+### **1.1**
+
+Use a loop to create a list of `numbers` from 1 to 100.
+
+Loop through the list.
+
+If a number is a **multiple of 3**, print `Fizz`.
+
+If a number is a **multiple of 5**,
+print `Buzz`.
+
+If a number is a **multiple of 3** **_and_** a **multiple of 5**, print `FizzBuzz`
+
+**Output**
+
+ 1: 1
+ 2: 2
+ 3: Fizz
+ 4: 4
+ 5: Buzz
+ 6: Fizz
+ 7: 7
+ 8: 8
+ 9: Fizz
+ 10: Buzz
+ 11: 11
+ 12: Fizz
+ 13: 13
+ 14: 14
+ 15: FizzBuzz
+ 16: 16
+ 17: 17
+ 18: Fizz
+ 19: 19
+ 20: Buzz
+ 21: Fizz
+ 22: 22
+ 23: 23
+ 24: Fizz
+ 25: Buzz
+ 26: 26
+ 27: Fizz
+ 28: 28
+ 29: 29
+ 30: FizzBuzz
+ 31: 31
+ 32: 32
+ 33: Fizz
+ 34: 34
+ 35: Buzz
+ 36: Fizz
+ 37: 37
+ 38: 38
+ 39: Fizz
+ 40: Buzz
+ 41: 41
+ 42: Fizz
+ 43: 43
+ 44: 44
+ 45: FizzBuzz
+ 46: 46
+ 47: 47
+ 48: Fizz
+ 49: 49
+ 50: Buzz
+ 51: Fizz
+ 52: 52
+ 53: 53
+ 54: Fizz
+ 55: Buzz
+ 56: 56
+ 57: Fizz
+ 58: 58
+ 59: 59
+ 60: FizzBuzz
+ 61: 61
+ 62: 62
+ 63: Fizz
+ 64: 64
+ 65: Buzz
+ 66: Fizz
+ 67: 67
+ 68: 68
+ 69: Fizz
+ 70: Buzz
+ 71: 71
+ 72: Fizz
+ 73: 73
+ 74: 74
+ 75: FizzBuzz
+ 76: 76
+ 77: 77
+ 78: Fizz
+ 79: 79
+ 80: Buzz
+ 81: Fizz
+ 82: 82
+ 83: 83
+ 84: Fizz
+ 85: Buzz
+ 86: 86
+ 87: Fizz
+ 88: 88
+ 89: 89
+ 90: FizzBuzz
+ 91: 91
+ 92: 92
+ 93: Fizz
+ 94: 94
+ 95: Buzz
+ 96: Fizz
+ 97: 97
+ 98: 98
+ 99: Fizz
+ 100: Buzz
+
+### Exercise 2 [solution](./solutions/exercise_2_solution.md)
+
+---
+
+## [< Exercise 1](exercise_1.md)| [Exercise 3 >](exercise_3.md)
+
+### [<< Back to Unit 5 Practice](/practice/unit_5/)
diff --git a/practice/unit_5/exercise_3.md b/practice/unit_5/exercise_3.md
new file mode 100644
index 0000000..5e4659d
--- /dev/null
+++ b/practice/unit_5/exercise_3.md
@@ -0,0 +1,74 @@
+# Unit 5 Practice
+
+## **Exercise 3 - Guess the Number**
+
+### **1.1**
+
+Select a number between 1 and 10 to act as a `secret`.
+
+Have the user attempt to `guess` the number.
+
+If they `guess` then `secret`, tell them they win!
+
+If they `guess` a higher number than the `secret`, tell them they guessed too high.
+
+If they `guess` a lower number than the `secret`, tell them they guessed too low.
+
+If they guess a number that isn't between 1 and 10, tell them they were out of bounds.
+
+**Output**
+
+ Guess a number 1-10: 3
+
+ Your guess of 3 was too low!!
+ The secret was: 5
+ ---
+
+ Guess a number 1-10: 7
+
+ Your guess of 7 was too high!!
+ The secret was: 5
+ ---
+
+ Guess a number 1-10: 5
+
+ You guessed the secret!
+ The secret was: 5
+
+### **1.2**
+
+Generate a random integer between 1 and 10 to act as a `secret` number.
+
+Using a `while` loop, have the game repeat until the user guesses the `secret`.
+
+**Output**
+
+ Guess a number 1-10: 6
+ Your guess of 6 was too low!!
+
+ Guess a number 1-10: 9
+ Your guess of 9 was too high!!
+
+ Guess a number 1-10: -99
+ Invalid guess: -99.
+
+ Guess a number 1-10: 7
+ You guessed the secret: 7!
+
+### **1.3**
+
+Allow the user three guesses. If they don't guess the number in three guesses, game over!
+
+Display the number of remaining guesses with each loop.
+
+Invalid guesses shouldn't affect the number of remaining guesses.
+
+**Output**
+
+### Exercise 3 [solution](./solutions/exercise_3_solution.md)
+
+---
+
+## [< Exercise 2](exercise_2.md) | [Exercise 4 >](exercise_4.md)
+
+### [<< Back to Unit 5 Practice](/practice/unit_5/)
diff --git a/practice/unit_5/exercise_4.md b/practice/unit_5/exercise_4.md
new file mode 100644
index 0000000..b56455d
--- /dev/null
+++ b/practice/unit_5/exercise_4.md
@@ -0,0 +1,45 @@
+# Unit 5 Practice
+
+## **Exercise 4 - Fibonacci / Tribonacci**
+
+The Fibonacci sequence is a series of numbers where **each consecutive number is the sum of the previous two**.
+
+### **1.1**
+
+Write a loop that adds the first 10 values of the Fibonacci sequence to a list.
+
+Display the list.
+
+Hint: You can create your list using the first two numbers in the sequence `[0,1]`
+
+**Output**
+
+ First ten Fibonacci numbers:
+ [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
+
+### **1.2**
+
+Tri-bonacci! This is as it sounds. Create a new list of Tri-bonacci values where each consecutive number is the sum of the previous **three** numbers
+
+Hint: You can create your list using the first three numbers in the sequence `[0,1,1]`
+
+**Output**
+
+ First ten Tribonacci numbers:
+ [0, 1, 1, 2, 4, 7, 13, 24, 44, 81]
+
+### **1.3**
+
+Write both the Fibonacci and Tribonacci sequence loops **without** providing the first two or three starting values.
+
+### **1.4**
+
+Allow the user to enter the number of elements to calculate in both the Fibonacci and Tribonacci loops.
+
+### Exercise 4 [solution](./solutions/exercise_4_solution.md)
+
+---
+
+## [< Exercise 3](exercise_3.md) | [Exercise 5 >](exercise_5.md)
+
+### [<< Back to Unit 5 Practice](/practice/unit_5/)
diff --git a/practice/unit_5/exercise_5.md b/practice/unit_5/exercise_5.md
new file mode 100644
index 0000000..8b05fb4
--- /dev/null
+++ b/practice/unit_5/exercise_5.md
@@ -0,0 +1,13 @@
+# Unit 5 Practice
+
+## **Exercise 5 - First Non-Consecutive Number**
+
+Coming soon...
+
+### Exercise 5 [solution](./solutions/exercise_5_solution.md)
+
+---
+
+## [< Exercise 4](exercise_4.md)
+
+### [<< Back to Unit 5 Practice](/practice/unit_5/)
diff --git a/practice/unit_5/solutions/exercise_1_solution.md b/practice/unit_5/solutions/exercise_1_solution.md
new file mode 100644
index 0000000..ccd5aca
--- /dev/null
+++ b/practice/unit_5/solutions/exercise_1_solution.md
@@ -0,0 +1,54 @@
+# Unit 5 Practice Solutions
+
+## Exercise 1 - Count Sheep
+
+### **1.1**
+
+**Solution**
+
+```python
+import random
+
+# Generate a random number between 1 and 10 to represent the number of sheep needed to fall asleep.
+sheep_to_sleep = random.randint(1,10)
+
+# you are still awake
+awake = True
+
+# count sheep until you fall asleep
+
+# counter variable
+sheep = 0
+
+# count sheep
+while awake: # same as awake == True
+ print(f'{sheep + 1} sheep - baa!')
+
+ # add one sheep_to_sleep
+ sheep += 1
+
+ # fall asleep
+ if sheep == sheep_to_sleep:
+ awake = False
+
+# sweet dreams
+print('\n...zZzZzZzZ...')
+```
+
+**Output**
+
+ 1 sheep - baa!
+ 2 sheep - baa!
+ 3 sheep - baa!
+ 4 sheep - baa!
+ 5 sheep - baa!
+ 6 sheep - baa!
+ 7 sheep - baa!
+ 8 sheep - baa!
+ 9 sheep - baa!
+
+ ...zZzZzZzZ...
+
+## [< Exercise 1](../exercise_1.md) | [Exercise 2 >](../exercise_2.md)
+
+### [<< Back to Unit 5 Practice](/practice/unit_5/)
diff --git a/practice/unit_5/solutions/exercise_2_solution.md b/practice/unit_5/solutions/exercise_2_solution.md
new file mode 100644
index 0000000..099413a
--- /dev/null
+++ b/practice/unit_5/solutions/exercise_2_solution.md
@@ -0,0 +1,144 @@
+# Unit 5 Practice Solutions
+
+## Exercise 2 - FizzBuzz
+
+**Solution**
+
+```python
+# loop 100 times
+j = 0
+while j < 100:
+
+ # if multiple of 3 and 5
+
+ # same as line 7:
+ # if j % 3 == 0 and j % 5 == 0:
+
+ if j % 15 == 0:
+ output = 'FizzBuzz'
+
+ # if multiple of 3
+ elif j % 3 == 0:
+ output = 'Fizz'
+
+ # if multiple of 5
+ elif j % 5 == 0:
+ output = 'Buzz'
+
+ # if not a multiple of 3 or 5
+ else:
+ output = j
+
+ # display the result each loop
+ print(output)
+
+ # count up
+ j += 1
+```
+
+**Output**
+
+ 1: 1
+ 2: 2
+ 3: Fizz
+ 4: 4
+ 5: Buzz
+ 6: Fizz
+ 7: 7
+ 8: 8
+ 9: Fizz
+ 10: Buzz
+ 11: 11
+ 12: Fizz
+ 13: 13
+ 14: 14
+ 15: FizzBuzz
+ 16: 16
+ 17: 17
+ 18: Fizz
+ 19: 19
+ 20: Buzz
+ 21: Fizz
+ 22: 22
+ 23: 23
+ 24: Fizz
+ 25: Buzz
+ 26: 26
+ 27: Fizz
+ 28: 28
+ 29: 29
+ 30: FizzBuzz
+ 31: 31
+ 32: 32
+ 33: Fizz
+ 34: 34
+ 35: Buzz
+ 36: Fizz
+ 37: 37
+ 38: 38
+ 39: Fizz
+ 40: Buzz
+ 41: 41
+ 42: Fizz
+ 43: 43
+ 44: 44
+ 45: FizzBuzz
+ 46: 46
+ 47: 47
+ 48: Fizz
+ 49: 49
+ 50: Buzz
+ 51: Fizz
+ 52: 52
+ 53: 53
+ 54: Fizz
+ 55: Buzz
+ 56: 56
+ 57: Fizz
+ 58: 58
+ 59: 59
+ 60: FizzBuzz
+ 61: 61
+ 62: 62
+ 63: Fizz
+ 64: 64
+ 65: Buzz
+ 66: Fizz
+ 67: 67
+ 68: 68
+ 69: Fizz
+ 70: Buzz
+ 71: 71
+ 72: Fizz
+ 73: 73
+ 74: 74
+ 75: FizzBuzz
+ 76: 76
+ 77: 77
+ 78: Fizz
+ 79: 79
+ 80: Buzz
+ 81: Fizz
+ 82: 82
+ 83: 83
+ 84: Fizz
+ 85: Buzz
+ 86: 86
+ 87: Fizz
+ 88: 88
+ 89: 89
+ 90: FizzBuzz
+ 91: 91
+ 92: 92
+ 93: Fizz
+ 94: 94
+ 95: Buzz
+ 96: Fizz
+ 97: 97
+ 98: 98
+ 99: Fizz
+ 100: Buzz
+
+## [< Exercise 2](../exercise_1.md) | [Exercise 3 >](../exercise_3.md)
+
+### [<< Back to Unit 5 Practice](/practice/unit_5/)
diff --git a/practice/unit_5/solutions/exercise_3_solution.md b/practice/unit_5/solutions/exercise_3_solution.md
new file mode 100644
index 0000000..0666ee2
--- /dev/null
+++ b/practice/unit_5/solutions/exercise_3_solution.md
@@ -0,0 +1,203 @@
+# Unit 5 Practice Solutions
+
+## Exercise 3 - Guess the Number
+
+### **1.1**
+
+**Solution**
+
+```python
+import random
+
+# secret number
+secret = 5
+
+# ask the user to guess
+guess = input('Guess a number 1-10: ')
+
+# convert guess to integer for comparisons
+guess = int(guess)
+
+if guess < 1 or guess > 10:
+ message = f'Invalid guess: {guess}.'
+
+# if they guess correctly
+elif guess == secret:
+ message = f'You guessed the secret!'
+
+# if they guess too high
+elif guess > secret:
+ message = f'Your guess of {guess} was too high!!'
+
+# if they guess too low
+elif guess < secret:
+ message = f'Your guess of {guess} was too low!!'
+
+# display result with after a new line
+print('\n' + message)
+print(f'The secret was: {secret}')
+```
+
+**Output**
+
+ Guess a number 1-10: 3
+
+ Your guess of 3 was too low!!
+ The secret was: 5
+ ---
+
+ Guess a number 1-10: 7
+
+ Your guess of 7 was too high!!
+ The secret was: 5
+ ---
+
+ Guess a number 1-10: 5
+
+ You guessed the secret!
+ The secret was: 5
+ ---
+
+ Guess a number 1-10: 400
+ Invalid guess: 400
+
+### **1.2**
+
+**Solution**
+
+```python
+import random
+
+# random secret number
+secret = random.randint(1,10)
+
+# loop until the user guesses the secret
+while True:
+ # ask the user to guess
+ guess = input('\nGuess a number 1-10: ')
+
+ # convert guess to integer for comparisons
+ guess = int(guess)
+
+ if guess < 1 or guess > 10:
+ message = f'Invalid guess: {guess}.'
+ print(message)
+ # go to the top of the loop
+ continue
+
+ # if they guess correctly
+ elif guess == secret:
+ message = f'You guessed the secret: {secret}!'
+
+ # display the winning message
+ print(message)
+
+ # end the loop
+ break
+
+ # if they guess too high
+ elif guess > secret:
+ message = f'Your guess of {guess} was too high!!'
+
+ # if they guess too low
+ elif guess < secret:
+ message = f'Your guess of {guess} was too low!!'
+
+ print(message)
+```
+
+**Output**
+
+ Guess a number 1-10: 3
+ Your guess of 3 was too low!!
+
+ Guess a number 1-10: 7
+ Your guess of 7 was too high!!
+
+ Guess a number 1-10: 99
+ Invalid guess: 99.
+
+ Guess a number 1-10: 5
+ You guessed the secret: 5!
+
+### **1.3**
+
+**Solution**
+
+```python
+import random
+
+# random secret number
+secret = random.randint(1,10)
+
+# number of guesses
+guesses_remaining = 3
+
+# loop until no guesses remain
+while guesses_remaining > 0:
+ # display the remaining guesses
+ print(f'You have {guesses_remaining} guesses remaining.')
+
+ # ask the user to guess
+ guess = input('\nGuess a number 1-10: ')
+
+ # convert guess to integer for comparisons
+ guess = int(guess)
+
+ if guess < 1 or guess > 10:
+ message = f'Invalid guess: {guess}.'
+ print(message)
+ # go to the top of the loop
+ continue
+
+ # if they guess correctly
+ elif guess == secret:
+ message = f'You guessed the secret: {secret}!'
+
+ # display the winning message
+ print(message)
+
+ # end the loop
+ break
+
+ # if they guess too high
+ elif guess > secret:
+ message = f'Your guess of {guess} was too high!!'
+
+ # if they guess too low
+ elif guess < secret:
+ message = f'Your guess of {guess} was too low!!'
+
+ # if the guess was too high or low,
+ # remove a guess
+ guesses_remaining -= 1
+ print(message)
+
+# when the user runs out of guesses
+else:
+ print(f'Sorry! You ran out of guesses. The secret was {secret}.')
+```
+
+**Output**
+
+ You have 3 guesses remaining.
+
+ Guess a number 1-10: 100
+ Invalid guess: 100.
+ You have 3 guesses remaining.
+
+ Guess a number 1-10: 10
+ Your guess of 10 was too high!!
+ You have 2 guesses remaining.
+
+ Guess a number 1-10: 6
+ Your guess of 6 was too low!!
+ You have 1 guesses remaining.
+
+ Guess a number 1-10: 8
+ Your guess of 8 was too low!!
+ Sorry! You ran out of guesses. The secret was 9.
+
+## [< Exercise 2](../exercise_2.md) | [Exercise 4 >](../exercise_4.md)
+
+### [<< Back to Unit 5 Practice](/practice/unit_5/)
diff --git a/practice/unit_5/solutions/exercise_4_solution.md b/practice/unit_5/solutions/exercise_4_solution.md
new file mode 100644
index 0000000..9322e22
--- /dev/null
+++ b/practice/unit_5/solutions/exercise_4_solution.md
@@ -0,0 +1,177 @@
+# Unit 5 Practice Solutions
+
+## Exercise 4 - Fibonacci / Tribonacci
+
+### **1.1**
+
+**Solution**
+
+```python
+# starting values
+fibonacci = [0,1]
+
+i = 0 # index counter
+
+# while fibonacci list has less than ten elements
+while len(fibonacci) < 10:
+
+ # get the two previous numbers
+ prev_1 = fibonacci[i]
+ prev_2 = fibonacci[i+1]
+
+ # sum of the two previous numbers
+ n = prev_1 + prev_2
+
+ # add n to the list
+ fibonacci.append(n)
+
+ # increase i
+ i += 1
+
+# display the result
+output = f'First ten Fibonacci numbers:\n{fibonacci}'
+print(output)
+```
+
+**Output**
+
+ First ten Fibonacci numbers:
+ [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
+
+### **1.2**
+
+**Solution**
+
+```python
+# starting values
+tribonacci = [0,1,1]
+
+i = 0 # index counter
+
+# while fibonacci has less than ten elements
+while len(tribonacci) < 10:
+
+ # get the three previous numbers
+ prev_1 = tribonacci[i]
+ prev_2 = tribonacci[i+1]
+ prev_3 = tribonacci[i+2]
+
+ # sum of the three previous numbers
+ n = prev_1 + prev_2 + prev_3
+
+ # add n to the list
+ tribonacci.append(n)
+
+ # increase i
+ i += 1
+
+# display the result
+output = f'First ten Tribonacci numbers:\n{tribonacci}'
+print(output)
+```
+
+**Output**
+
+ First ten Tribonacci numbers:
+ [0, 1, 1, 2, 4, 7, 13, 24, 44, 81]
+
+### **1.3**
+
+**Solution - Fibonacci**
+
+```python
+# no starting values
+fibonacci = []
+
+i = 0 # index counter
+
+# while fibonacci has less than ten elements
+while len(fibonacci) < 10:
+
+ # get the first two elements
+ if len(fibonacci) < 2:
+
+ # len(fibonacci) with be either 0 or 1,
+ # so the first two elements become [0,1]
+ n = len(fibonacci)
+
+ # calculate all other elements
+ else:
+ # get the twp previous numbers
+ prev_1 = fibonacci[i]
+ prev_2 = fibonacci[i+1]
+
+ # add the sum of the three previous numbers to the list
+ n = prev_1 + prev_2
+
+ # increase i
+ i += 1
+
+ # add n to the list
+ fibonacci.append(n)
+
+# display the result
+output = f'First ten Fibonacci numbers:\n{fibonacci}'
+print(output)
+```
+
+**Solution - Tribonacci**
+
+```python
+# no starting values
+tribonacci = []
+
+i = 0 # index counter
+
+# while tribonacci has less than ten elements
+while len(tribonacci) < 10:
+ # get the first two elements
+ if len(tribonacci) < 2:
+ # the first two elements become [0,1]
+ # because the length is less than 2 (0 or 1)
+ n = len(tribonacci)
+
+ # get the third element
+ elif len(tribonacci) == 2:
+ n=1
+
+ # calculate all other elements
+ else:
+ # get the three previous numbers
+ prev_1 = tribonacci[i]
+ prev_2 = tribonacci[i+1]
+ prev_3 = tribonacci[i+2]
+
+ # sum of the three previous numbers
+ n = prev_1 + prev_2 + prev_3
+
+ # increase i
+ i += 1
+
+ # add n to the list
+ tribonacci.append(n)
+
+# display the result
+output = f'First ten Tribonacci numbers:\n{tribonacci}'
+print(output)
+```
+
+### **1.4**
+
+```python
+# ask the user for the number of elements
+limit = input("Enter the number of Fibonacci numbers you'd like to generate")
+
+# convert the input to an integer
+limit = int(limit)
+
+# use the input value to set the loop
+while len(fibonacci) < limit:
+ # calculate Fibonacci numbers as above
+ # ...
+ # ...
+```
+
+## [< Exercise 4](../exercise_4.md) | [Exercise 5 >](../exercise_5.md)
+
+### [<< Back to Unit 5 Practice](/practice/unit_5/)
diff --git a/practice/unit_5/solutions/exercise_5_solution.md b/practice/unit_5/solutions/exercise_5_solution.md
new file mode 100644
index 0000000..12aa2a2
--- /dev/null
+++ b/practice/unit_5/solutions/exercise_5_solution.md
@@ -0,0 +1,11 @@
+# Unit 5 Practice Solutions
+
+## Exercise 5 - First Non-Consecutive Number
+
+**Solution**
+
+Coming soon...
+
+## [< Exercise 4](../exercise_4.md) | [Exercise 5 >](../exercise_5.md)
+
+### [<< Back to Unit 5 Practice](/practice/unit_5/)
diff --git a/resources/example_lessons/unit_1/unit_1_lesson.py b/resources/example_lessons/unit_1/unit_1_lesson.py
new file mode 100644
index 0000000..c26481c
--- /dev/null
+++ b/resources/example_lessons/unit_1/unit_1_lesson.py
@@ -0,0 +1,102 @@
+# Welcome to PDX Code Guild!
+# single-line comments use pound signs #
+# everything to the right of the pound sign will be a comment
+
+'''
+Multi-line
+comment with
+single quotes
+'''
+
+"""
+Multi-line
+comment with
+double quotes
+"""
+
+'''
+Comments
+
+- organize code
+- explain code
+- exclude lines of code for testing
+'''
+
+# ------------------------------------------------------------------------------- #
+
+# a "function" is a named piece of code that performs a specific task
+# Python comes with many built-in functions
+# functions must be executed using parentheses after their name ()
+
+# print(data) - a built-in function to display the 'data' in the terminal
+
+# express an opinion about spam
+# print("I don't like spam!") # I don't like spam!
+
+# --------------------------------------------------------------------------------------- #
+
+# Datatype: string (str)
+
+# strings are sequences of textual characters surrounded by quotes
+
+'cat'
+"dog"
+'01237461123'
+"3.141592654"
+'' # blank string
+"" # blank string
+
+# -------------------------------------------------------------------------------------- #
+
+# concatenation - adding strings together to form a single string
+
+# print('pdx' + 'code') # pdxcode
+
+# print three words with space between
+# print('pdx' + ' ' + 'code' + ' ' + 'guild') # pdx code guild
+
+# build a word one letter at a time
+# print('c' + 'a' + 't') # cat
+
+# print('4' + '4') # 44 - both 4s are strings
+# print(4 + 4) # 8 - both 4s are integers
+# print('4' + 4) # TypeError: can only concatenate str (not "int") to str
+
+# ---------------------------------------------------------------------------------- #
+
+# a "method" is a function (needs parentheses to be executed)
+# methods only manipulate the object to which they belong
+
+# an object's methods are accessed using a dot after the object
+
+# .upper() - return an uppercase version of the string
+# print('abcd'.upper()) # ABCD
+# print('wxyz'.upper()) # WXYZ
+
+# .title() - return a lowercased string with the first letter of each word capitalized
+# print('pOrTlAnD, oReGoN'.title()) # Portland, Oregon
+
+# -------------------------------------------------------------------------------------- #
+
+# Escape Characters
+
+# denoted with a backslash \ before the character
+# allow characters to be placed within a string that would normally cause errors
+# allow formatting of strings
+# other uses...
+
+# Python uses quotation marks to begin and end strings
+# "Hello "world"" # Error! Double quotes cancel each other
+# 'Hello 'world'' # Error! Single quotes cancel each other
+
+# Solution 1: mismatmached sets of quotes (fix quotes when presenting)
+# print("Hello "world"") # hello "world"
+# print('Hello 'world'') # hello 'world'
+
+# Solution 2: escape characters (add escape characters when presenting)
+# print("Hello "world"") # Hello "world" - \" escape character
+# print('Hello 'world'') # Hello 'world' - \' escape characters
+
+# escape characters can also format strings (add escape characters when presenting)
+# print("ABC") # \n - new line character
+# print("ABC") # \t - horizontal tab character
\ No newline at end of file
diff --git a/resources/example_lessons/unit_2/unit_1_review.py b/resources/example_lessons/unit_2/unit_1_review.py
new file mode 100644
index 0000000..0cf071d
--- /dev/null
+++ b/resources/example_lessons/unit_2/unit_1_review.py
@@ -0,0 +1,132 @@
+'''
+Programming 101
+Unit 1 Review
+'''
+
+'''
+Multi-line comment
+with single quotes
+'''
+
+"""
+Multi-line comment
+with double quotes
+"""
+
+# single line comments use a pound sign #
+# everything to the right of the pound sign is a comment
+
+'''
+Comments
+
+- organize code
+- explain code
+- exclude lines of code for testing
+'''
+
+# ------------------------------------------------------------------------------------- #
+
+# a function is a named piece of code that performs a specific task
+
+# print(data) - display the data in the terminal
+
+# functions need parentheses after their name to be executed
+# print 'hello world' # SyntaxError: Missing parentheses in call to 'print'. Did you mean print('hello world')?
+
+# print('hello')
+# print() # print blank line
+# print('world')
+
+# print() can accept multiple, comma-separated items
+# they will print with a space between each
+# print('cat', 'dog', 'elephant') # cat dog elephant
+# print(100, 'dog', 1.5) # 100 dog 1.5
+
+# label some data
+# print('pi:', 3.141592654) # pi: 3.141592654
+
+# -------------------------------------------------------------------------------------------- #
+
+# Datatype: string (str)
+
+# strings are sequences of textual characters surrounded by quotes
+
+"cat"
+'dog'
+'iuy62t3ghb2k3jh9862389(*^(*^'
+"... an entire book ... "
+
+'' # empty string
+"" # empty string
+
+' ' # symbol of a space
+" " # symbol of a space
+
+
+# ---------------------------------------------------------------------------------------- #
+
+# type(object) - return the datatype of the object
+# everything in Python is an object
+
+# print(type('')) #
+# print(type('3.14')) #
+print(type(3)) #
+
+# ------------------------------------------------------------------------------------------ #
+
+# print a multi-line string
+
+'''
+print("""
+Multi-line comments
+ are also
+ multi-line strings
+""")
+
+'''
+
+# ------------------------------------------------------------------------------------------- #
+
+# concatenation - adding strings together to form a single string
+
+# print('pdx' + 'code' + 'guild') # pdxcodeguild
+# print('pdx' + ' ' + 'code' + ' ' + 'guild') # pdx code guild
+
+# --------------------------------------------------------------------------------------------- #
+
+# a "method" is a function that manipulates only the object to which it belongs
+# an object's methods are accessed with a dot . after the object
+
+# .upper() - return an uppercase version of the string
+# print('abcd'.upper()) # ABCD
+
+# .replace(old_str, new_str) - replace all occurrences of the old_str with the new_str
+# print('hello'.replace('h', 'j'))
+
+# methods can be chained
+# each subsequent method will operate on the return value of the previous
+
+# call .upper() on the string returned by .replace()
+# print('hello'.replace('h', 'j').upper()) # JELLO
+
+# -------------------------------------------------------------------------------------------- #
+
+# Escape Characters
+
+# denoted with a backslash \ before the character
+# allow characters to be placed within a string that would normally cause errors
+# allow formatting of strings
+# other uses...
+
+# Python uses quotation marks to begin and end strings
+# "Hello "world"" # Error! Double quotes cancel each other
+
+# Solution 1: use mismatched sets
+# print('Hello "world"') # Hello "world"
+
+# Solution 2: escape characters
+# print("Hello \"world\"") # Hello "world"
+
+# escape characters can also format strings
+# print("A\nB\nC") # \n - new line character
+# print("A\tB\tC") # \t - horizontal tab character
diff --git a/resources/example_lessons/unit_2/unit_1_review_template.py b/resources/example_lessons/unit_2/unit_1_review_template.py
new file mode 100644
index 0000000..669d12d
--- /dev/null
+++ b/resources/example_lessons/unit_2/unit_1_review_template.py
@@ -0,0 +1,87 @@
+'''
+Programming 101
+Unit 1 Review
+'''
+
+'''
+Comments
+
+- organize code
+- explain code
+- exclude lines of code for testing
+'''
+
+# ------------------------------------------------------------------------------------- #
+
+# a function is a named piece of code that performs a specific task
+
+# print(data) - display the data in the terminal
+
+# functions need parentheses after their name to be executed
+
+# hello
+# print blank line
+# world
+
+# print() can accept multiple, comma-separated items
+# they will print with a space between each
+
+# label some data
+
+# -------------------------------------------------------------------------------------------- #
+
+# Datatype: string (str)
+
+# strings are sequences of textual characters surrounded by quotes
+
+
+# ---------------------------------------------------------------------------------------- #
+
+# type(object) - return the datatype of the object
+# everything in Python is an object
+
+
+# ------------------------------------------------------------------------------------------ #
+
+# print a multi-line string
+
+
+# ------------------------------------------------------------------------------------------- #
+
+# concatenation - adding strings together to form a single string
+
+# --------------------------------------------------------------------------------------------- #
+
+# a "method" is a function that manipulates only the object to which it belongs
+# an object's methods are accessed with a dot . after the object
+
+# .upper() - return an uppercase version of the string
+
+# .replace(old_str, new_str) - replace all occurrences of the old_str with the new_str
+
+# methods can be chained
+# each subsequent method will operate on the return value of the previous
+
+# call .upper() on the string returned by .replace()
+
+# -------------------------------------------------------------------------------------------- #
+
+# Escape Characters
+
+# denoted with a backslash \ before the character
+# allow characters to be placed within a string that would normally cause errors
+# allow formatting of strings
+# other uses...
+
+# Python uses quotation marks to begin and end strings
+# "Hello "world"" # Error! Double quotes cancel each other
+
+# Solution 1: use mismatched sets
+# print("Hello "world"") # Hello "world"
+
+# Solution 2: escape characters
+# print("Hello "world"") # Hello "world"
+
+# escape characters can also format strings
+# print("ABC") # \n - new line character
+# print("ABC") # \t - horizontal tab character
diff --git a/resources/example_lessons/unit_2/unit_2_lesson.py b/resources/example_lessons/unit_2/unit_2_lesson.py
new file mode 100644
index 0000000..cfb4c22
--- /dev/null
+++ b/resources/example_lessons/unit_2/unit_2_lesson.py
@@ -0,0 +1,222 @@
+'''
+Programming 101
+Unit 2
+'''
+
+# ------------------------------------Variables---------------------------------------- #
+
+# EXPLAIN THATIF WE WANT TO PRINT THE COLOR 5 TIMES,
+# WE NEED TO CREATE 5 INDIVIDUAL STRINGS THE WAY WE'VE SEEN IT SO FAR
+print('purple') # purple
+print('purple') # purple
+print('purple') # purple
+print('purple') # purple
+print('purple') # purple
+
+# SHOW THAT IF WE CHANGE ONE, IT DOESN'T CHANGE ALL THE REST
+print('green') # green
+print('purple') # purple
+print('purple') # purple
+print('purple') # purple
+print('purple') # purple
+
+# THIS IS WHY WE USE VARIABLES
+color = 'purple'
+
+# NOW WE CAN PRINT THE color VARIABLE 5 TIMES TO REFER BACK TO THE SAME STRING
+print(color) # purple
+print(color) # purple
+print(color) # purple
+print(color) # purple
+print(color) # purple
+
+# CHANGE THE VALUE OF color AND SHOW THE OUTPUT AGAIN
+# ---------------------------------------------------------------------------- #
+
+'''
+Variables
+
+- are used to store data that the program will use later
+- can store objects of ANY datatype
+- BECOME the datatype of the object they store
+- can be given new values (be 'redefined')
+'''
+
+# = is the assignment operator
+# it assigns the value on the right to the variable on the left
+
+color = 'pink'
+# print(color) # pink
+
+# ------------------------------------------------------------------------------------- #
+
+# variable 'color' IS a string because it CONTAINS a string
+# print(type(color)) #
+
+# since 'color' contains a string, it can be used in string operations
+# print(color.upper()) # PINK
+# print(color) # pink
+
+# redefine the value within 'color'
+color = 'purple'
+# print(color) # purple
+
+# redefine the 'color' variable using the return value from .upper()
+color = color.upper()
+# print(color) # PURPLE
+
+# ------------------------------------------------------------------------------------- #
+
+first_name = 'Keegan'
+
+# concatenate the values within the variables
+output = 'My name is ' + first_name + ' and my favorite color is ' + color.lower() + '.'
+# print(output) # My name is Keegan and my favorite color is purple.
+
+# -------------------------------------------------------------------------------------- #
+
+'''
+Python Variable Names
+
+- must start with a letter or underscore
+- cannot start with number
+- can only contain alphanumeric characters and underscores (A-z, 0-9, and _)
+- are case sensitive (age, Age, AGE are 3 different variables)
+'''
+
+# user_name_1 = 'Athena' # valid variable name
+# 1u$ern@me = 'Hades' # invalid variable name
+
+# python_variable_and_function_names_use_snake_case
+# all lowercase words separated with underscores
+
+# variable names should aim to describe the data they contain
+phone_number = '7654352647' # good
+p = '8765678765' # bad
+
+# -------------------------------------------------------------------------------------------- #
+
+city = 'Portland'
+temp = 70 # integer - int
+
+# concatenation only works between strings
+# other datatypes will need to be "typecast" as strings using str()
+# str(object) - return a string representation of the object
+
+# message = 'Welcome to ' + city + '! The temp today was ' + str(temp) + ' degrees!'
+# print(message) # Welcome to Portland! The temp today was 70 degrees!
+
+'''
+f-string
+
+- 'f' stands for 'formatted'
+- begin with and 'f' before the opening quote
+- Python expressions (code) can be placed within the f-string using curly brackets {}
+- don't care about datatype
+'''
+
+message = f"Welcome to {city}! The temp today was {temp} degrees!"
+# print(message) # Welcome to Portland! The temp today was 70 degrees!
+
+# --------------------------------------------------------------------------------------- #
+
+# input() - allow the user to interact with the code from the terminal
+
+'''
+user_string = input('prompt message')
+
+- Print the 'prompt message' and wait for the user to hit Enter
+- Once the user hits Enter, anything they typed in the terminal will be returned from input()
+- The returned string can be stored in a variable such as 'user_string' above
+
+'''
+
+
+
+# color = input('Enter a color: ')
+# print(f"Favorite color: {color}")
+
+# ------------------------------------------------------------------------------------------------ #
+
+'''
+input() always returns a string
+
+In order to use input() for datatypes other than strings,
+the return value will need to be typecast
+
+Integer (int) - whole numbers
+Float (float) - decimal numbers
+
+Typecasting functions
+str(object) - return a string representation of the object, if possible
+int(object) - return a integer representation of the object, if possible
+float(object) - return a float representation of the object, if possible
+'''
+
+'''
+number = input('Please enter a number: ')
+
+print(number + number) # '99'
+print(number, type(number)) # 9
+
+
+# redefine the string number as a float
+number = float(number)
+
+print(number + number) # 18.0
+print(number, type(number)) # 9.0
+
+'''
+
+# ---------------------------------------------------------------------------------- #
+
+# Find the area of a rectangle with user-defined sides
+"""
+# have the user define the height and width of the rectangle
+height = input('Enter the height of the rectangle: ')
+width = input('Enter the width of the rectangle: ')
+
+# convert the height and width from strings to floats
+height = float(height)
+width = float(width)
+
+# calculate the area
+area = height * width # * is multiplication
+
+# display the result
+result = f'''
+Area of a Rectangle
+-------------------
+height ... {height}
+width .... {width}
+
+area ..... {area}'''
+
+print(result)
+
+"""
+
+# -------------------------------------------------------------------------------------------- #
+
+# arithmetic operators (math)
+
+x = 5
+y = 3
+
+# print(x + y) # addition +
+# print(x - y) # subtraction -
+
+# print(x * y) # multiplication *
+# print(x ** y) # exponentiation ** (x^y)
+
+# print(x / y) # 'regular' division / (results in a float)
+# print(x // y) # 'floor' division // (always rounds down to the nearest integer)
+
+# print(x % y) # modulus % (remainder after division)
+
+# ------------------------------------------------------------------------------------------ #
+
+# // and % are compliments
+# print(75 / 10) # 7.5
+# print(75 // 10) # 7
+# print(75 % 10) # 5
diff --git a/resources/example_lessons/unit_3/unit_2_review.py b/resources/example_lessons/unit_3/unit_2_review.py
new file mode 100644
index 0000000..be54cbc
--- /dev/null
+++ b/resources/example_lessons/unit_3/unit_2_review.py
@@ -0,0 +1,167 @@
+'''
+Programming 101
+Unit 2 Review
+'''
+
+# variables are named storage spaces
+
+# assign a value to a variable using =
+
+fruit = 'apple' # assign the string 'apple' to the variable 'fruit'
+# print(fruit) # apple
+
+
+# --------------------------------------------------------------------------------- #
+
+# variables become the datatype they store
+# type(object) - return the datatype of the object
+datatype = type(fruit)
+# print(fruit, datatype) # apple
+
+# ------------------------------------------------------------------------------ #
+
+# change the value within the variable 'fruit'
+fruit = 'orange'
+# print(fruit) # orange
+
+# --------------------------------------------------------------------------------- #
+
+# call a string method on the fruit variable and redefine the variable with the return value
+fruit = fruit.upper()
+
+# concatentate using the string within the variable
+message = 'Favorite fruit: ' + fruit.title()
+# print(message) # Favorite fruit: Orange
+
+# ---------------------------------------------------------------------------------- #
+
+'''
+Python Variable Names
+- must start with a letter or underscore character
+- cannot start with a number
+- can only contain alphanumeric characters and underscores (A-z, 0-9 and _)
+- are case sensitive (age, Age, AGE are three different variables)
+'''
+
+# python_variable_and_function_names_use_snake_case
+# all lowercase words separated with underscores
+
+# ThisIsTitleOrPascalCase - used in Python for defining classes (custom datatypes)
+# ALLCAPS - generally used for constant variables
+
+# ----------------------------------------------------------------------------------- #
+
+# f-string
+
+# begin with an 'f' before the opening quote
+# Python expressions can be placed within the string using curly brackets {}
+
+# concatention only works with strings
+# other datatypes will need to be typecast as string using str()
+
+number = 99.5
+
+# output = 'The number is ' + str(number) + '!'
+# print(output) # The number is 99.5!
+
+# f-strings don't care about datatype
+output = f"The number is {number}!"
+# print(output) # The number is 99.5!
+
+
+# ------------------------------------------------------------------------------------- #
+
+# input() - allows the user to interact with the code
+
+'''
+user_string = input(prompt_message)
+
+Print the 'prompt_message' and wait for the user to hit Enter.
+Once the user hits 'Enter', anything they typed in the terminal will be returned.
+The returned string can be stored in a variable such as 'user_string' above
+
+fruit = input('Enter a fruit: ')
+print(f"Favorite fruit: {fruit}")
+'''
+
+
+# ---------------------------------------------------------------------------------- #
+
+# input() always returns a string
+
+# in order to user input() for numbers
+# the return value will need to be typecast from string to integer/float
+# int(object) - return a integer representation of the object, if possible
+# float(object) - return a float representation of the object, if possible
+'''
+number = input('Enter a number: ')
+
+print(number, type(number)) # 3
+print(number * 10) # '3333333333'
+
+# typecast the string number into a float
+number = float(number)
+
+print(number, type(number)) # 3.0
+print(number * 10) # 30.0
+'''
+# ------------------------------------------------------------------------------------------- #
+
+# value passed to int() and float() must LOOK like numbers
+# int('fish') # ValueError: invalid literal for int() with base 10: 'fish'
+# float('fish') # ValueError: could not convert string to float: 'fish'
+
+# ----------------------------------------------------------------------------------------- #
+
+# arithmetic operators
+
+x = 5
+y = 3
+
+# print(x + y) # addition +
+# print(x - y) # subtraction -
+
+# print(x * y) # multiplication *
+# print(x ** y) # exponentiation **
+
+# print(x / y) # regular division / (results in a float)
+# print(x // y) # floor division // (always round down to the nearest integer)
+
+# print(x % y) # modulus % (remainder after division)
+
+# ------------------------------------------------------------------------------------ #
+
+# % 2 to check even/odd
+
+# print(75 % 2) # 1 - odd
+# print(88 % 2) # 0 - even
+
+# ------------------------------------------------------------------------------------ #
+
+x = 3
+
+x + 2 # uses x but doesn't change it
+# print(x + 2) # 5 - uses x but doesn't change it
+# print(x) # 3
+
+# add 2 to 'x' and redefine the 'x' variable with the result
+x = x + 2
+# print(x) # 5
+
+
+# ReAssignment Operators - combine the arithmetic and assignment operators
+
+'''
+### These don't all need to be shown.
+### Showing a few to establish the pattern is enough
+x += 2 # x = x + 2
+x -= 10 # x = x - 10
+x *= 100 # x = x * 100
+x **= 3 # x = x ** 3
+x /= 15 # x = x / 15
+x //= 5 # x = x // 5
+x %= 2 # x = x % 2
+'''
+
+
+# ---------------------------------------------------------------------------------------- #
\ No newline at end of file
diff --git a/resources/example_lessons/unit_3/unit_2_review_template.py b/resources/example_lessons/unit_3/unit_2_review_template.py
new file mode 100644
index 0000000..f1aa14f
--- /dev/null
+++ b/resources/example_lessons/unit_3/unit_2_review_template.py
@@ -0,0 +1,109 @@
+'''
+Programming 101
+Unit 2 Review
+'''
+
+# variables are named storage spaces
+
+# assign a value to a variable using =
+
+# --------------------------------------------------------------------------------- #
+
+# variables become the datatype they store
+# type(object) - return the datatype of the object
+
+# ------------------------------------------------------------------------------ #
+
+# change the value within the variable 'fruit'
+
+# --------------------------------------------------------------------------------- #
+
+# call a string method on the fruit variable and redefine the variable with the return value
+
+# concatentate using the string within the variable
+
+# ---------------------------------------------------------------------------------- #
+
+'''
+Python Variable Names
+- must start with a letter or underscore character
+- cannot start with a number
+- can only contain alphanumeric characters and underscores (A-z, 0-9 and _)
+- are case sensitive (age, Age, AGE are three different variables)
+'''
+
+# python_variable_and_function_names_use_snake_case
+# all lowercase words separated with underscores
+
+# ThisIsTitleOrPascalCase - used in Python for defining classes (custom datatypes)
+# ALLCAPS - generally used for constant variables
+
+# ----------------------------------------------------------------------------------- #
+
+# f-string
+
+# begin with an 'f' before the opening quote
+# Python expressions can be placed within the string using curly brackets {}
+
+# concatention only works with strings
+# other datatypes will need to be typecast as string using str()
+
+# f-strings don't care about datatype
+
+# ------------------------------------------------------------------------------------- #
+
+# input() - allows the user to interact with the code
+
+'''
+user_string = input(prompt_message)
+
+Print the 'prompt_message' and wait for the user to hit Enter.
+Once the user hits 'Enter', anything they typed in the terminal will be returned.
+The returned string can be stored in a variable such as 'user_string' above
+'''
+
+
+# ---------------------------------------------------------------------------------- #
+
+# input() always returns a string
+
+# in order to user input() for numbers
+# the return value will need to be typecast from string to integer/float
+# int(object) - return a integer representation of the object, if possible
+# float(object) - return a float representation of the object, if possible
+
+# ------------------------------------------------------------------------------------------- #
+
+# value passed to int() and float() must LOOK like numbers
+
+### USE PREVIOUS EXAMPLE'S input() TO PRODUCE ERROR ###
+
+# ----------------------------------------------------------------------------------------- #
+
+# arithmetic operators
+
+# addition +
+# subtraction -
+
+# multiplication *
+# exponentiation **
+
+# regular division / (results in a float)
+# floor division // (always round down to the nearest integer)
+
+# modulus % (remainder after division)
+
+# ------------------------------------------------------------------------------------ #
+
+# % 2 to check even/odd
+
+# ------------------------------------------------------------------------------------ #
+
+# ReAssignment Operators - combine the arithmetic and assignment operators
+
+# x = 4
+
+### SHOW HOW x + 2 DOESN'T CHANGE x
+### SHOW HOW WE NEED TO DO x + 2 AND THEN USE THE RESULT TO REDEFINE x
+
+# ---------------------------------------------------------------------------------------- #
\ No newline at end of file
diff --git a/resources/example_lessons/unit_3/unit_3_lesson.py b/resources/example_lessons/unit_3/unit_3_lesson.py
new file mode 100644
index 0000000..a2e51c5
--- /dev/null
+++ b/resources/example_lessons/unit_3/unit_3_lesson.py
@@ -0,0 +1,167 @@
+'''
+Programming 101
+Unit 3
+'''
+
+# Datatype: boolean (bool)
+# True / False
+
+a = True
+b = False
+
+# print(a, type(a)) # True
+# print(b, type(b)) # False
+
+# in Python, booleans are capitalized
+# b = true # NameError: name 'true' is not defined
+
+# --------------------------------------------------------------------------------------------------- #
+
+# Comparison Operators - compare two pieces of data and result in a boolean
+
+x = 5
+y = 5
+
+# = is the assignment operator
+
+# print(x == y) # == check equality - True
+# print(x != y) # != check inequality - False
+
+# print(x < y) # < 'strictly' less than - False
+# print(x <= y) # <= less than or equal to - True
+
+# print(x > y) # > 'strictly' greater than - False
+# print(x >= y) # >= greater than or equal to - True
+
+# check the result of some math
+# print(x / 2 == 2.5) # True
+
+# check for a particular value in a variable
+# print(x == 5) # True
+# print(x == 99) # False
+
+# ----------------------------------------------------------------------- #
+
+# other datatypes can be compared as well
+# can't compare unlike datatypes
+
+word_1 = 'catt'
+word_2 = 'catt'
+
+# print(word_1 == word_2) # True
+# print(word_1 == 'cat') # False
+
+# ----------------------------------------------------------------------- #
+
+# Logical Operators - combine the results of two comparisons into a single boolean
+# and, or, not
+
+x = 5
+y = 3
+
+# and - True only if BOTH comparisons result in True
+# print(x == 5 and y == 3) # True - both comparisons result in True
+# print(x == 5 and x == y) # False - right comparison (x == y) results in False
+
+# or - True if at least ONE comparison is True
+# print(x == 5 or x == y) # True - left comparison (x == 5) results in True
+# print(x == 1 or x == y) # False - both comparisons result in False
+
+# not - flip a boolean
+# print(x < 0) # False
+# print(not x < 0) # True
+
+# ------------------------------------------------------------------------------------ #
+
+# 'not' is often used with the keyword 'in' to determine if an item is 'in' a sequence (list, string, etc...)
+
+word = 'book'
+
+# print('k' in word) # True
+# print('z' not in word) # True
+
+# ------------------------------------------------------------------------------------ #
+
+'''
+Conditional Statements - if / elif / else
+
+Run different code blocks based on the outcome of comparisons.
+
+Code Block
+----------
+A section of code that executed together.
+In Python, code blocks are defined using horizontal indentation
+
+
+- must start with if
+- every single if statement will be checked
+- elif will only be checked if the preceding if and other elifs were False
+- if/elif will only be checked until a True condition is found
+- else will be run if all other conditions were False
+
+'''
+
+# ------------------------------------------------------------------------------------- #
+
+light_switch = 'ON'
+
+if light_switch == 'ON': # colon signifies the beginning of a code block
+ # first line in a code block determines the indentation for the block
+ message = 'I can see!'
+
+elif light_switch == 'OFF':
+ message = "It's dark in here!"
+
+elif light_switch == 'DIM':
+ message = 'The light is dim...'
+
+else:
+ message = 'The light is broken...'
+
+# print(message)
+
+# -------------------------------------------------------------------------------------- #
+
+x = 10
+y = 10
+
+if x < y:
+ output = f"{x} is less than {y}"
+
+elif x == 14:
+ output = "x is 14"
+
+elif x > y:
+ output = f"{x} is greater than {y}"
+
+else:
+ output = f"x and y are both {x}"
+
+# print(output)
+
+# ---------------------------------------------------------------------------------- #
+
+# pretend this is line 1 of the file (imports are always at the top)
+import random
+
+# set the secret number 1-10
+# secret = 5
+
+# generate a secret number 1-10
+secret = random.randint(1, 10)
+
+# ask the user to guess a number
+guess = input('Guess a number between 1 and 10: ')
+
+# convert the guess to an integer
+guess = int(guess)
+
+# compare the guess to the secret
+if guess == secret:
+ print(f"Congratulations! You guessed the secret number: {secret}!")
+
+elif guess < secret:
+ print(f"Oops! Your guess of {guess} was too low! The secret number was {secret}...")
+
+elif guess > secret:
+ print(f"Oops! Your guess of {guess} was too high! The secret number was {secret}...")
diff --git a/resources/example_lessons/unit_4/unit_3_review.py b/resources/example_lessons/unit_4/unit_3_review.py
new file mode 100644
index 0000000..624465f
--- /dev/null
+++ b/resources/example_lessons/unit_4/unit_3_review.py
@@ -0,0 +1,202 @@
+'''
+Programming 101
+Unit 3 Review
+'''
+
+# datatype: boolean (bool)
+# True / False
+
+a = True
+b = False
+
+# print(a, type(a)) # True
+# print(b, type(b)) # False
+
+# booleans are Capitalized in Python
+# a = false # NameError: name 'false' is not defined
+
+# ---------------------------------------------------------------------------------- #
+
+# all datatypes have typecasting functions
+# str(), int(), float()
+
+# bool(object) - return a boolean representation of the object
+
+# Truthy/Falsey
+# If an object has value, it will convert to True
+# If an object has NO value, it will convert to False
+
+
+x = 0 # zero has no value - False
+y = 1 # 1 (or any number other than zero) has value - True
+
+x = '' # blank string has no value - False
+y = 'a' # string with at least one character has value - True
+
+x = [] # blank list has no value
+y = ['a'] # list with at least one item has value
+
+# print(bool(x), bool(y))
+# -------------------------------------------------------------------------------- #
+
+# Comparison Operators - compare two pieces of data and result in a boolean
+# all comparisons need two sides
+
+x = 5
+y = 5
+
+# print(x == y) # == equality - True
+# print(x != y) # != inequality - False
+
+# print(x < y) # < 'strictly' less than - False
+# print(x <= y) # <= less than or equal to - True
+
+# print(x > y) # > 'strictly' greater than - False
+# print(x >= y) # >= greater than or equal to - True
+
+# ------------------------------------------------------------------------------------ #
+
+# other datatypes can be compared
+word_1 = 'cat'
+word_2 = 'dog'
+
+# print(word_1 == word_2) # False
+# print(word_1 == 'cat' and word_2 == 'dog') # True
+
+# avoid < and > with datatypes other than numbers (at least for now)
+# print('a' < 'A') # False (confusing)
+
+# checking for alphabetical order
+# print('h' < 'w')
+
+# ---------------------------------------------------------------------------------- #
+
+# Logical Operators - combine two comparisons and result in a single boolean
+# and, or, not
+
+# all logical statements needs two comparisons
+
+x = 2
+y = 10
+
+# and - True only if BOTH comparisons are True
+# print(x == 2 and y == 10) # True - both comparisons result in True
+# print(x < 0 and y == 10) # False - left comparison (x < 0) results in False
+
+# or - True if at least ONE comparison is True
+# print(x < 0 or y == 10) # True - right comparison (y == 10) results in True
+# print(x < 0 or y < 0) # False - both comparisons result in False
+
+# ----------------------------------------------------------------------------------------- #
+
+# not - flip a boolean
+
+# 'not' works in front of any code that produces a boolean
+# .isnumeric() - string method which returns a boolean indicating if the string is all numbers or not
+
+string = '12a34'
+# print(string.isnumeric()) # False
+# print(not string.isnumeric()) # True
+
+# ----------------------------------------------------------------------------------------- #
+
+# 'not' with Truthy/Falsey
+
+word = ''
+
+# These two lines both check if the 'word' variable contains a blank string
+# print(word == '') # True
+# print(not word) # True
+
+
+# ------------------------------------------------------------------------------------------------ #
+
+# Conditional Statements - run different 'code blocks' based on the outcome of comparisons
+# keywords: if, elif, else
+
+# code block - A section of code that executes together.
+# In Python, code blocks are defined using horizontal indentation
+
+'''
+Conditional Statements
+----------------------
+- must start with an if
+- every single if will be checked
+- elif will only be checked if the preceding if and other elifs were False
+- else will run if all other conditions were False
+- if/elif will only be checked until a True condition is found
+'''
+
+'''
+if/elif combos
+--------------
+if
+if / else
+if / elif
+if / elif / else
+if / elif / elif / ... / elif
+if / elif / elif / ... / else
+'''
+# ------------------------------------------------------------------------------- #
+
+'''
+# ask the user for a color
+color = input('Enter a color: ')
+
+if color == 'green' or color == 'yellow':
+ output = f"I like the color '{color}'!"
+
+elif color == 'blue' or color == 'orange':
+ output = f"{color.upper()}!!!"
+
+elif 'p' in color:
+ output = f"The color {color} contains the letter 'p'."
+
+# elif color == '':
+elif not word: # same as line 155
+ output = "Color cannot be blank!"
+
+else:
+ output = f"I'm indifferent to the color '{color}'..."
+
+
+print(output)
+'''
+
+# ----------------------------------------------------------------------------------- #
+
+# 'nested conditionals' - conditionals within the code block of other conditionals
+
+'''
+# avoid repeating x < 10 using a nested conditional
+if x < 10 and x < 5:
+ # ... do something
+elif x < 10 and x == 5:
+ # ... # do something
+elif x < 10 and x > 5:
+ # ... # do something
+
+'''
+x = 15
+
+if x < 10:
+ output = f"{x} is less than 10"
+
+ if x == 5:
+ output += ' and x is 5'
+
+ elif x < 5:
+ output += f" and {x} is less than 5."
+
+ elif x > 5:
+ output += f" and {x} is greater than 5."
+
+
+else:
+ if x == 10:
+ output = "x is 10"
+
+ elif x > 10:
+ output = f"{x} is greater than 10"
+
+# print(output)
\ No newline at end of file
diff --git a/resources/example_lessons/unit_4/unit_3_review_template.py b/resources/example_lessons/unit_4/unit_3_review_template.py
new file mode 100644
index 0000000..580ec41
--- /dev/null
+++ b/resources/example_lessons/unit_4/unit_3_review_template.py
@@ -0,0 +1,114 @@
+'''
+Programming 101
+Unit 3 Review
+'''
+
+# datatype: boolean (bool)
+# True / False
+
+
+# booleans are Capitalized in Python
+
+# ---------------------------------------------------------------------------------- #
+
+### THIS SECTION CAN BE SKIPPED, IF NEEDED AS WELL AS ALL FURTHER REFERENCES TO TRUTHY/FALSEY
+
+# all datatypes have typecasting functions
+# str(), int(), float()
+
+# bool(object) - return a boolean representation of the object
+
+# Truthy/Falsey
+# If an object has value, it will convert to True
+# If an object has NO value, it will convert to False
+
+
+# zero has no value
+# 1 (or any number other than zero) has value
+
+# blank string has no value
+# string with at least one character has value
+
+# blank list has no value
+# list with at least one item has value
+
+# print(bool(x), bool(y))
+# -------------------------------------------------------------------------------- #
+
+# Comparison Operators - compare two pieces of data and result in a boolean
+# all comparisons need two sides
+
+
+# == equality
+# != inequality
+
+# < 'strictly' less than
+# <= less than or equal to
+
+# > 'strictly' greater than
+# >= greater than or equal to
+
+# ------------------------------------------------------------------------------------ #
+
+# other datatypes can be compared
+
+### THIS SECTION CAN BE SKIPPED, IF NEEDED ###
+# avoid < and > with datatypes other than numbers (at least for now)
+
+# checking for alphabetical order
+# ---------------------------------------------------------------------------------- #
+
+# Logical Operators - combine two comparisons and result in a single boolean
+# and, or, not
+
+# all logical statements needs two comparisons
+
+
+# and - True only if BOTH comparisons are True
+
+# or - True if at least ONE comparison is True
+
+# ----------------------------------------------------------------------------------------- #
+
+# not - flip a boolean
+
+# 'not' works in front of any code that produces a boolean
+# .isnumeric() - string method which returns a boolean indicating if the string is all numbers or not
+
+# ------------------------------------------------------------------------------------------------ #
+
+# Conditional Statements - run different 'code blocks' based on the outcome of comparisons
+# keywords: if, elif, else
+
+# code block - A section of code that executes together.
+# In Python, code blocks are defined using horizontal indentation
+
+'''
+Conditional Statements
+----------------------
+- must start with an if
+- every single if will be checked
+- elif will only be checked if the preceding if and other elifs were False
+- else will run if all other conditions were False
+- if/elif will only be checked until a True condition is found
+'''
+
+'''
+Conditional statements will always have:
+- 1 if
+- 0 to infinity elifs
+- 0 or 1 else
+'''
+# ------------------------------------------------------------------------------- #
+
+# 'nested conditionals' - conditionals within the code block of other conditionals
+
+'''
+# avoid repeating x < 10 using a nested conditional
+if x < 10 and x < 5:
+ # ... do something
+elif x < 10 and x == 5:
+ # ... # do something
+elif x < 10 and x > 5:
+ # ... # do something
+'''
diff --git a/resources/example_lessons/unit_4/unit_4_lesson.py b/resources/example_lessons/unit_4/unit_4_lesson.py
new file mode 100644
index 0000000..4e9173b
--- /dev/null
+++ b/resources/example_lessons/unit_4/unit_4_lesson.py
@@ -0,0 +1,261 @@
+'''
+Programming 101
+Unit 4
+'''
+
+import random
+
+'''
+Datatype: list (list)
+
+'Ordered' and 'changeable' sequences of items.
+
+Items are seprated with commas ,
+Lists are defined using square brackets []
+
+Since lists are 'ordered', their items can be retrieved using their positions in the list.
+An item's position in the list is called its 'index' ('indices' plural)
+'''
+
+# define an empty list
+empty_list = []
+# print(empty_list, type(empty_list)) # []
+
+# --------------------------------------------------------------------------------------------- #
+
+numbers = [11, -22, 33, -44] # list of integers
+colors = ['red', 'green', 'blue'] # list of strings
+
+# list items can be ANY datatype, including other lists
+jumble = ['cat', 99, None, 3.14, False, 'elephant', [1, 2, 3]]
+# print(jumble) # ['cat', 99, None, 3.14, False, 'elephant', [1, 2, 3]]
+
+# --------------------------------------------------------------------------------------------- #
+
+# list items can be organized vertically
+colors = [
+ 'red',
+ 'green',
+ 'blue'
+]
+
+# print(colors) # ['red', 'green', 'blue']
+
+# ------------------------------------------------------------------------------------------- #
+
+# retrieve an item from the list using its index
+# place the index in square brackets after the list's variable name
+
+# list indices always start at 0
+# print(colors[0]) # red
+# print(colors[1]) # green
+# print(colors[2]) # blue
+
+# can't use indices that don't exist
+# print(colors[3]) # IndexError: list index out of range
+
+# ---------------------------------------------------------------------------------------------- #
+
+# in Python, negative indices are allowed
+# print(colors[-1]) # blue
+# print(colors[-2]) # green
+# print(colors[-3]) # red
+
+# can't use indices that don't exist
+# print(colors[-4]) # IndexError: list index out of range
+
+# ----------------------------------------------------------------------------------------------- #
+
+# often, a variable will be used to represent an index
+index = 2
+# print(colors[index]) # blue
+
+# ---------------------------------------------------------------------------------------------- #
+
+### THIS SECTION CAN BE SKIPPED, IF NEEDED
+# strings are also 'ordered' sequences, which means
+# indices can be used to retrieve each character in a string
+
+letters = 'ABCDEFG'
+# print(letters[0]) # A
+
+# strings are NOT changeable
+# letters[0] = 'Z' # TypeError: 'str' object does not support item assignment
+
+# option 1: return a new string with the desired changes
+# letters = letters.replace('A', 'Z')
+# print(letters) # ZBCDEFG
+
+# option 2: convert the string to a list
+# list(sequence) - return the sequence as a list, if possible
+letters = list(letters)
+# print(letters) # ['A', 'B', 'C', 'D', 'E', 'F', 'G']
+
+letters[0] = 'Z'
+# print(letters) # ['Z', 'B', 'C', 'D', 'E', 'F', 'G']
+
+# ------------------------------------------------------------------------------- #
+
+# change the color at index 1 to 'yellow'
+colors[1] = 'yellow'
+# print(colors) # ['red', 'yellow', 'blue']
+
+# cannot add values this way
+# colors[3] = 'purple' # IndexError: list assignment index out of range
+
+# ----------------------------------------------------------------------------- #
+
+# add items using list methods
+
+# .append(item) - add a single item to the END of the list and return None
+colors.append('purple')
+# print(colors) # ['red', 'yellow', 'blue', 'purple']
+
+# .insert(index, item) - add the item at the index and return None
+colors.insert(1, 'cyan')
+# print(colors) # ['red', 'cyan', 'yellow', 'blue', 'purple']
+
+# .extend(sequence) - add the items from the sequence to the end of the list
+colors.extend(['magenta', 'yellow', 'pink'])
+# print(colors) # ['red', 'cyan', 'yellow', 'blue', 'purple', 'magenta', 'yellow', 'pink']
+
+# ----------------------------------------------------------------------------- #
+
+# delete items using list methods
+
+# .remove(item) - remove the first occurrence of the item from the list
+colors.remove('yellow')
+# print(colors) # ['red', 'cyan', 'blue', 'purple', 'magenta', 'yellow', 'pink']
+
+# .pop(index) - remove the item at the index and return it. index defaults to -1 if not provided
+
+# colors.pop() # remove the last item
+# print(colors) # ['red', 'cyan', 'blue', 'purple', 'magenta', 'yellow']
+
+# color = colors.pop(1)
+# print(color, colors) # cyan ['red', 'blue', 'purple', 'magenta', 'yellow']
+
+# ----------------------------------------------------------------------------------------- #
+
+# random.choice() - return a random selection from a sequence (list/string)
+
+# choose a random color from the list of colors
+random_color = random.choice(colors)
+# print(random_color)
+
+
+ABCs = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+random_letter = random.choice(ABCs)
+# print(random_letter)
+
+# ----------------------------------------------------------------------------------------- #
+
+'''
+loop - a code block that repeats until a certain condition is met
+
+'for' loop
+-----------
+
+for item in sequence - visit each item in a sequence (list, string, etc.)
+for x in range() - loop a certain number of times
+
+for/in - Python operators
+item/x - arbitrary variable name to store each item from the sequence as it's visited
+sequence/range() - iterable (loopable) object (list, string, range, etc...) through which to loop
+'''
+
+colors = ['red', 'cyan', 'blue', 'purple', 'magenta', 'yellow', 'pink']
+
+'''
+for color in colors:
+ # loop this code block
+ # for each item in the colors list
+ print(color)
+'''
+
+# ------------------------------------------------------------------------------------- #
+
+### 1. BUILD LOOP, PRINT EACH color
+### 2. INTRODUCE COUNTER VARIABLE. EXPLAIN DESIRED OUTPUT STRING "1. red"
+### 3. REPLACE THE COLOR WITH THE color VARIABLE, SHOW OUTPUT OF DIFFERENT COLORS WITH SAME NUMBER LABEL
+### 4. REPLACE THE NUMBER WITH THE counter VARIABLE, SHOW OUTPUT OF DIFFERENT COLORS WITH SAME NUMBER LABEL
+### 5. INCREASE counter TO CHANGE NUMBER LABEL
+
+counter = 1 # to label each color
+
+for color in colors:
+ output = f"{counter}. {color}"
+
+ # print(output)
+
+ # increase the counter to change the number label
+ counter += 1
+
+# ------------------------------------------------------------------------------------- #
+
+### SUGGESTED PRESENTATION
+### 1. COPY ABCs VARIABLE FROM random.choice() EXAMPLE ABOVE
+### 2. LOOP THROUGH ABCs, PRINT EACH letter
+### 3. DEFINE vowels LIST
+### 4. CHECK IF letter IS IN vowels LIST AND PRINT APPROPRIATE output
+
+# use a string as a sequence for looping
+ABCs = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+
+vowels = ['A', 'E', 'I', 'O', 'U']
+
+# loop through the string and print only the vowels
+for letter in ABCs:
+ # check if the current letter is a vowel
+ if letter in vowels:
+ output = letter
+
+ else:
+ output = '...'
+
+ # print(output)
+
+# ------------------------------------------------------------------------------------------ #
+
+# for x in range() - loop a certain number of times
+
+# range(stop_value) - return a range of numbers from 0 to stop_value-1
+
+# print(range(10)) # range(0, 10)
+
+# convert the range object to a list
+# print(list(range(10))) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+'''
+for number in range(10):
+ print(number)
+'''
+
+# ------------------------------------------------------------------------------------------- #
+
+# generate a list of the powers of 2 from 0 to 10
+
+# blank list of numbers
+powers_of_2 = []
+
+# loop 11 times
+for exponent in range(11):
+ powers_of_2.append(2 ** exponent)
+
+# print(powers_of_2) # [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
+
+# --------------------------------------------------------------------------------------------- #
+
+# generate a list of 10 random numbers between 0 and 100
+
+# blank list of numbers
+numbers = []
+
+# loop 10 times
+for x in range(10):
+ # generate a random number
+ random_number = random.randint(0, 100)
+
+ numbers.append(random_number)
+
+# print(numbers)
\ No newline at end of file
diff --git a/resources/example_lessons/unit_5/unit_4_review.py b/resources/example_lessons/unit_5/unit_4_review.py
new file mode 100644
index 0000000..ae30248
--- /dev/null
+++ b/resources/example_lessons/unit_5/unit_4_review.py
@@ -0,0 +1,265 @@
+'''
+Programming 101
+Unit 4 Review
+'''
+
+'''
+datatype: list (list)
+
+'Ordered' and 'changeable' sequences of items.
+
+Lists are defined using square brackets []
+Items are separated with commas ,
+
+Since lists are 'ordered', their items can be retrieved using their positions in the list.
+An item's position in the list is called its 'index' (indices plural)
+'''
+
+# define a list of strings
+fruits = ['gauva', 'apricot', 'kiwi']
+
+# organized vertically
+fruits = [
+ 'guava',
+ 'apricot',
+ 'kiwi'
+]
+
+# print(fruits) # ['guava', 'apricot', 'kiwi']
+
+# ------------------------------------------------------------------------------------ #
+
+# because lists are 'ordered', their items can be retrieved using their indices
+# list indices start at 0
+# print(fruits[0]) # guava
+# print(fruits[1]) # apricot
+# print(fruits[2]) # kiwi
+
+# step off the right edge of the list
+# print(fruits[3]) # IndexError: list index out of range
+
+# ---------------------------------------------------------------------- #
+
+# last index of a list is one less than the list's length
+# len(sequence) - return the length of the sequence as an integer
+
+# print(len(fruits)) # 3
+
+# calculate the last index using the list's length
+last_index = len(fruits) - 1
+# print(last_index, fruits[last_index]) # 2 kiwi
+
+# ----------------------------------------------------------------------------------- #
+
+# Python allows negative indices
+# -1 will be the last index in the list
+# print(fruits[-1]) # kiwi
+# print(fruits[-2]) # apricot
+# print(fruits[-3]) # guava
+
+# step off the left edge of the list
+# print(fruits[-4]) # IndexError: list index out of range
+
+# ------------------------------------------------------------------------------------------ #
+
+# strings are also 'ordered' sequences
+letters = 'ABCDEFG'
+# print(letters[-1]) # G
+
+# strings are NOT 'changeable'
+# letters[0] = 'Z' # TypeError: 'str' object does not support item assignment
+
+# ------------------------------------------------------------------------------------------ #
+
+# lists are changeable
+fruits[1] = 'lime'
+# print(fruits) # ['guava', 'lime', 'kiwi']
+
+# cannot add items this way
+# fruits[3] = 'lemon' # IndexError: list assignment index out of range
+
+# --------------------------------------------------------------------------------------------- #
+
+# use list methods to add items to a list
+# .append(item) - add the item to the end of the list
+fruits.append('lemon')
+# print(fruits) # ['guava', 'lime', 'kiwi', 'lemon']
+
+# .insert(index, item) - add the item at the index
+fruits.insert(2, 'gooseberry')
+# print(fruits) # ['guava', 'lime', 'gooseberry', 'kiwi', 'lemon']
+
+# .extend(sequence) - add the items from the sequence to the end of the list
+fruits.extend(['guava', 'lingonberry', 'strawberry'])
+# print(fruits) # ['guava', 'lime', 'gooseberry', 'kiwi', 'lemon', 'guava', 'lingonberry', 'strawberry']
+
+# ----------------------------------------------------------------------------------------- #
+
+# delete items with list methods
+
+# .remove(item) - remove the first occurrence of the item from the list
+fruits.remove('guava')
+# print(fruits) # ['lime', 'gooseberry', 'kiwi', 'lemon', 'guava', 'lingonberry', 'strawberry']
+
+# .pop(index) - remove the item at the index and return it. index is -1 if not provided
+
+# fruits.pop() # remove the last item from the list
+# print(fruits) # ['lime', 'gooseberry', 'kiwi', 'lemon', 'guava', 'lingonberry']
+
+# fruit = fruits.pop(1) # remove the item at index 1
+# print(fruit, fruits) # gooseberry ['lime', 'kiwi', 'lemon', 'guava', 'lingonberry']
+
+
+# -------------------------------------------------------------------------------------- #
+
+# .index(item) - return the index of the first occurrence of the item, if it exists
+lemon_index = fruits.index('lemon')
+# print(lemon_index, fruits[lemon_index]) # 3 lemon
+
+# value must exist in the list to get its index
+# print(fruits.index('peach')) # ValueError: 'peach' is not in list
+
+fruit = 'kiwi'
+if fruit in fruits:
+ index = fruits.index(fruit)
+else:
+ index = f'That item ({fruit}) is not in the list'
+
+# print(index)
+
+# --------------------------------------------------------------------------------------- #
+
+# .sort() - sort a list in ascending order in place (returns None)
+# fruits.sort()
+# print(fruits) # ['gooseberry', 'guava', 'kiwi', 'lemon', 'lime', 'lingonberry', 'strawberry']
+
+# use reverse=True to sort in descending order
+# fruits.sort(reverse=True)
+# print(fruits) # ['strawberry', 'lingonberry', 'lime', 'lemon', 'kiwi', 'guava', 'gooseberry']
+
+# ------------------------------------------------------------------------------------ #
+
+# typecast to list
+# list(sequence) - return the sequence as a list, if possible
+letters = list('ABCDEFG')
+# print(letters) # ['A', 'B', 'C', 'D', 'E', 'F', 'G']
+
+# ----------------------------------------------------------------------------------- #
+
+# string methods that deal with lists
+
+letters = 'A-B-C-D-E-F-G'
+
+# .split(separator) - split the string into a list at each instance of the separator character
+letters_list = letters.split('-')
+# print(letters_list) # ['A', 'B', 'C', 'D', 'E', 'F', 'G']
+
+colors = 'red, green, blue'
+colors = colors.split(', ')
+# print(colors) # ['red', 'green', 'blue']
+
+
+# ''.join() - joins all items in a sequence, using the string value as a seperator
+# letter_list = ['A', 'B', 'C', 'D', 'E', 'F', 'G']
+
+# new_string = ', '.join(letter_list)
+
+# print(new_string) # A, B, C, D, E, F, G
+
+
+# ----------------------------------------------------------------------------------------- #
+
+# 'nested' lists
+
+# 3x3 grid
+grid = [['O', 'O', 'X'], ['O', 'O', 'O'], ['O', 'O', 'O']]
+
+grid = [
+ ['O', 'O', 'X'],
+ ['O', 'O', 'O'],
+ ['O', 'O', 'O']
+]
+
+# print(grid[0]) # ['O', 'O', 'X']
+# print(grid[0][2]) # X
+
+grid[1][1] = 'X'
+grid[2][0] = 'X'
+
+# print(grid) # [['O', 'O', 'X'], ['O', 'X', 'O'], ['O', 'O', 'O']]
+
+'''
+for row in grid:
+ # join each row into a string using spaces
+ print(' '.join(row))
+'''
+
+# -------------------------------------------------------------------------------------------- #
+
+# for item in sequence - loop through each item in a sequence
+'''
+for fruit in fruits:
+ print(fruit)
+'''
+
+# --------------------------------------------------------------------------------------------- #
+
+# print only the fruits that start with the letter 'L'
+'''
+for fruit_name in fruits:
+ # check if the first letter of the fruit's name is 'L'
+ if fruit_name[0].upper() == 'L':
+ # if 'berry' in fruit_name: # only print the berries
+ print(fruit_name)
+ else:
+ print('...')
+'''
+# ----------------------------------------------------------------------------------------------- #
+
+# for x in range() - loop a certain number of times
+
+# range(stop) - return a range of numbers from 0 to stop-1
+'''
+for x in range(10):
+ print(x, x * '*')
+'''
+
+# --------------------------------------------------------------------- #
+
+# range(start, stop)
+'''
+for x in range(10, 21): # loop 10-20
+ print(x)
+'''
+# ----------------------------------------------------------------------- #
+
+# range(start, stop, step)
+'''
+for x in range(0, 101, 10):
+ print(x)
+'''
+
+# ---------------------------------------------------------------------- #
+
+# loop through the indices of a list
+
+# print(list(range(len(fruits)))) # [0, 1, 2, 3, 4, 5, 6]
+
+for index in range(len(fruits)):
+ # get the value at the current index
+ fruit = fruits[index]
+
+ # print(index, fruit)
+
+# -------------------------------------------------------------------- #
+'''
+# nested loop
+for fruit_name in fruits:
+ fruit_name = fruit_name.upper()
+ print(fruit_name)
+
+ for letter in fruit_name:
+ print(letter)
+
+ print('')
+'''
diff --git a/resources/example_lessons/unit_5/unit_4_review_template.py b/resources/example_lessons/unit_5/unit_4_review_template.py
new file mode 100644
index 0000000..9cac30f
--- /dev/null
+++ b/resources/example_lessons/unit_5/unit_4_review_template.py
@@ -0,0 +1,137 @@
+'''
+Programming 101
+Unit 4 Review
+'''
+
+'''
+datatype: list (list)
+
+'Ordered' and 'changeable' sequences of items.
+
+Lists are defined using square brackets []
+Items are separated with commas ,
+
+Since lists are 'ordered', their items can be retrieved using their positions in the list.
+An item's position in the list is called its 'index' (indices plural)
+'''
+
+# define a list of strings
+
+# organized vertically
+
+
+# ------------------------------------------------------------------------------------ #
+
+# because lists are 'ordered', their items can be retrieved using their indices
+# list indices start at 0
+
+# step off the right edge of the list
+
+# ---------------------------------------------------------------------- #
+### THIS SECTION CAN BE SKIPPED, IF NEEDED
+
+# last index of a list is one less than the list's length
+# len(sequence) - return the length of the sequence as an integer
+
+# calculate the last index using the list's length
+
+# ----------------------------------------------------------------------------------- #
+
+# Python allows negative indices
+# -1 will be the last index in the list
+
+# step off the left edge of the list
+
+# ------------------------------------------------------------------------------------------ #
+
+# strings are also 'ordered' sequences
+
+# strings are NOT 'changeable'
+
+# ------------------------------------------------------------------------------------------ #
+
+# lists are changeable
+
+# cannot add items this way
+
+# --------------------------------------------------------------------------------------------- #
+
+# use list methods to add items to a list
+# .append(item) - add the item to the end of the list and return None
+
+# .insert(index, item) - add the item at the index and return None
+
+# .extend(sequence) - add the items from the sequence to the end of the list and return None
+
+# ----------------------------------------------------------------------------------------- #
+
+# delete items with list methods
+
+# .remove(item) - remove the first occurrence of the item from the list and return None
+
+# .pop(index) - remove the item at the index and return it. index is -1 if not provided
+
+# -------------------------------------------------------------------------------------- #
+
+# .index(item) - return the index of the first occurrence of the item, if it exists
+
+# value must exist in the list to get its index
+
+# --------------------------------------------------------------------------------------- #
+
+# .sort() - sort a list in ascending order in place and return None
+
+# use reverse=True to sort in descending order
+
+# ------------------------------------------------------------------------------------ #
+
+# typecast to list
+# list(sequence) - return the sequence as a list, if possible
+
+# ----------------------------------------------------------------------------------- #
+
+### THIS SECTION CAN BE SKIPPED, IF NEEDED
+
+# string methods that deal with lists
+
+
+# .split(separator) - split the string into a list at each instance of the separator character
+
+# ''.join() - joins all items in a sequence, using the string value as a seperator
+
+# -------------------------------------------------------------------------------------------- #
+
+# for item in sequence - loop through each item in a sequence
+
+
+# --------------------------------------------------------------------------------------------- #
+
+# print only the fruits that start with the letter 'L'
+
+# ----------------------------------------------------------------------------------------------- #
+
+# for x in range() - loop a certain number of times
+
+# range(stop) - return a range of numbers from 0 to stop-1
+
+
+# --------------------------------------------------------------------- #
+### THIS SECTION CAN BE SKIPPED, IF NEEDED
+
+# range(start, stop)
+
+# ----------------------------------------------------------------------- #
+### THIS SECTION CAN BE SKIPPED, IF NEEDED
+
+# range(start, stop, step)
+
+
+# ---------------------------------------------------------------------- #
+### THIS SECTION CAN BE SKIPPED, IF NEEDED
+
+# loop through the indices of a list
+
+# -------------------------------------------------------------------- #
+### THIS SECTION CAN BE SKIPPED, IF NEEDED
+
+# nested loop
diff --git a/resources/example_lessons/unit_5/unit_5_lesson.py b/resources/example_lessons/unit_5/unit_5_lesson.py
new file mode 100644
index 0000000..eddf610
--- /dev/null
+++ b/resources/example_lessons/unit_5/unit_5_lesson.py
@@ -0,0 +1,116 @@
+'''
+Programming 101
+Unit 5
+'''
+
+import random
+import string # string module
+
+letters = string.ascii_letters
+# print(letters) # abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
+
+digits = string.digits
+# print(digits) # '0123456789'
+
+punctuation = string.punctuation
+# print(punctuation) # !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
+
+all_characters = letters + digits + punctuation
+# print(all_characters) # abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
+
+# --------------------------------------------------------------------------------------------------- #
+
+### A LOOP IS A CODE BLOCK THAT REPEATS UNTIL A CERTAIN CONDITION IS MET
+### IN A for LOOP, THE CONDITION IS BASED ON THE SEQUENCE OVER WHICH WE'RE LOOPING
+### IN A WHILE LOOP, WE SET THE CONDITION OVER WHICH WE LOOP
+### IT IS UP TO US TO CHANGE A VALUE WITHIN THE
+
+# while loop
+'''
+while some_condition == True:
+ # loop this code block
+ # until 'some_condition'
+ # becomes False
+'''
+
+
+# "for x in range(10)" with a while loop
+x = 0
+
+while x < 10:
+ # print(x)
+
+ # ... other code
+
+ # increment x to eventually make the loop's condition False
+ x += 1
+
+# --------------------------------------------------------------------------------------------- #
+
+### 1. INTRODUCE BLANK LIST
+### 2. BUILD LOOP USING LIST'S LENGTH
+### 3. GENERATE A RANDOM NUMBER EACH LOOP, PRINT IT
+### 4. INSTEAD OF PRINTING THE RANDOM NUMBER, ADD IT TO THE LIST
+
+# generate a list of 10 random numbers between 0 and 100
+
+# blank list to store numbers
+numbers = []
+
+# loop until there are 10 numbers in the list
+while len(numbers) < 10:
+ # add a random number to the list
+ numbers.append(random.randint(0, 100))
+
+# print(numbers) # [90, 3, 61, 23, 22, 94, 75, 9, 17, 48]
+
+# ------------------------------------------------------------------------------ #
+
+### 1. USE THE LIST OF numbers GENERATED USING THE LOOP ON LINE 61
+### 2. REMOVE ONE NUMBER AT A TIME AND PRINT THE LIST AFTER EACH
+### 3. WALK THROUGH THE OUTPUT IN THE TERMINAL
+
+# remove one number at time from a list until the list is empty
+
+# generated by the loop on line 52
+# print(numbers)
+
+# loop while the list still has numbers in it
+while numbers != []:
+ # remove one item from the end of the list and save it in a variable
+ number = numbers.pop()
+
+ # print(number, numbers)
+
+# -------------------------------------------------------------------------------- #
+
+# loop controls
+# else, break, continue
+
+'''
+1. BUILD LOOP, print(x)
+2. SHOW else AFTER THE LOOP RUNS
+3. SHOW THAT CODE BELOW THE LOOP RUNS NO MATTER WHAT,
+ BUT else ONLY RUNS WHEN THE LOOP'S CONDITION BECOMES FALSE
+4. SHOW HOW break CAUSES else TO BE SKIPPED
+5. SHOW HOW continue CAN BE USED TO SKIP ITERATIONS
+'''
+
+for x in range(10):
+
+ if x == 3 or x == 5:
+ print(x * '.')
+ continue # skip the rest of this iteration and begin the next
+
+ if x == 8:
+ print('Goodbye')
+ break # end the loop immediately
+
+ print(x)
+
+else:
+ # else will be triggered
+ # if the loop's condition becomes False
+ print('The loop made it all the way through!')
+
+print("\nother code ...")
diff --git a/resources/lessons/lesson_1 b/resources/lessons/lesson_1
new file mode 100644
index 0000000..dffb29b
--- /dev/null
+++ b/resources/lessons/lesson_1
@@ -0,0 +1,114 @@
+# Welcome to PDX Code Guild!
+
+# single-line comments use pound signs #
+
+# everything to the right of the pound sign will be a comment
+
+'''
+Multi-line
+comment with
+single quotes
+'''
+
+"""
+Multi-line
+comment with
+double quotes
+"""
+
+'''
+
+Comments
+
+- organize code
+- explain code
+- exclude lines of code for testing
+'''
+
+# ------------------------------------------------------------------------------- #
+
+# a 'function' is a named piece of code that performs a specific task
+
+# Python comes with many built-in function
+
+#functions must be executed using parentheses after their name ()
+
+# print(data) - a built-in function to display the 'data' in the terminal
+
+# express an opinion about spam
+
+# print("I don't like spam!") # I don't like spam!
+# --------------------------------------------------------------------------------------- #
+
+# Datatype: string (str)
+
+# strings are sequences of textual characters surrounded by quotes
+
+'cat'
+"dog"
+'012345678'
+"3.141592654"
+
+'' # blank string
+"" # blank string
+
+# -------------------------------------------------------------------------------------- #
+
+# concatenation - adding strings together to form a single string
+
+# print('pdx'+'code') # pdxcode
+
+# print three words with spaces between
+
+# print('pdx'+ ' ' + 'code' + ' ' + 'guild') # pdx code guild
+
+# build a word one letter at a time
+# print('c'+'a'+'t') # cat
+
+
+# print('4' + '4') # 44 - both 4s are strings
+
+# print(4 + 4) # 8 - both 4s are integers
+
+# print('4' + 4) # TypeError: can only concatenate str (not "int") to str
+# ---------------------------------------------------------------------------------- #
+
+# a "method" is a function (needs parentheses to be executed)
+
+# methods only manipulate the object to which they belong
+
+# an object's methods are accessed using a dot after the object
+
+# .upper() - return an uppercase version of the string
+
+# print('abcd'.upper()) # ABCD
+
+# print('wxyz'.upper()) # WXYZ
+
+# .title() - return a lowercased string with the first letter of each word capitalized
+
+# print('pOrTlAnd, oReGoN'.title()) # Portland, Oregon
+
+# -------------------------------------------------------------------------------------- #
+
+# Escape Characters
+
+# denoted with a backslash \ before the character
+# allow characters to be placed within a string that would normally cause errors
+# allow formatting of strings
+
+# Python uses quotation marks to begin and end strings
+
+# solution 1: mismatched sets of quotes
+# "Hello 'world'" # Error! Double quotes cancel each other
+# 'Hello "world"' # Error! Single quotes cancel each other
+
+# Solution 2: escape characters
+# print("Hello "world"") # Hello "world" - \" escape character
+# print('Hellow \'world\'') # Hello 'world' - \' escape characters
+
+
+# escape characters can also format strings
+
+# print('A\nB\nC') # \n - new line character
+# print('A\tB\tC') # \t - horizontal tab character
diff --git a/resources/lessons/lesson_1_review b/resources/lessons/lesson_1_review
new file mode 100644
index 0000000..69391b4
--- /dev/null
+++ b/resources/lessons/lesson_1_review
@@ -0,0 +1,87 @@
+'''
+Programming 101
+Unit 1 Review
+'''
+'''
+Multi-line comment
+with single quotes
+'''
+"""
+multi-line comment
+with double quotes
+"""
+'''
+Comments
+- organize code
+- explain code
+- exclude lines of code for testing
+'''
+# ------------------------------------------------------------------------------------- #
+# a function is a named piece of code that performs a specific task
+# print(data) - display the data in the terminal
+# functions need parentheses after their name to be executed
+# print('hello')
+# print() #blank line
+# print('world')
+# print() can accept multiple, comma-separated items
+# they will print with a space between each
+# print('cat', 'dog', 'elephant') # cat dog elephant
+# print(100, 'dog', 1.5) # 100 dog 1.5
+# label some data
+# print('pi:', 3.141592654) # pi: 3.141592654
+# -------------------------------------------------------------------------------------------- #
+# Datatype: string (str)
+# strings are sequences of textual characters surrounded by quotes
+"cat"
+'dog'
+'iuy62t3ghb2k3jh9862389(*^(*^'
+"... an entire book ... "
+'' # empty string
+"" # empty string
+' ' # symbol of a space
+" " # symbol of a space
+# ---------------------------------------------------------------------------------------- #
+# type(object) - return the datatype of the object
+# everything in Python is an object
+# print(type('')) #
+# print(type('3.14')) #
+# print(type(3)) #
+# ------------------------------------------------------------------------------------------ #
+# print a multi-line string
+"""
+print('''
+Multi-line comments
+ are also
+ multi-line strings
+''')
+"""
+# ------------------------------------------------------------------------------------------- #
+# concatenation - adding strings together to form a single string
+# print('pdx' + 'code' + 'guild') # pdxcodeguild
+# print('pdx' + ' ' + 'code' + ' ' + 'guild') # pdx code guild
+# --------------------------------------------------------------------------------------------- #
+# a "method" is a function that manipulates only the object to which it belongs
+# an object's methods are accessed with a dot . after the object
+# .upper() - return an uppercase version of the string
+# print('abcd'.upper()) # ABCD
+# .replace(old_str, new_str) - replace all occurrences of the old_str with the new_str
+# print('hello'.replace('h', 'j'))
+# methods can be chained
+# each subsequent method will operate on the return value of the previous
+# call .upper() on the string returned by .replace()
+# print('jello'.upper().replace('h')) # JELLO
+# -------------------------------------------------------------------------------------------- #
+# Escape Characters
+# denoted with a backslash \ before the character
+# allow characters to be placed within a string that would normally cause errors
+# allow formatting of strings
+# other uses...
+# Python uses quotation marks to begin and end strings
+# "Hello "world"" # Error! Double quotes cancel each other
+# Solution 1: use mismatched sets
+# print("Hello 'world'") # Hello "world"
+# Solution 2: escape characters
+# print("Hello \"world\"") # Hello "world"
+# escape characters can also format strings
+# print("A\nB\nC") # \n - new line character
+# print("A\tB\tC") # \t - horizontal tab character
diff --git a/resources/lessons/lesson_2 b/resources/lessons/lesson_2
new file mode 100644
index 0000000..fdc2bc8
--- /dev/null
+++ b/resources/lessons/lesson_2
@@ -0,0 +1,210 @@
+'''
+Programming 101
+Unit 2 Variables, Input Function
+'''
+
+# ------------------------------------Variables---------------------------------------- #
+
+# print('purple') # purple
+# print('purple') # purple
+# print('purple') # purple
+# print('purple') # purple
+# print('purple') # purple
+
+
+# print('green') # green
+# print('purple') # purple
+# print('purple') # purple
+# print('purple') # purple
+# print('purple') # purple
+
+color = 'purple'
+
+
+# print(color) # purple
+# print(color) # purple
+# print(color) # purple
+# print(color) # purple
+# print(color) # purple
+# ---------------------------------------------------------------------------- #
+
+'''
+Variables
+
+- are used to store data that the program will use later
+- can store objects of ANY datatype
+- BECOME the datatype of the object they store
+- can be given new values (be 'redefined')
+'''
+
+# = is the assignment operator
+# it assigns the value on the right to the variable on the left
+
+color = 'pink'
+# print(color) # pink
+# ---------------------------------------------------------------------------- #
+
+# variable 'color' IS a string because it CONTAINS a string
+# print(type(color)) #
+
+# since 'color' contains a string, it can be used in string operations
+# print(color.upper()) # PINK
+# print(color) # pink
+
+# redefine the value within 'color'
+color = 'purple'
+# print(color) # purple
+
+# redefine the 'color' variable using the return value from .upper()
+color = color.upper()
+# print(color) # PURPLE
+# ---------------------------------------------------------------------------- #
+
+first_name = 'James'
+
+# concatenate the values within the variables
+
+output = 'My name is ' + first_name + ' and my favorite color is ' + color.lower() + '.'
+# print(output) # My name is James and my favorite color is purple.
+
+# ---------------------------------------------------------------------------- #
+
+'''
+Python Variable Names
+
+- must start with a letter or underscore
+- cannot start with a number
+- can only contain alphanumeric characters and underscores (A-z, 0-9, and _)
+- are case sensitive (age, Age, AGE are 3 different variables)
+'''
+
+# user_name_1 = 'Athena' # valid variable name
+# 1u$ern@me = 'Hades' # invalid variable name
+
+# python_variable_and_function_names_use_snake_case
+# all lowercase words separated with underscores
+
+# variable names should aim to describe the data they contain
+phone_number = '7674352647' # good
+p = '8768562323' # bad
+
+# ---------------------------------------------------------------------------- #
+
+city = 'Portland'
+temp = 70 # integer - int
+
+
+# concatenation only works between strings
+# other datatypes wil lneed to be 'typecast' as strings using str()
+# str(object) - return a string representation of the object
+
+message = 'Welcome to ' + city + '! The temp today was ' + str(temp) + ' degrees!'
+# print(message) # Welcome to Portland! The temp today was 70 degrees!
+
+'''
+f-string
+
+- 'f' stands for 'formatted'
+- begin with and 'f' before the opening quote
+- Python expressions (code) can be placed within the f-string using curly brackets {}
+- don't care about datatype
+'''
+
+message = f'Welcome to {city}! The temp today was {temp} degrees!'
+# print(message) # Welcome to Portland! The temp today was 70 degrees!
+# ---------------------------------------------------------------------------- #
+
+# input() - allow the user to interact with the code from the terminal
+
+'''
+user_string = input('prompt message')
+
+- Print the 'prompt message' and wait for the user to hit Enter
+- Once the user hits Enter, anything they typed in the terminal will be returned from input()
+- The returned string can be stored in a variable such as 'user_string' above
+'''
+
+# color = input('Enter a color: ')
+# print(f'Favorite color: {color}')
+# ---------------------------------------------------------------------------- #
+
+
+
+'''
+input() always returns a string
+
+In order to use input() for datatypes other than strings,
+the return value will need to be typecast
+
+Integer (int) - whole numbers
+Float (float) - decimal numbers
+
+Typecasting functions
+str(object) - return a string representation of the object, if possible
+int(object) - return a integer representation of the object, if possible
+float(object) - return a float representation of the object, if possible
+'''
+'''
+number = input('Please enter a number: ')
+
+print(number + number) # '99'
+print(number, type(number)) # 9
+
+# redefine the string number as a float
+number = float(number)
+
+print(number + number) # 18.0
+print(number, type(number)) # 9.0
+'''
+# ---------------------------------------------------------------------------- #
+"""
+# Find the area of a rectangle with user-defined sides
+
+# have the user define the height and width of the rectangle
+height = input('Enter the height of the rectangle: ')
+width = input('Enter the width of the rectangle: ')
+
+# convert the height and width from strings to floats
+height = float(height)
+width = float(width)
+
+
+# calculate the area
+area = height * width # * is multiplication
+
+# display the result
+result = f'''
+Area of a Rectangle
+-------------------
+height ... {height}
+width .... {width}
+area ..... {area}'''
+
+# print(result)
+"""
+
+# ---------------------------------------------------------------------------- #
+
+
+# arithmetic operators (math)
+
+x = 5
+y = 3
+
+
+# print(x + y) # addition +
+# print(x - y) # subtraction -
+
+# print(x * y) # multiplication *
+# print(x ** y) # exponentiation ** (x^y)
+
+# print(x / y) # 'regular' division / (results in a float)
+# print(x // y) # 'floor' division // (always rounds down to the nearest integer)
+
+# print(x % y) # modulus % (remainder after division)
+# ---------------------------------------------------------------------------- #
+
+# // and % are compliments
+# print(75 / 10) # 7.5
+# print(75 // 10) # 7
+# print(75 % 10) # 5
diff --git a/resources/lessons/lesson_2_review b/resources/lessons/lesson_2_review
new file mode 100644
index 0000000..a1e0272
--- /dev/null
+++ b/resources/lessons/lesson_2_review
@@ -0,0 +1,171 @@
+'''
+Programming 101
+Unit 2 Review
+'''
+
+# variables are named storage spaces
+
+# assign a value to a variable using =
+
+fruit = 'apple' # assign the string 'apple' to the variable 'fruit
+# print(fruit) # apple
+
+# --------------------------------------------------------------------------------- #
+
+# variables become the datatype they store
+# type(object) - return the datatype of the object
+
+datatype = type(fruit)
+
+# print(fruit, datatype) # apple
+
+# ------------------------------------------------------------------------------ #
+
+# change the value within the variable 'fruit'
+fruit = 'orange'
+# print(fruit) # orange
+
+# --------------------------------------------------------------------------------- #
+
+# call a string method on the fruit variable and redefine the variable with the return value
+
+fruit = fruit.upper()
+
+# concatentate using the string within the variable
+
+message = 'Favorite fruit: ' + fruit.title()
+# print(message) # Favorite fruit: Orange
+
+# ---------------------------------------------------------------------------------- #
+
+'''
+Python Variable Names
+- must start with a letter or underscore character
+- cannot start with a number
+- can only contain alphanumeric characters and underscores (A-z, 0-9 and _)
+- are case sensitive (age, Age, AGE are three different variables)
+'''
+
+# python_variable_and_function_names_use_snake_case
+# all lowercase words separated with underscores
+
+# ThisIsTitleOrPascalCase - used in Python for defining classes (custom datatypes)
+# ALLCAPS - generally used for constant variables
+
+# ----------------------------------------------------------------------------------- #
+
+# f-string
+
+# begin with an 'f' before the opening quote
+# Python expressions can be placed within the string using curly brackets {}
+
+# concatention only works with strings
+# other datatypes will need to be typecast as string using str()
+
+number = 99.5
+
+output = 'The number is ' + str(number) + '!'
+# print(output) # The number is 99.5!
+
+# f-strings don't care about datatype
+
+output = f'The number is {number}!'
+# print(output) # The number is 99.5!
+
+# ------------------------------------------------------------------------------------- #
+
+# input() - allows the user to interact with the code
+
+'''
+user_string = input(prompt_message)
+
+Print the 'prompt_message' and wait for the user to hit Enter.
+Once the user hits 'Enter', anything they typed in the terminal will be returned.
+The returned string can be stored in a variable such as 'user_string' above
+
+
+fruit = input('Enter a fruit: ')
+print(f'Favorite fruit: {fruit}')
+
+'''
+
+
+# ---------------------------------------------------------------------------------- #
+
+# input() always returns a string
+
+# in order to user input() for numbers
+# the return value will need to be typecast from string to integer/float
+# int(object) - return a integer representation of the object, if possible
+# float(object) - return a float representation of the object, if possible
+'''
+number = input('Enter a number: ')
+
+# print(number, type(number)) # 3
+# print(number * 10) # '3333333333'
+
+# typecast the string number into a flot
+number = float(number)
+
+# print(number, type(number)) # 3.0
+
+# print(number * 10) # 30.0
+# '''
+# ------------------------------------------------------------------------------------------- #
+
+# value passed to int() and float() must LOOK like numbers
+
+# int('fish') # ValueError: invalid literal for int() with base 10: 'fish'
+# float('fish') # ValueError: could not convert string to float: 'fish'
+
+
+# ----------------------------------------------------------------------------------------- #
+
+# arithmetic operators
+
+x = 5
+y = 3
+
+# print(x + y)# addition +
+# print(x - y)# subtraction -
+
+# print(x * y)# multiplication *
+# print(x ** y)# exponentiation **
+
+# print(x / y)# regular division / (results in a float)
+# print(x // y)# floor division // (always round down to the nearest integer)
+
+# print(x % y)# modulus % (remainder after division)
+
+# ------------------------------------------------------------------------------------ #
+
+# % 2 to check even/odd
+# print(75 % 2) # 1 - odd
+# print(88 % 2) # 0 - even
+
+# ------------------------------------------------------------------------------------ #
+
+x = 3
+
+x + 2 # uses x but doesn't change it
+
+# print(x + 2) # 5 - uses x but doesn't change it
+# print(x) # 3
+
+# add 2 to 'x' and redenfine the 'x' variable with the result
+
+x = x + 2
+# print(x) # 5
+
+# ReAssignment Operators - combine the arithmetic and assignment operators
+
+'''
+x += 2 # x = x + 2
+x -= 10 # x = x - 10
+x *= 100 # x = x * 100
+x **= 3 # x = x ** 3
+x /= 15 # x = x / 15
+x //= 5 # x = x // 5
+x %= 2 # x = x % 2
+'''
+
diff --git a/resources/lessons/lesson_3 b/resources/lessons/lesson_3
new file mode 100644
index 0000000..a2e51c5
--- /dev/null
+++ b/resources/lessons/lesson_3
@@ -0,0 +1,167 @@
+'''
+Programming 101
+Unit 3
+'''
+
+# Datatype: boolean (bool)
+# True / False
+
+a = True
+b = False
+
+# print(a, type(a)) # True
+# print(b, type(b)) # False
+
+# in Python, booleans are capitalized
+# b = true # NameError: name 'true' is not defined
+
+# --------------------------------------------------------------------------------------------------- #
+
+# Comparison Operators - compare two pieces of data and result in a boolean
+
+x = 5
+y = 5
+
+# = is the assignment operator
+
+# print(x == y) # == check equality - True
+# print(x != y) # != check inequality - False
+
+# print(x < y) # < 'strictly' less than - False
+# print(x <= y) # <= less than or equal to - True
+
+# print(x > y) # > 'strictly' greater than - False
+# print(x >= y) # >= greater than or equal to - True
+
+# check the result of some math
+# print(x / 2 == 2.5) # True
+
+# check for a particular value in a variable
+# print(x == 5) # True
+# print(x == 99) # False
+
+# ----------------------------------------------------------------------- #
+
+# other datatypes can be compared as well
+# can't compare unlike datatypes
+
+word_1 = 'catt'
+word_2 = 'catt'
+
+# print(word_1 == word_2) # True
+# print(word_1 == 'cat') # False
+
+# ----------------------------------------------------------------------- #
+
+# Logical Operators - combine the results of two comparisons into a single boolean
+# and, or, not
+
+x = 5
+y = 3
+
+# and - True only if BOTH comparisons result in True
+# print(x == 5 and y == 3) # True - both comparisons result in True
+# print(x == 5 and x == y) # False - right comparison (x == y) results in False
+
+# or - True if at least ONE comparison is True
+# print(x == 5 or x == y) # True - left comparison (x == 5) results in True
+# print(x == 1 or x == y) # False - both comparisons result in False
+
+# not - flip a boolean
+# print(x < 0) # False
+# print(not x < 0) # True
+
+# ------------------------------------------------------------------------------------ #
+
+# 'not' is often used with the keyword 'in' to determine if an item is 'in' a sequence (list, string, etc...)
+
+word = 'book'
+
+# print('k' in word) # True
+# print('z' not in word) # True
+
+# ------------------------------------------------------------------------------------ #
+
+'''
+Conditional Statements - if / elif / else
+
+Run different code blocks based on the outcome of comparisons.
+
+Code Block
+----------
+A section of code that executed together.
+In Python, code blocks are defined using horizontal indentation
+
+
+- must start with if
+- every single if statement will be checked
+- elif will only be checked if the preceding if and other elifs were False
+- if/elif will only be checked until a True condition is found
+- else will be run if all other conditions were False
+
+'''
+
+# ------------------------------------------------------------------------------------- #
+
+light_switch = 'ON'
+
+if light_switch == 'ON': # colon signifies the beginning of a code block
+ # first line in a code block determines the indentation for the block
+ message = 'I can see!'
+
+elif light_switch == 'OFF':
+ message = "It's dark in here!"
+
+elif light_switch == 'DIM':
+ message = 'The light is dim...'
+
+else:
+ message = 'The light is broken...'
+
+# print(message)
+
+# -------------------------------------------------------------------------------------- #
+
+x = 10
+y = 10
+
+if x < y:
+ output = f"{x} is less than {y}"
+
+elif x == 14:
+ output = "x is 14"
+
+elif x > y:
+ output = f"{x} is greater than {y}"
+
+else:
+ output = f"x and y are both {x}"
+
+# print(output)
+
+# ---------------------------------------------------------------------------------- #
+
+# pretend this is line 1 of the file (imports are always at the top)
+import random
+
+# set the secret number 1-10
+# secret = 5
+
+# generate a secret number 1-10
+secret = random.randint(1, 10)
+
+# ask the user to guess a number
+guess = input('Guess a number between 1 and 10: ')
+
+# convert the guess to an integer
+guess = int(guess)
+
+# compare the guess to the secret
+if guess == secret:
+ print(f"Congratulations! You guessed the secret number: {secret}!")
+
+elif guess < secret:
+ print(f"Oops! Your guess of {guess} was too low! The secret number was {secret}...")
+
+elif guess > secret:
+ print(f"Oops! Your guess of {guess} was too high! The secret number was {secret}...")
diff --git a/resources/lessons/lesson_3_review b/resources/lessons/lesson_3_review
new file mode 100644
index 0000000..9aeea32
--- /dev/null
+++ b/resources/lessons/lesson_3_review
@@ -0,0 +1,177 @@
+'''
+Programming 101
+Unit 3
+'''
+
+# Datatype: boolean (bool)
+
+# True / False
+
+a = True
+b = False
+
+# print(a, type(a)) # True
+# print(b, type(b)) # False
+
+# in Python, booleans are capitalized
+# b = true # NameError: name 'true' is not defined
+# --------------------------------------------------------------------------------------------------- #
+
+
+# Comparison Operators - compare two pieces of data and result in a boolean
+
+
+x = 5
+y = 5
+
+# = is the assignment operator
+
+# print(x == y) # == check equality - True
+# print(x != y) # != check inequality - False
+
+
+# print(x < y) # < 'strictly' less than - False
+# print(x <= y) # <= less than or equal to - True
+
+
+# print(x > y) # > 'strictly' greater than - False
+# print(x >= y) # >= greater than or equal to - True
+
+
+# check the result of some math
+# print (x / 2 == 2.5) # True
+
+# check for a particular value in a variable
+
+# print(x == 5) # True
+
+# print(x == 99) # False
+# ----------------------------------------------------------------------- #
+
+# other datatypes can be compared as well
+# can't compare unlike datatypes
+
+word_1 = 'catt'
+word_2 = 'catt'
+
+# print(word_1 == word_2) # True
+# print(word_1 == 'cat') # False
+
+# ----------------------------------------------------------------------- #
+
+# logical Operators - combine the results of two comparisons into a single boolean
+# and, or, not
+
+
+x = 5
+y = 3
+
+# and = True only if BOTH comparisons result in True
+
+# print(x == 5 and y == 3) # True - both comparisons result in True
+
+# print(x == 5 and x == y) # False - right comparison (x == y) results in False
+
+# or - True if at least ONE comparison is True
+# print(x == 5 or x == y) # True - left comparison (x == 5) results in True
+# print(x == 1 or x == y) # False - both comparisons result in False
+
+
+# not - flip a boolean
+# print(x < 0)
+# print(not x < 0) # True
+
+# ------------------------------------------------------------------------------------ #
+
+# 'not' is often used with the keyword 'in' to determine if an item is 'in' a sequence (list, string, etc..)
+
+word = 'book'
+
+# print('k' in word) # True
+# print('z' not in word) # True
+
+# ------------------------------------------------------------------------------------ #
+
+'''
+Conditional statements - if / elif / else
+
+
+Run different code blocks based on the outcome of comparisons.
+
+Code Block
+----------
+
+A section of code that executes together.
+In Python, code blocks are defined using horizontal indentation
+
+- must start with if
+- every single if statement will be checked
+- elif will only be checked if the preceding if and other elifs were False
+- if/elif will only be checked until a True condition is found
+- else will be run if all other conditions were False
+
+'''
+
+# ------------------------------------------------------------------------------------- #
+
+
+light_switch = 'ON'
+
+if light_switch == 'ON': # colon signifies the beginning of a code block
+ # first line in a code block determines the indentation for the block
+ message = 'I can see!'
+
+elif light_switch == 'OFF':
+
+ message = "It's dark in here!"
+elif light_switch == 'DIM':
+
+ message = 'The light is dim...'
+else:
+
+ message = 'The light is broken...'
+
+# print(message)
+
+# -------------------------------------------------------------------------------------- #
+
+x = 10
+y = 10
+
+if x < y:
+ output = f'{x} is less than {y}'
+
+elif x == 14:
+ output = 'x is 14'
+
+elif x > y:
+ output = f'{x} is greater than {y}'
+
+else:
+ output = f'x and y are both {x}'
+
+# print(output)
+# ---------------------------------------------------------------------------------- #
+# pretend this is line 1 of the file (imports are always at the top)
+import random
+
+# set the secret 1-10
+# secret = 5
+
+secret = random.randint(1, 100000)
+
+# ask the user to guess a number
+guess = input('Guess a number between 1 and 10: ')
+
+# convert the guess to an integer
+guess = int(guess)
+
+
+if guess == secret:
+ print(f'Congratulations! you guess the secret number: {secret}')
+
+elif guess < secret:
+ print(f'Oops! Your guess of {guess} was too low! The secret number was {secret}...')
+
+elif guess > secret:
+ print(f'Oops! Your guess of {guess} was too high! The secret number was {secret}...')
diff --git a/resources/lessons/lesson_4 b/resources/lessons/lesson_4
new file mode 100644
index 0000000..079f212
--- /dev/null
+++ b/resources/lessons/lesson_4
@@ -0,0 +1,250 @@
+'''
+Programming 101
+Unit 4
+'''
+
+import random
+
+'''
+Datatype: list (list)
+
+'Ordered' and 'changeable' sequences of items.
+
+Items are seprated with commas ,
+Lists are defined using square brackets []
+
+Since lists are 'ordered', their items can be retrieved using their positions in the list.
+An item's position in the list is called its 'index' ('indices' plural)
+'''
+
+# define an empty list
+empty_list = []
+
+# print(empty_list, type(empty_list)) # []
+# --------------------------------------------------------------------------------------------- #
+
+# numbers = [11, -22, 33, -44] # list of integers
+# colors = ['red', 'green', 'blue'] # list of strings
+
+# list items can be ANY dataype, including other lists
+jumble = ['cat', 99, None, 3.14, False, 'elephant', [1, 2, 3]]
+# print(jumble) # ['cat', 99, None, 3.14, False, 'elephant', [1, 2, 3]]
+
+# --------------------------------------------------------------------------------------------- #
+
+# list items can be organized vertically
+
+colors = [
+ 'red',
+ 'green',
+ 'blue'
+]
+
+# print(colors) # ['red', 'green', 'blue']
+
+# --------------------------------------------------------------------------------------------- #
+
+# retrieve an item from the list using its index
+# place the index in square brackets after the list's variable name
+
+# list indices always start at 0
+# print(colors[0]) # red
+# print(colors[1]) # green
+# print(colors[2]) # blue
+
+# can't use indices that don't exist
+# print(colors[3]) # IndexError: list index out of range
+# --------------------------------------------------------------------------------------------- #
+
+# in Python, negative indices are allowed
+# print(colors[-1]) # blue
+# print(colors[-2]) # green
+# print(colors[-3]) # red
+
+# can't use indices that don't exist
+# print(colors[-4]) # IndexError: list index out of range
+
+# --------------------------------------------------------------------------------------------- #
+
+# often, a variable will be used to represent an index
+index = 2
+
+# print(colors[index]) # blue
+
+
+# --------------------------------------------------------------------------------------------- #
+
+# strings are also 'ordered' sequences, which means
+# indices can be used to retrieve each character in a string
+
+letters = 'ABCDEFG'
+# print(letters[0]) # A
+
+# strings are NOT changeable
+# letters[0] = 'Z' # TypeError: 'str' object does not support item assignment
+
+# option 1: return a new string with the desired changes
+# letters = letters.replace('A', 'Z')
+# print(letters) # ZBCDEFG
+
+# option 2: convert the string to a list
+# list() - return the sequence as a list, if possible
+letters = list(letters)
+# print(letters) # ['A', 'B', 'C', 'D', 'E', 'F', 'G']
+
+letters[0] = 'Z'
+# print(letters) # ['Z', 'B', 'C', 'D', 'E', 'F', 'G']
+
+# --------------------------------------------------------------------------------------------- #
+
+# change the color at index 1 to 'yellow'
+colors[1] = 'yellow'
+# print(colors) # ['red', 'yellow', 'blue']
+
+# cannot add values this way
+# colors[3] = 'purple' # IndexError: list assignment index out of range
+
+# --------------------------------------------------------------------------------------------- #
+
+# add items using list methods
+
+# .append(item) - add a single item to the END of the list and return None
+colors.append('purple')
+# print(colors) # ['red', 'yellow', 'blue', 'purple']
+
+# .insert(index, item) - add the item at the index and return None
+colors.insert(1, 'cyan')
+# print(colors) # ['red', 'cyan', 'yellow', 'blue', 'purple']
+
+# .extend(sequence) - add the items from the sequence to the end of the list
+colors.extend(['magenta', 'yellow', 'pink'])
+# print(colors) # ['red', 'cyan', 'yellow', 'blue', 'purple', 'magenta', 'yellow', 'pink']
+# --------------------------------------------------------------------------------------------- #
+
+# delete items using list methods
+
+# .remove(item) - remove the first occurrence of the item from the list
+colors.remove('yellow')
+# print(colors) # ['red', 'cyan', 'blue', 'purple', 'magenta', 'yellow', 'pink']
+
+# .pop(index) - remove the items at the index and return it. Index defaults to -1 if not provided
+# colors.pop() # remove the last item
+# print(colors) # ['red', 'cyan', 'blue', 'purple', 'magenta', 'yellow']
+
+# color = colors.pop(1)
+# print(color, colors) # cyan ['red', 'blue', 'purple', 'magenta', 'yellow']
+
+
+# --------------------------------------------------------------------------------------------- #
+
+# random.choice() - return a random selection from a sequence (list,string)
+
+# choose a random color from the list of colors
+random_color = random.choice(colors)
+# print(random_color)
+
+ABCs = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+random_letters = random.choice(ABCs)
+# print(random_letters)
+# --------------------------------------------------------------------------------------------- #
+
+'''
+loop - a code block that repeats until a certain condition is met
+
+'for' loop
+-----------
+
+for item in sequence - visit each item in a sequence (list, string, etc.)
+for x in range() - loop a certain number of times
+
+for/in - Python operators
+item/x - arbitrary variable name to store each item from the sequence as it's visited
+sequence/range() - iterable (loopable) object (list, string, range, etc...) through which to loop
+'''
+
+colors = ['red', 'cyan', 'blue', 'purple', 'magenta', 'yellow', 'pink']
+'''
+for color in colors:
+ # loop this code block
+ # for each item in the colors list
+ print(color)
+'''
+# --------------------------------------------------------------------------------------------- #
+
+counter = 1 # to label each color
+
+
+for color in colors:
+ output = f'{counter}. {color}'
+
+ # print(output)
+
+ # increase the counter to change the number label
+ counter += 1
+
+# --------------------------------------------------------------------------------------------- #
+
+ABCs = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+
+vowels = ['A', 'E', 'I', 'O', 'U']
+
+# loop through the string and print only the vowels
+for letter in ABCs:
+ # check if the current letter is a vowel
+ if letter in vowels:
+ output = letter
+
+ else:
+ output = '...'
+
+ # print(output)
+
+
+# --------------------------------------------------------------------------------------------- #
+
+# for x in range() - loop a certain number of times
+
+# range(stop_value) - return a range of number from 0 to stop_value -1
+
+# print(range(10)) # range(0, 10)
+
+# convert the range object to a list
+# print(list(range(10))) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+'''
+for number in range(10):
+ print(number)
+
+'''
+
+# --------------------------------------------------------------------------------------------- #
+
+# generate a list of the powers of 2 from 0 to 10
+
+
+# blank list of numbers
+powers_of_2 = []
+
+# loop 11 times
+
+for exponent in range(11):
+ powers_of_2.append(2 ** exponent)
+
+# print(powers_of_2) # [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]
+
+# --------------------------------------------------------------------------------------------- #
+
+# generate a list of 10 random numbers between 0 and 100
+
+# blank list of numbers
+numbers = []
+
+# loop 10 times
+for x in range(10):
+ # generate a random number
+ random_number = random.randint(0, 100)
+
+ numbers.append(random_number)
+
+
+#print(numbers)
diff --git a/resources/lessons/lesson_4_review b/resources/lessons/lesson_4_review
new file mode 100644
index 0000000..698db30
--- /dev/null
+++ b/resources/lessons/lesson_4_review
@@ -0,0 +1,235 @@
+'''
+Programming 101
+Unit 4 Review
+'''
+
+'''
+datatype: list (list)
+
+'Ordered' and 'changeable' sequences of items.
+
+Lists are defined using square brackets []
+Items are separated with commas ,
+
+Since lists are 'ordered', their items can be retrieved using their positions in the list.
+An item's position in the list is called its 'index' (indices plural)
+'''
+
+# define a list of strings
+
+fruits = ['guava', 'apricot', 'kiwi']
+
+# organized vertically
+
+fruits = [
+ 'guava',
+ 'apricot',
+ 'kiwi'
+]
+
+# print(fruits) # ['guava', 'apricot', 'kiwi']
+# ------------------------------------------------------------------------------------ #
+
+# because lists are 'ordered', their items can be retrieved using their indices
+# list indices start at 0
+
+# print(fruits[0]) # guava
+# print(fruits[1]) # apricot
+# print(fruits[2]) # kiwi
+
+# step off the right edge of the list
+
+# print(fruits[3]) # IndexError: list index out of range
+
+# ---------------------------------------------------------------------- #
+
+# last index of a list is one less than the list's length
+# len(sequence) - return the length of the sequence as an integer
+
+# print(len(fruits)) # 3
+
+# calculate the last index using the list's length
+
+last_index = len(fruits) - 1
+# print(last_index, fruits[last_index]) # kiwi
+
+
+
+# ----------------------------------------------------------------------------------- #
+
+# Python allows negative indices
+# -1 will be the last index in the list
+
+# print(fruits[-1]) # kiwi
+# print(fruits[-2]) # apricot
+# print(fruits[-3]) # guava
+
+# step off the left edge of the list
+# print(fruits[-4]) # IndexError: list index out of range
+
+# ------------------------------------------------------------------------------------------ #
+
+# strings are also 'ordered' sequences
+letters = 'ABCDEFG'
+# print(letters[-1]) # G
+
+# strings are NOT 'changeable'
+# letters[0] = 'Z' # TypeError: 'str' object does not support item assignment
+
+# ------------------------------------------------------------------------------------------ #
+
+# lists are changeable
+
+fruits[1] = 'lime'
+# print(fruits) # ['guava', 'lime', 'kiwi']
+
+# cannot add items this way
+# fruits[3] = 'lemon' # IndexError: list assignment index out of range
+
+# --------------------------------------------------------------------------------------------- #
+
+# use list methods to add items to a list
+
+# .append(item) - add the item to the end of the list and return None
+fruits.append('lemon')
+# print(fruits) # ['guava', 'lime', 'kiwi', 'lemon']
+
+# .insert(index, item) - add the item at the index and return None
+
+fruits.insert(2, 'gooseberry')
+# print(fruits) # # ['guava', 'lime', 'gooseberry', 'kiwi', 'lemon']
+
+# .extend(sequence) - add the items from the sequence to the end of the list and return None
+
+fruits.extend(['guava', 'lingonberry', 'strawberry'])
+# print(fruits) # ['guava', 'lime', 'gooseberry', 'kiwi', 'lemon', 'guava', 'lingonberry', 'strawberry']
+# ----------------------------------------------------------------------------------------- #
+
+# delete items with list methods
+
+# .remove(item) - remove the first occurrence of the item from the list and return None
+
+fruits.remove('guava')
+# print(fruits) # ['lime', 'gooseberry', 'kiwi', 'lemon', 'guava', 'lingonberry', 'strawberry']
+
+# .pop(index) - remove the item at the index and return it. index is -1 if not provided
+
+# fruits.pop()
+# print(fruits) # ['lime', 'gooseberry', 'kiwi', 'lemon', 'guava', 'lingonberry']
+
+
+fruit = fruits.pop(1)
+# print(fruit, fruits) # gooseberry ['lime', 'kiwi', 'lemon', 'guava', 'lingonberry', 'strawberry']
+
+# -------------------------------------------------------------------------------------- #
+
+# .index(item) - return the index of the first occurrence of the item, if it exists
+
+lemon_index = fruits.index('lemon')
+
+# print(lemon_index, fruits[lemon_index]) # 3 lemon
+
+# value must exist in the list to get its index
+# print(fruits.index('peach')) # ValueError: 'peach' is not in list
+
+fruit = 'apple'
+
+if fruit in fruits:
+ index = fruits.index(fruit)
+else:
+ index = f'That item ({fruit}) is not in the list'
+
+# print(index)
+
+# --------------------------------------------------------------------------------------- #
+
+# .sort() - sort a list in ascending order in place and return None
+
+fruits.sort()
+# print(fruits) # ['guava', 'kiwi', 'lemon', 'lime', 'lingonberry', 'strawberry']
+
+# use reverse=True to sort in descending order
+
+fruits.sort(reverse=True)
+# print(fruits) # ['strawberry', 'lingonberry', 'lime', 'lemon', 'kiwi', 'guava']
+# ------------------------------------------------------------------------------------ #
+
+# typecast to list
+# list(sequence) - return the sequence as a list, if possible
+
+letters = list('ABCDEFG')
+# print(letters) # ['A', 'B', 'C', 'D', 'E', 'F', 'G']
+
+# ----------------------------------------------------------------------------------- #
+
+# string methods that deal with lists
+
+letters = 'A-B-C-D-E-F-G'
+
+
+# .split(separator) - split the string into a list at each instance of the separator character
+
+letters_list = letters.split('-')
+# print(letters_list) #['A', 'B', 'C', 'D', 'E', 'F', 'G']
+
+colors = 'red, green, blue'
+
+colors = colors.split(', ')
+# print(colors) #['red', 'green', 'blue']
+
+# ''.join() - joins all items in a sequence, using the string value as a seperator
+
+letters_list = ['A', 'B', 'C', 'D', 'E', 'F', 'G']
+
+new_string = ', '.join(letters_list)
+# print(new_string) # A, B, C, D, E, F, G
+
+
+# -------------------------------------------------------------------------------------------- #
+
+# for item in sequence - loop through each item in a sequence
+'''
+for fruit in fruits:
+ print(fruit)
+'''
+
+# --------------------------------------------------------------------------------------------- #
+
+# print only the fruits that start with the letter 'L'
+'''
+for fruit_name in fruits:
+ # check if the first letter of the fruit's name is 'L'
+ if fruit_name[0].upper() == 'L':
+ print(fruit_name)
+ else:
+ print('...')
+'''
+# ----------------------------------------------------------------------------------------------- #
+
+# for x in range() - loop a certain number of times
+
+# range(stop) - return a range of numbers from 0 to stop-1
+'''
+for x in range(10):
+ print(x, x * '*')
+'''
+
+# --------------------------------------------------------------------- #
+
+# range(start, stop)
+
+# ----------------------------------------------------------------------- #
+### THIS SECTION CAN BE SKIPPED, IF NEEDED
+
+# range(start, stop, step)
+
+
+# ---------------------------------------------------------------------- #
+### THIS SECTION CAN BE SKIPPED, IF NEEDED
+
+# loop through the indices of a list
+
+# -------------------------------------------------------------------- #
+### THIS SECTION CAN BE SKIPPED, IF NEEDED
+
+# nested loop
diff --git a/resources/lessons/lesson_5 b/resources/lessons/lesson_5
new file mode 100644
index 0000000..f6270d3
--- /dev/null
+++ b/resources/lessons/lesson_5
@@ -0,0 +1,90 @@
+'''
+Programming 101
+Unit 5
+'''
+import random
+import string # string module
+
+letters = string.ascii_letters
+# print(letters) # abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
+
+digits = string.digits
+# print(digits) # 0123456789
+
+punctuation = string.punctuation
+# print(punctuation) # !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
+
+all_characters = letters + digits + punctuation
+# print(all_characters) # abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
+
+# --------------------------------------------------------------------------------------------------- #
+
+# while loop
+'''
+while some_condition == True:
+ # loop this code block
+ # until 'some_condition'
+ # becomes False
+'''
+
+# 'for x in range(10)' with a while loop
+
+x = 0
+
+while x < 10:
+
+ # print(x)
+
+ # ... other code
+
+ # increment x to eventually make the loop's condition False
+ x += 1 # x = x + 1
+
+# --------------------------------------------------------------------------------------------- #
+
+# generate a list of 10 random numbers between 0 and 100
+
+# blank list to store numbers
+numbers = []
+
+# loop until there are 10 numbers in the list
+while len(numbers) < 10:
+ # add a random number to the list
+ numbers.append(random.randint(0, 100))
+
+print(numbers) # [78, 55, 74, 36, 55, 15, 80, 64, 75, 87]
+# --------------------------------------------------------------------------------------------- #
+
+# remove one number at a time from a list until the list is empty
+
+# generated by the loop on line 51
+# print(numbers)
+
+# loop while the list still has numbers in it
+while numbers != []:
+ # remove one item from the end of the list and save it in a variable
+ number = numbers.pop()
+
+ print(number, numbers)
+# --------------------------------------------------------------------------------------------- #
+
+# loop controls
+# else, break, continue
+
+
+for x in range(10):
+
+ if x == 3 or x == 5:
+ print(x * '.')
+ continue # skip the rest of this iteration and begin the next
+
+ if x == 8:
+ print('Goodbye')
+ break # end the loop immediately
+
+ print(x)
+
+else:
+ print('The loop made it all the way through!')
+
+print('\nother code ...')
diff --git a/resources/slack/channel_home.png b/resources/slack/channel_home.png
new file mode 100644
index 0000000..9fada46
Binary files /dev/null and b/resources/slack/channel_home.png differ
diff --git a/resources/slack/create_code_snippet.png b/resources/slack/create_code_snippet.png
new file mode 100644
index 0000000..a7af6ed
Binary files /dev/null and b/resources/slack/create_code_snippet.png differ
diff --git a/resources/slack/file_options_icon.png b/resources/slack/file_options_icon.png
new file mode 100644
index 0000000..629f20c
Binary files /dev/null and b/resources/slack/file_options_icon.png differ
diff --git a/resources/slack/keegan_dm.png b/resources/slack/keegan_dm.png
new file mode 100644
index 0000000..71174f1
Binary files /dev/null and b/resources/slack/keegan_dm.png differ
diff --git a/resources/slack/search_bar.png b/resources/slack/search_bar.png
new file mode 100644
index 0000000..8702ffa
Binary files /dev/null and b/resources/slack/search_bar.png differ
diff --git a/resources/slack/search_keegan.png b/resources/slack/search_keegan.png
new file mode 100644
index 0000000..c7a866d
Binary files /dev/null and b/resources/slack/search_keegan.png differ
diff --git a/resources/slack/shortcuts_icon.png b/resources/slack/shortcuts_icon.png
new file mode 100644
index 0000000..356b27c
Binary files /dev/null and b/resources/slack/shortcuts_icon.png differ
diff --git a/resources/slack/snippet_popup.png b/resources/slack/snippet_popup.png
new file mode 100644
index 0000000..59e8b0c
Binary files /dev/null and b/resources/slack/snippet_popup.png differ
diff --git a/resources/slack/uploaded_file.png b/resources/slack/uploaded_file.png
new file mode 100644
index 0000000..f80275b
Binary files /dev/null and b/resources/slack/uploaded_file.png differ
diff --git a/resources/slack/view_raw_dropdown.png b/resources/slack/view_raw_dropdown.png
new file mode 100644
index 0000000..6ce19ff
Binary files /dev/null and b/resources/slack/view_raw_dropdown.png differ
diff --git a/resources/syllabus-instructions/1.PNG b/resources/syllabus-instructions/1.PNG
new file mode 100644
index 0000000..7f6e1f8
Binary files /dev/null and b/resources/syllabus-instructions/1.PNG differ
diff --git a/units/unit-0.md b/units/unit-0.md
index b4a9672..1a29687 100644
--- a/units/unit-0.md
+++ b/units/unit-0.md
@@ -1,33 +1,39 @@
# Unit 00
+
[Back to Syllabus](../README.md)
## Intro to the terminal
### Lesson
-Please go through Appendix A: Command Line Crash Course by Zed A. Shaw.
+Please go through Appendix A: Command Line Crash Course by Zed A. Shaw.
+
+Our _terminal cheatsheet_ can be found [here](/docs/terminal_cheatsheet.md).
-### Homework
+### Terminal Practice
-[Lab 1: Creating a folder on the Desktop](../labs/lab01_pdxfolder.md)
+[Lab 0: Creating a File Tree](../practice/unit_0/exercise_1.md)
## Installing Python
Please download the latest version of Python:
- - [Instructions for Windows](../docs/python_windows.md)
- - [Instructions for Mac](../docs/python_mac.md)
- - [Instructions for all other operating systems](https://realpython.com/installing-python/)
+- [Instructions for Windows](../docs/python_windows.md)
+- [Instructions for Mac](../docs/python_mac.md)
+- [Instructions for all other operating systems](https://realpython.com/installing-python/)
## Installing VS Code
Please visit the Visual Studio Code downloads page and download VS Code for your operating system.
-- Instructions for macOS
-- Instructions for Windows
-- Instructions for Linux
+
+- Instructions for macOS
+- Instructions for Windows
+- Instructions for Linux
### VS Code Tutorials
+
The following tutorials will help you get familar with VS Code:
+
- [Getting Started with VS Code](https://code.visualstudio.com/docs/introvideos/basics) (3 min video)
- [Customize Visual Studio Code](https://code.visualstudio.com/docs/introvideos/configure) (5 min video)
- [User and Workspace Settings](https://code.visualstudio.com/docs/getstarted/settings)
diff --git a/units/unit-1.md b/units/unit-1.md
index b53a473..579c356 100644
--- a/units/unit-1.md
+++ b/units/unit-1.md
@@ -1,11 +1,16 @@
# Unit 01
+
[Back to Syllabus](../README.md)
## Table of Contents
+
- [Comments](#comments)
-- [print()](#print)
+- [The `print()` function](#print)
- [Datatype: Strings](#strings)
- [String Concatenation](#concatenating)
+- [String Methods](#methods)
+- [Escape Characters](#escape)
+- [Unit 1 Lab](#lab)
## Comments
@@ -13,92 +18,55 @@
# this is a comment
```
-Comments are one of the most useful tools in programming. Comments can be used to:
-
-- organize code
-- explain code
-- exclude certain lines of code while testing
+Comments are one of the most useful tools in programming. Comments can be used to:
-### Organizing Code
-If you're anything like me, you love, LOVE to organize. From my closet to my kitchen, no item is left unturned. So imagine how excited I was to find that there was a method to organizing your code! Check out the example below.
-
-_You might not understand every single line of code. Don't worry about that for now._
+### organize code
```python
-# filename: roll_the_dice.py
-# author: lisa of PDX Code Guild
-
-# Modules (modules are libraries we can borrow methods from)
-import random
+# 10/07/2020
+# ------------------ #
+print('Welcome to Python!')
-# Logic
-dice1 = random.randint(1,6)
-dice2 = random.randint(1,6)
-
-result = dice1 + dice2
-
-# Result
-print(f"You rolled {result}!")
+# --- say hello! --- #
+print('Hello!')
```
-### Explain Code
-
-Now the example above is well organized but it could be better! I could use comments to explain what each line is doing. Check out the same example below but with comments explaining the code.
+### explain code
```python
-# filename: roll_the_dice.py
-# author: lisa of PDX Code Guild
-
-# Modules
-# import random so we can use the randint function which chooses a random number between two integers
-import random
-
-# Logic
-# randomly choose a number between 1 and 6
-# then save it to dice1
-dice1 = random.randint(1,6)
-# do the same as above but save the second number to dice2
-dice2 = random.randint(1,6)
-
-# add the value of dice1 and dice2 together; save to a new variable called result
-result = dice1 + dice2
-
-# Result
-# print the value of the variable result
-print(f"You rolled {result}!")
+# express an opinion about spam
+print("I don't like spam!")
```
-Don't the comments make it easier to understand the code? Moving foward, you should add comments to explain your code!
-### Exclude code while testing
-Below are two print() statements. We use print() when we want to print a message to the screen.
-
-Because there is a hash symbol at the beginning of the second line, _"Hello Pluto!"_ will not run and we will not see it printed to the screen!
+### exclude certain lines of code while testing
```python
-print("Hello World!")
-# print("Hello Pluto!")
+print("Hello friends!")
+# print("Hello nobody!") # this line is excluded using a comment
```
-#### Assignment
-Complete Exercise 2 of Learn Python the Hard Way.
-
-#### Quiz
-Complete this short quiz to test your knowledge.
-
[Back to top](#top)
-## print()
+## The `print()` function
```python
print("Hello! Welcome to my really cool app!")
```
-print() is a built-in function in Python. What that means is that it does all the work for you! As long as you have the correct syntax, anything you write in the parenthesis will display on the screen!
+`print()` is a built-in function in Python. Functions can be used to perform a variety of tasks. The parentheses are **required** in order for the function to work properly.
-#### Assignment
-Complete Exercise 5 of Learn Python the Hard Way. You can check out other built-in functions here.
+Data can be passed into the `print()` function's parentheses and that data will be displayed in the terminal. If no data is privided to `print()`, it displays a blank line.
+
+```python
+print('Hello world!') # Hello world!
+print() # prints a blank line
+print(4 + 4) # 8
+```
+
+[Back to top](#top)
## Datatype: Strings
+
There are many different datatypes in Python. The first one we will explore are Strings. String literals represent textual data.
```python
@@ -114,44 +82,84 @@ There are many different datatypes in Python. The first one we will explore are
Triple quoted strings may **span multiple lines**. All associated whitespace will be included in the string literal.
+```python
+print("""
+PDX Code Guild
+Programming 101
+Unit 1
+""")
+```
+
+Output
+
+```bash
+PDX Code Guild
+Programming 101
+Unit 1
+```
+
Some examples of Strings:
```python
-# String: Hello Mars!
-print("Hello Mars!")
+# String: Hello, friends!
+print("Hello, friends!")
-# String: Bucky is my favorite dog!
-dog_name = "Bucky"
-print(f"{dog_name} is my favorite dog!")
-# dog_name is variable where it's dataype is a String.
+# String: Welcome to PDX Code Guild!
+print("Welcome to PDX Code Guild!")
```
-We only use fstrings (format string) when we are embedding the value of a variable in a string when priting. We will learn more about this in Unit 2,
-
-#### Assignment
-Complete Exercise 6 of Learn Python the Hard Way
[Back to top](#top)
## String Concatenation
+
To concatenate, or combine, two strings you can use the **+** operator.
-Example 1:
+Strings will be printed **_exactly_** as they're written.
+
```python
-a = "Hello"
-b = "World"
-c = a + b
-print(c) # outcome: "HelloWorld"
+print("PDX" + "Code" + "Guild") # PDXCodeGuild
```
-Example 2:
+If we want spaces between our strings, we have to include them ourselves.
+
```python
-a = "Hello"
-b = "World"
-c = a + " " + b
-print(c) # outcome: "Hello World"
+# spaces inside another string
+print("PDX" + " Code " + "Guild") # PDX Code Guild
+
+# spaces inside their own strings
+print("PDX" + " " + "Code" + " " + "Guild") # PDX Code Guild
```
-To practice everythin you learned in Unit 1, please complete Lab 01.
-#### Lab 01: [Hello](https://github.com/PdxCodeGuild/Programming101/blob/master/labs/lab01_pdxfolder.md)
+## Methods
-[Back to top](#top)
\ No newline at end of file
+Methods are functions that manipulate the piece of data to which they're attached. In Python, many datatypes have methods, including strings.
+
+Find a full list of string methods [here](https://www.w3schools.com/python/python_ref_string.asp).
+
+### Common string methods:
+
+| method | description | example | result |
+| ------------ | --------------------------------------------------------- | -------------------------- | ------------- |
+| capitalize() | Converts the first letter to uppercase | "hello world".capitalize() | "Hello world" |
+| lower() | Converts a string to lowercase | "Hello World".lower() | "hello world" |
+| strip() | Removes whitespace from the beginning and end of a string | " Hello World ".strip() | "Hello World" |
+| title() | Converts the first character of each word to uppercase | "hello world".title() | "Hello World" |
+| upper() | Converts a string to uppercase | "hello world".upper() | "HELLO WORLD" |
+
+## Escape Characters
+
+Escape characters allow us to use special characters inside a string. They also allow us to use 'illegal' characters in a string, such as a double quote withing a string surrounded by double quotes.
+An escape character is a `\` followed by the character you want to insert.
+|code|result|
+|---|---|
+|`\'`|Single Quote|
+|`\"`|Double Quote|
+|`\\`|Backslash|
+|`\n`|New Line|
+|`\t`|Tab|
+
+To practice everything you learned in Unit 1, please complete the following lab:
+
+## Lab 01: [Hello](/labs/hello.md)
+
+[Back to top](#top)
diff --git a/units/unit-2.md b/units/unit-2.md
index 9cb280e..b1cbb44 100644
--- a/units/unit-2.md
+++ b/units/unit-2.md
@@ -1,35 +1,195 @@
# Unit 02
+
[Back to Syllabus](../README.md)
## Table of Contents
+
- [variables](#variables)
- [f-strings](#fstring)
- [input()](#input)
-- Random Module
-- Integers
-- Operators
+- [Integers / Floats](#numbers)
+- [Arithmetic Operators](#math-operators)
### Variables
-- Complete [Exercise 4](https://learnpythonthehardway.org/python3/ex4.html) of Learn Python the Hard Way
+
+Variables are used to store data that the program will use later.
+
+```python
+# a string, "Jim", is assigned to a variable called name
+name = "Jim"
+# we later use that variable in a print statement
+print("Hello " + name + "!") # Hello Jim!
+```
+
+A variable's value can be changed after assignment.
+
+```python
+# a string, "Jim", is assigned to a variable called name
+name = "Jim"
+
+# a string, "Pam", is assigned to a variable called name which OVERWRITES the previous data
+name = "Pam"
+
+# the string, "Jim", no longer exists!
+print("Hello " + name + "!") # Hello Pam!
+```
+
+### Variable names:
+
+- must start with a letter or the underscore character
+- cannot start with a number
+- can only contain alpha-numeric characters and underscores (A-z, 0-9, and \_ )
+- are case-sensitive (age, Age and AGE are three different variables)
+
+#### Valid variable names:
+
+```python
+username = 'Athena'
+user_name = 'Dionysus'
+username_2 = 'Artemis'
+_user_name = 'Aphrodite'
+userName = 'Poseidon'
+USERNAME = 'Hera'
+```
+
+#### Invalid variable names:
+
+```python
+2username = 'Nyx' # cannot begin with a number
+user-name = 'Hades' # no hyphens
+u$ern&me = 'Cerberus' # no special characters other than underscores
+user name = 'Persephone' # no spaces
+```
+
+[Back to top](#top)
+
+---
### f-strings
-- [Quick overview](https://www.w3schools.com/python/ref_func_print.asp)
-- Complete [Exercise 5](https://learnpythonthehardway.org/python3/ex5.html) of Learn Python the Hard Way
+
+Let's say we want to print a message to the user with some information that we have about them:
+
+```python
+# Variables
+name = "Lisa"
+city = "Portland"
+
+# print statement with the concatenation
+print("Hello " + name + "! Today in " + city + ", it is warm and sunny!") # Hello Lisa! Today in Portland, it is warm and sunny!
+```
+
+Doesn't that look cumbersome? An easier and cleaner way would be to use **f-strings**! We use f-strings to format Python expressions (bits of code) into our strings!
+
+f-strings start with an `f` before the opening quotation mark and code can be placed into the string using curly brackets `{}`. Any code inside an f-string's curly brackets is evaluated and its result is used.
+
+```python
+# Variables
+city = "Portland"
+weather = "warm and sunny"
+
+# print statement with an f-string
+print(f"Today in {city}, it is {weather}!") # Today in Portland, it is warm and sunny!
+```
+
+[Back to top](#top)
+
+---
### input()
-- [Quick overview](https://www.w3schools.com/python/ref_func_input.asp)
Example 1:
+
```python
+# this line has three actions!
+user_name = input("What is your name?")
# prints a question to the user
# then allows the user to type an input
# saves user input to a variable
-user_name = input("What is your name?") # this line has three actions!
+
+print(f"Hello {user_name}!")
# prints "Hello" with the user's name that they typed in!
-print(f"Hello {user_name}!") # outcome: "Hello Lisa"
+# outcome: "Hello "
+```
+
+- [input() code demo](https://repl.it/@pdxadmin/input) (Type in your name after the programs asks you for it!)
+- [read more here](https://www.w3schools.com/python/ref_func_input.asp)
+
+---
+
+### Numbers
+
+Integers are whole numbers. They can positive or negative.
+
+Let's use the example below to calculate how old we are this year.
+
+```python
+current_year = 2020 # integer (int)
+year_of_birth = 1988 # integer (int)
+age = current_year - year_of_birth
+
+print(age) # 32
+```
+
+Floats are one way that Python represents decimal numbers. They can also be positive or negative, but will always contain a decimal.
+
+### Error:
+
+```python
+# Error! Cannot concatenate string and integer
+print(4 + "4") # TypeError: unsupported operand type(s) for +: 'int' and 'str'
+```
+
+
+## Arithmetic Operators
+
+| Operator | Name | Example |
+| -------- | -------------- | -------- |
+| + | Addition | x + y |
+| - | Subtraction | x - y |
+| \* | Multiplication | x \* y |
+| / | Division | x / y |
+| // | Floor Division | x // y |
+| \*\* | Exponentiation | x \*\* y |
+| % | Modulus | x % y |
+
+### Arithmetic Example
+
+The adventure club you're in has decided to check out [Powell Butte Nature Park](https://www.portlandoregon.gov/parks/finder/index.cfm?action=ViewPark&PropertyID=528). When the idea comes up, 20 people are interested in going. On the day before the hike, 6 people drop out. Let's update the headcount.
+
+```python
+num_of_interested = 20
+drop_outs = 6
+num_of_attendees = num_of_interested - drop_outs
+
+print(f"There were {num_of_interested} people who were interested in going hiking but {drop_outs} have changed their mind. The total number of people going is now {num_of_attendees}.")
```
-#### Lab 03: [Mad Libs](https://github.com/PdxCodeGuild/Programming101/blob/master/labs/lab03_madlibs.md)
+**Output**
+
+ There were 20 people who were interested in going hiking but 6 have changed their mind. The total number of people going is now 14.
+
+We can also calculate the attendance rate as a percentage
+
+```python
+num_of_interested = 20
+drop_outs = 6
+num_of_attendees = num_of_interested - drop_outs
+
+attendance_rate = (num_of_attendees / num_of_interested) * 100
+
+print(f"There were {num_of_interested} people who were interested in going hiking but {drop_outs} have changed their mind. The total number of people going is now {num_of_attendees}.")
+
+print(f"That's an attendance rate of {attendance_rate}%")
+```
+
+**Output**
+
+ There were 20 people who were interested in going hiking but 6 have changed their mind. The total number of people going is now 14.
+ That's an attendance rate of 70.0%.
+
+---
+
+## Lab 02: [Mad Libs](https://github.com/PdxCodeGuild/Programming101/blob/master/labs/madlibs.md)
[Back to top](#top)
diff --git a/units/unit-3.md b/units/unit-3.md
index f6dc6c2..7d7b600 100644
--- a/units/unit-3.md
+++ b/units/unit-3.md
@@ -4,14 +4,19 @@
## Table of Contents
-- [Datatype: boolean](#boolean)
-- [Comparison Operators](#comparison)
-- [Logical Operators](#logical)
-- [Conditionals: if/else](#conditionals)
+
+ - [Dataype: Boolean](#dataype-boolean)
+ - [Comparison Operators](#comparison-operators)
+ - [Logical Operators](#logical-operators)
+ - [Conditionals: if/else](#conditionals-ifelse)
+ - [Random Module](#random-module)
+ - [Flowcharts](#flowcharts)
+ - [Lab 03: Grading](#lab-03-grading)
+
## Dataype: Boolean
-- [Boolean Overview (w3schools)](https://www.w3schools.com/python/python_booleans.asp)
+- [Boolean Overview (w3schools)](https://www.w3schools.com/python/python_booleans.asp)
A boolean can represent one of two values: `True` or `False`.
@@ -22,15 +27,15 @@ b = False
## Comparison Operators
-- [Comparison Operators Overview (w3schools)](https://www.w3schools.com/python/python_operators.asp)
- |Operator|Description|Example|
- |--------|-----------|-------|
- | == | Equal | x==y |
- | != | Not Equal | x != y |
- | > | Greater than | x > y |
- | < | Less than | x < y |
- | >= | Greater than or equal to | x >= y |
- | <= | Less than or equal to | x <= y |
+- [Comparison Operators Overview (w3schools)](https://www.w3schools.com/python/python_operators.asp)
+ |Operator|Description|Example|
+ |--------|-----------|-------|
+ | == | Equal | x == y |
+ | != | Not Equal | x != y |
+ | > | Greater than | x > y |
+ | < | Less than | x < y |
+ | >= | Greater than or equal to | x >= y |
+ | <= | Less than or equal to | x <= y |
```python
x = 3
@@ -51,7 +56,7 @@ x >= 3 # True
## Logical Operators
-- [Logical Operators Overview (w3schools)](https://www.w3schools.com/python/python_operators.asp)
+- [Logical Operators Overview (w3schools)](https://www.w3schools.com/python/python_operators.asp)
| Operator | Description | Example |
| -------- | ---------------------------------------- | ---------------- |
@@ -75,11 +80,11 @@ x >= 3 # True
## Conditionals: if/else
-- [Conditionals: if/else Overview (w3schools)](https://www.w3schools.com/python/python_conditions.asp)
+- [Conditionals: if/else Overview (w3schools)](https://www.w3schools.com/python/python_conditions.asp)
-We can use condtional statements to run code using our comparison operators
+We can use condtional statements to run code using our comparison operators.
-This can be achieved by using the `if` keyword
+This can be achieved by using the `if` keyword.
```python
x = 4
@@ -88,9 +93,9 @@ if x < y:
print("x is less than y")
```
-Notice how the `print` statement is indented? Python relies on indentation to define blocks of code. Other languages my use { } to accomplish the same task.
+Notice how the `print` statement is indented? Python relies on indentation to define blocks of code.
-We also have access to the keyword `elif`. This is pythons way of saying "if the previous condition was not True, then try this one"
+We also have access to the keyword `elif`. This is Python's way of saying, "if the previous condition was not True, then try this one."
```python
x = 4
@@ -103,7 +108,7 @@ elif x < y:
```
-Lastly we have `else`. This will catch any case that was not caught by the preceding conditions
+Lastly we have `else`. This will catch any case that was not caught by the preceding conditions.
```python
x = 4
@@ -119,9 +124,40 @@ else:
Notice there is no conditional statement on `else`.
-### Assignment
+### Random Module
+
+Modules are a Python object that are sources of related code; think of if as a library of information. A code library, if you will! It is a file containing a set of functions you want to include in your application. ([For a list of all modules, you can check out the offical Python docs](https://docs.python.org/3/py-modindex.html)).
+
+For this lesson, we will be looking at the [random module](https://pynative.com/python-random-module/). And specifically, we will be looking at the `randint()` function of the random module: [random.randint()](https://www.w3schools.com/python/ref_random_randint.asp). Please see the example below:
+
+```python
+# include the random module in our file
+import random
+
+# randint(bottom, top)
+# generate a random integer between
+# the bottom number and the top number
+random_number = random.randint(1, 100)
+
+print(f'Random number: {random_number}')
+
+```
-- [Unit 3 Quiz](https://forms.gle/2F7BuDH5vRKUZCUB6)
-- [Lab 04: Grading](/labs/lab04_grading.md)
+**Output**
+
+ Random number: 56
+
+ Random number: 13
+
+ Random number: 98
+
+---
+
+### Flow Charts
+
+[Flow Charts](../docs/flowcharts/README.md) are a great tool for planning the logical flow of a program. Click the link to read more.
+
+---
+## [Lab 03: Grading](/labs/grading.md)
[Back to top](#top)
diff --git a/units/unit-4.md b/units/unit-4.md
index d8d4411..bf6420e 100644
--- a/units/unit-4.md
+++ b/units/unit-4.md
@@ -1,19 +1,17 @@
# Unit 04
+
[Back to Syllabus](../README.md)
## Table of Contents
+
- [Datatype: Lists](#lists)
- [Modules](#modules)
-- [for each](#each)
+- [for item in sequence](#each)
- [for x in range()](#range)
-- [break](#break)
-- [continue](#continue)
-## Lists
-- [List Overview](https://www.w3schools.com/python/python_lists.asp)
-- [List Methods](https://www.w3schools.com/python/python_ref_list.asp)
+## Datatype: Lists
-A list is a collection which is ordered and changeable. In Python lists are written with square brackets.
+A list is a collection of items which are ordered and changeable. In Python lists are written with square brackets.
```python
fruits = [] # empty list
@@ -30,8 +28,13 @@ for fruit in fruits:
print(f"{fruit} has an index of {fruits.index(fruit)}")
```
+- [List code demo](https://repl.it/@pdxadmin/lists)
+- [List Overview](https://www.w3schools.com/python/python_lists.asp)
+- [List Methods](https://www.w3schools.com/python/python_ref_list.asp)
+
## Modules
-Modules are sources of code; similar to a library. It is a file containing a set of functions you want to include in your application. (For a list of all modules, you can check out the offical [Python docs](https://docs.python.org/3/py-modindex.html)). For this lesson, we will be looking at the [random module](https://pynative.com/python-random-module/). And specifically, we will be looking at the choice() function of the random module: [random.choice()](https://www.w3schools.com/python/ref_random_choice.asp). Please see the example below:
+
+Modules are sources of code; similar to a library. It is a file containing a set of functions you want to include in your application. (For a list of all modules, you can check out the offical [Python docs](https://docs.python.org/3/py-modindex.html)). For this lesson, we will be looking at the [random module](https://pynative.com/python-random-module/). And specifically, we will be looking at the `choice()` function of the random module: [random.choice()](https://www.w3schools.com/python/ref_random_choice.asp). Please see the example below:
```python
# include the random module in our file
@@ -48,77 +51,48 @@ chosen_fruit = random.choice(fruits)
# print the value of variable chosen_fruit
print(chosen_fruit)
```
-Let's practice random.choice() in the next lab.
-#### Lab 05: [Magic 8 Ball](https://github.com/PdxCodeGuild/Programming101/blob/master/labs/lab05_magic-8-ball.md)
+[Back to top](#top)
-## Loops: for each
+## Loops: for item in sequence
Do something to each item in a list.
```python
# initialize a list with student names and save to a variable, students
students = ["Al", "Anthony", "Lisa"]
-# the student variable only exists in this for loop. you cannot use "student" anywhere else
-# studentS is the list variable we created a bove
+
+# the student variable will hold each subsequent student as we pass through the students list
for student in students: # for each item in the list, do this:
print(f"Hello {student}")
```
-Outcome: each item of the list printed on a new line
-```
+Outcome: each item of the list printed on a new line:
+
+```bash
Hello Al
Hello Anthony
Hello Lisa
```
-Complete [Exercise 6](https://www.w3schools.com/python/exercise.asp?filename=exercise_for_loops3) of PYTHON Loops.
-
## Loops: for x in range()
Do something for a set number of times.
```python
-# x here is just a placeholder. it will do the counting for us
+# the x below is a counter. it will keep track of what number loop we are on
for x in range(3): # do the following 3 times
- print("Hello!")
+ print("Hello!") # this is done 3 times
+```
+
+Outcome: each item of the list is printed on a new line
-# outcome: each item of the list on a new line
+```bash
Hello
Hello
Hello
```
-Complete [Exercise 5](https://www.w3schools.com/python/exercise.asp?filename=exercise_for_loops2) of PYTHON Loops.
-
-## Loops: break
-
-The break keyword is used to break out a for loop, or a while loop.
-
-```python
-i = 1 # set variable i equal to the value of 1
-while i < 6: # as long as i (1) is less than 6, run the following
- print(i) # print i (1 on the first round)
- if i == 3: # on every loop, check if i == 3
- break # if it does, exit the while loop and stop counting
- i += 1 # after printing i (1), add 1 to i (1). i is now 2
-```
-
-## Loops: continue
-
-```python
-# Skip the iteration if the variable i is 3, but continue with the next iteration:
-for i in range(9):
- if i == 3:
- continue
- print(i)
-```
-Complete [Exercise 4](https://www.w3schools.com/python/exercise.asp?filename=exercise_for_loops1) of PYTHON Loops.
-
-## Additional Resources
-- Loops & Iteration
- - [article](https://www.py4e.com/html3/05-iterations)
- - [slides](https://www.py4e.com/lectures3/Pythonlearn-05-Iterations.pptx)
- - [video](https://www.youtube.com/watch?v=8DvywoWv6fI&t=8121s) (2:15:21 - 2:58:38)
+#### Lab 06: [Rock, Paper, Scissors](/labs/rps.md)
-[Back to top](#top)
\ No newline at end of file
+[Back to top](#top)
diff --git a/units/unit-5.md b/units/unit-5.md
index be372c9..8976085 100644
--- a/units/unit-5.md
+++ b/units/unit-5.md
@@ -1,28 +1,43 @@
# Unit 05
+
[Back to Syllabus](../README.md)
## Table of Contents
+
- [String Module](#string)
- [while loop](#while)
+- [break](#break)
+- [continue](#continue)
- [else](#else)
## String Module
-- [official docs](https://docs.python.org/3/library/string.html)
+
+The String module contains tools for working with strings. You can read the official docs [here](https://docs.python.org/3/library/string.html).
```python
-# including the string module in our file
+# Including the String module
import string
-# string.ascii_letters returns all upper and lower capital letters
-letters = string.ascii_letters
-
-print(letters)
-# outcome: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
+# string module constants
+print(string.ascii_letters)
+# result: abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
+print(string.ascii_lowercase)
+# result: abcdefghijklmnopqrstuvwxyz
+print(string.ascii_uppercase)
+# result: ABCDEFGHIJKLMNOPQRSTUVWXYZ
+print(string.digits)
+# result: 0123456789
+print(string.hexdigits)
+# result: 0123456789abcdefABCDEF
+print(string.whitespace)
+# result:
+print(string.punctuation)
+# result: !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
```
-#### Lab 08: [Password Generator](https://github.com/PdxCodeGuild/IntroToProgramming/blob/master/labs/lab08-password_generator.md)
## Loops: while
-Do something while statement is true.
+
+Do something while statement is `True`.
```python
i = 1 # set variable i equal to the value of 1
@@ -31,12 +46,40 @@ while i < 6: # as long as i (1) is less than 6, run the following
i += 1 # after printing i (1), add 1 to i (1). i is now 2
```
-Complete [Exercise 1](https://www.w3schools.com/python/exercise.asp?filename=exercise_while_loops1) of PYTHON Loops.
+## Loops: break
+
+The break keyword is used to break out of a loop.
+
+```python
+for i in range(10): # for each number 0-9, run the following
+ if i == 3: # on every loop, check if i == 3
+ print('skip 3')
+
+ # return to the top of the loop
+ continue
+
+ if i == 7:
+ print('Goodbye!')
+
+ # exit the loop
+ break
+
+ print(i) # print the current value of i
+```
+
+## Loops: continue
+
+```python
+# Skip the iteration if the variable i is 3, but continue with the next iteration:
+for i in range(9):
+ if i == 3:
+ continue
+ print(i)
+```
## Loops: else
-Do something while statement is true. When it is no longer true, do something else.
-Complete [Exercise 2](https://www.w3schools.com/python/exercise.asp?filename=exercise_while_loops2) of PYTHON Loops.
+Do something while statement is `True`. When it is no longer `True`, do something `else`. The `else` code block will only be triggered if a loop ends "naturally", when its condition becomes `False`. It will not be triggered if a loop is broken with `break`.
```python
i = 1 # set variable i equal to the value of 1
@@ -47,6 +90,6 @@ else: # the moment, i is 6, the while statement goes from True to False
print("i is no longer less than 6") # this will now print
```
-Complete [Exercise 3](https://www.w3schools.com/python/exercise.asp?filename=exercise_while_loops3) of PYTHON Loops.
+## Lab 5 - [Password Generator](/labs/password_generator.md)
-[Back to top](#top)
\ No newline at end of file
+[Back to top](#top)
+
+
+
+
+
+
+
+
+
