Your GitHub repository will be part of your portfolio and you will likely link to it from your portfolio.

Creating a clean looking README is as important for a project as having nice clean code.

Here are some examples of great READMEs:

• https://github.com/axios/axios
• https://github.com/Microsoft/vscode
• https://github.com/twbs/bootstrap
• https://github.com/electron/electron

Here are some example of great student READMEs:

• https://github.com/cfsanderson/Minesweeper
• https://github.com/m1g/tic-react-toe
• https://github.com/m1g/snowman

Objectives

• Create quality READMEs

Explorer Mode

• Choose several (at least three) repositories to update the READMEs
• Include a description, in your own words, of what the assignment was
• Include a list of technologies (and links to the homepage for each) you used
• Include a link to the project in production (surge, etc.)
• Include a screenshot or an animated gif (see Kap, Recordit, or Licecap)
• Optional:
  • Include an aspect you are particularly proud of
  • Include a snippet of code you are proud of (see GitHub Markdown on how to format code snippets)

Welcome to your journey as a developer. When learning a new language, a developer usually starts with creating a hello, world program. A hello, world program is a simple program that allows a developer to see the basic structure of an application as well as confirm their environment is working.

Objectives

• Ensure your development environment is setup.

Requirements

Make sure you have followed the
setup instructions for your computer's operating system

Follow this guide to review how to create and run C# applications.

Follow this guide to review how to turn in your assignments.

Explorer Mode

• Create a new app.
• In the static void Main, Change Welcome to C#, to
  Hello, World, my is [your name]

In this assignment, you will be creating a console application that manages a zoo
full of dinosaurs.

Objectives

• Practice control structures.
• Practice data structures.
• Practice working with user data.
• Practice with LINQ.
• Practice with OOP concepts.

Requirements

• Create a console application that manages the dinosaurs in your zoo.

Explorer Mode

• Create a class to represent your dinosaurs. The class should have the following properties

  • Name
  • DietType - This will be "carnivore" or "herbivore"
  • WhenAcquired - This will default to the current time when the
    dinosaur is created
  • Weight - How heavy the dinosaur is in pounds.
  • EnclosureNumber - the number of the pen the dinosaur is currently in

• Add a method Description to your class to print out a description of the dinosaur to include all of its properties. Create an output format of your choosing.

• Your dinosaurs will be stored in a List<Dinosaur>.

• When the console application runs, it should let the user choose one of the following actions:

  • View
    • This command will show the all the dinosaurs in the list, ordered by WhenAcquired
  • Add
    • This command will let the user type in the information for a dinosaur and add it to the list
  • Remove
    • This command will prompt the user for a dinosaur name then find and delete the dinosaur with that name.
  • Transfer
    • This command will prompt the user for a dinosaur name and a new EnclosureNumber and update that dino's information.
  • Summary
    • This command will display the number of carnivores and the number of herbivores.
  • Quit
    • This will stop the program

Adventure Mode

• Add an option to view the Dinosaurs acquired after a given date (to be given by the user).
• Add an option to view all the Dinosaurs in a given enclosure number.

Epic Mode

• Learn how to read and write from a file. At the start of the program load all the dinosaurs from a file. When the program ends write out all the dinosaurs to the same file.

For this assignment, you are creating a simple interactive scoreboard for your favorite sport.

Requirements

• Refer to this mockup to design your page:

• A user should be able to update a score and the teams playing.
• Use these HTML and CSS files as starting content:
  • HTML
  • CSS

Explorer Mode

Part 1:

• Create a new project using the beta stack and implement the design using the given HTML & CSS.
• Update the CSS to improve the styling based on your own design and tastes.
• Avoid updating the HTML too much, try to use existing elements and classes. However, do add new classes or elements for your design or your JavaScript if needed.
• Assign an event to the input fields to automatically change the team's name as the user types.
• Assign click events to the buttons to update the corresponding values on the page. The score buttons should adjust the current score by a "hard-coded" value.
• Deploy your site.

Part 2:

• Add an if statement to stop each team's score from going below 0.
• Add an if statement to stop each team's score from going above 21
• When a team gets 21 points, display a message to the user of who won
• Add a reset button that resets the scoreboard back to each team having 0 points

Adventure Mode

• Add more CSS to the winning teams score to indicate who won.
• Implement a Quarter/Period Tracker that would be appropriate for the sport.
• Add some styling to make it more presentable. Have fun with it.
• Make the layout responsive.

Epic Mode

• Add a Timer that counts down automatically and updates the period/quarter appropriately.
• Save/load the information to local storage.
• Add anything else that your sport would have on its scoreboard (e.g., fouls, sacks, shots on goal).
• Improve the ease of use for score keeping in your sport.

Get to know React Router by building yourself a small photo gallery site.

Objectives

• Adding dependencies to your React Project
• Navigating JSON data structures
• Using the React Router library
• Using parameters in React Router

Requirements

Using the JSON data below as a starter, build a photo gallery app. Here's
an example.

{
  "pandas": {
    "title": "Panda Bears",
    "description": "Pandas are bears native to south-central China, and are objectively the cutest animals on earth.",
    "photos": [
      {
        "title": "Panda Waving",
        "imageURL": "https://things-i-like.netlify.com/images/baby_panda.jpg",
        "sourceURL": "https://codeburst.io/pandas-for-data-stuff-code-challenge-7972207a8294"
      },
      {
        "title": "Großer Panda im Ocean Park, Hongkong",
        "imageURL": "https://things-i-like.netlify.com/images/grosser_panda.jpg",
        "sourceURL": "https://en.wikipedia.org/wiki/Giant_panda"
      },
      {
        "title": "Wild pandas get a boost; the iconic species has been upgraded from 'endangered' to 'vulnerable.'",
        "imageURL": "https://things-i-like.netlify.com/images/tree_panda.png",
        "sourceURL": "https://www.worldwildlife.org/magazine/issues/spring-2017/articles/wild-pandas-get-a-boost--2"
      },
      {
        "title": "Sacred Warrior, by Adrian Smith",
        "imageURL": "https://things-i-like.netlify.com/images/rising_sun.png",
        "sourceURL": "https://www.artstation.com/adrian-smith/albums/1298277"
      }
    ]
  },
  "miniatures": {
    "title": "Miniature Painting",
    "description": "I enjoy painting miniatures from board games. I've been painting since early 2018, here's some of my work.",
    "photos": [
      {
        "title": "City of Kings",
        "imageURL": "https://things-i-like.netlify.com/images/city_of_kings.jpg",
        "sourceURL": "https://www.instagram.com/p/Btv-0uYH8Xc"
      },
      {
        "title": "Blood Rage, Ram Clan",
        "imageURL": "https://things-i-like.netlify.com/images/ram_clan.jpg",
        "sourceURL": "https://www.instagram.com/p/BjRKLqYh4gK"
      },
      {
        "title": "Cormac the Druid, work in progress",
        "imageURL": "https://things-i-like.netlify.com/images/cormac.jpg",
        "sourceURL": "https://www.instagram.com/p/BnW2QrWDaky"
      }
    ]
  }
}

Save this as a JSON file in your project and import it.

If you hot-link photos from the internet, be sure to include a valid link back to the source.

Explorer Mode

• You should have at least 4 components: App, CategoryList, PhotoList, PhotoDetail.

• On the home page, your category list should render the title of each category and link using the key. For examples "Panda Bears" should link to /pandas

• Render each photo in the given category on the photo list page with a thumbnail-sized version of your photos.

• Render a large version of the photo on the photo details page.

• Customize the given data to include your own photos and categories.

• Add bread crumb navigation, as seen in the example.

• Add a thumbnail to the first photo in each category to the home page, as seen in the example.

Adventure Mode

• Choose one of the following:
  • Find an external API for a photo-sharing site (such as Flickr) and use data from the API rather than the given JSON file.
  • Create a C# backend to produce a list of categories with titles and descriptions, each category should have many photos. Create an API for this, deploy it, and then restructure your React front end to use this API.

Additional Resources

• React Router Documentation

In this project, you will practice accessing an API. You'll see how an API request is made, and see how data is returned from an API

Objectives

• Demonstrate usage of APIs
• Understand how an API request is sent.
• Understand the request and response for an API.

Explorer Mode

• [] Choose one of the APIs from
  this list that does not request
  "AUTH" (Authorization) since an API that requires authorization is a little
  more difficult to use when first learning. I have also selected some sample
  APIs that will be good choices:

• After choosing your API read the documentation.
• Use the Insomnia tool to make a few queries of the API.
• Capture screenshots from Insomnia showing your request and the response
  output.
• Attach those screenshots to your homework assignment.
• For one response, show a screenshot with the "Header" tab displayed.
• For this response, find a few headers and describe what they do. NOTE: If the header starts with X- it is a custom header and likely is documented by your API. Other headers are more standard and can be google searched.

Adventure Mode

Read the documentation on this API: https://one-list-api.herokuapp.com/

Choose your access token from your first and last name. For example jane-doe
or ron-swanson.

• Use Insomnia to insert 6 items in the list associated with your access token. Attach screenshots of the request and results screen.
• Use Insomnia to mark 2 of these items complete. Attach screenshots of the request and result screen.
• Use Insomnia to delete 1 of the non-complete items. Attach screenshots of the request and result screen.

Epic Mode

• Investigate using C#'s HttpClient class to make requests to any of the APIs you used in Adventure mode.
• Create a console app that makes requests and prints the results. Submit the URL to the Github repository of this console app.

Let's get started

Today, we are starting our journey into JavaScript. For this assignment, you
will be making a program that demonstrates some JavaScript fundamentals.

Objectives

• Ensure your development environment is setup
• Practice creating variables
• Practice working with user input

Requirements

Create your project using app-app with the beta stack

Remove all the code inside main.js and start with a fresh and empty file.

Explorer Mode

• Create a new app that does the following.

  • Practice Creating Variables

    • Create a variable that stores the numberOfCupsOfCoffee that you drink every day (even if that is zero).
    • Create a variable called fullName and set it equal to your full name.
    • Use console.log and your variables, numberOfCupsOfCoffee and fullName to output all three on one line.

  • Practice Getting Input From the User

    • Ask the user for their name and store it in a variable named userName. (use window.prompt to get input from the user)
    • Console log a greeting to the user, using their name.

  • Converting String Input Into Numbers

    • Input two numbers from the user. Use window.prompt twice, once for each prompt/number. Convert each resulting string from window.prompt to a float using parseFloat. Save the first value in a variable named firstOperand and the second value in a variable named secondOperand.

  • Doing Math

    • Add the operand variables from above and save the results in a variable named sum.
    • Subtract the secondOperand variable from the firstOperand variable and
      save the results in a variable named difference.
    • Multiply the operand variables and save the results in a variable named
      product.
    • Divide the firstOperand by the secondOperand and save the results in a
      variable named quotient.
    • Find the remainder when one operand is divided by the other and save the results in a variable named remainder.
    • Use console.log to present the user, in a meaningful way, each of the values for the sum, difference, quotient, product, and remainder variables. (e.g. perhaps one of your outputs is similar to
      If you add 4 and 5 you get 9 if 4 and 5 were the input)

  • Using Arrays

    • Use
      this page to generate a array of random numbers.
    • Place these numbers into a properly formatted array named numbers.
    • Determine the following. Use JavaScripts for loops to your advantage.
      • In a variable named smallest, find the smallest value in the array
      • In a variable named largest, find the largest value in the array
      • In a variable named sum, find the sum of all the values in the array
      • In a variable named average, find the average of all the values in the
        array

Adventure Mode

• Revisit your arrays. This time create new variables that represent:
  • sumOfOdd that contains the sum of all the odd numbers
  • countOfEven that contains the total count of all the even numbers

In this assignment, you will communicate with a back-end API server to create the user-interface for a Minesweeper clone. It might help to familiarize yourself with the game if you've never played it.

Objectives

• Understand how state drives changes to an interface in React
• Respond to user events in React
• Understand and use REST APIs
• Use React lifecycle methods
• Understand and interpret API documentation
• Use fetch or axios to perform POST request or

Requirements

Read over the documentation for the API we'll be using:

https://minesweeper-api.herokuapp.com/

You will need to interpret the response and render a graphical user interface. The API results include an array of arrays (two-dimensional array), these represent rows and columns. These are probably best translated into table rows (<tr>) and table data (<td>) cells.

Here's an example implementation of this assignment:

Explorer Mode

• Create a new game when the page loads, and render it on the screen, this look as close to gif as possible.
• Style the cells appropriately.
• Left clicking a cell performs the check action
• Right/secondary clicking a cell performs the flag action
• When the game status changed to won or lost, show a victory or failure message.

Adventure Mode

• Before creating the game, prompt the user to choose: Easy, Medium, or Hard mode.
• Have fun with the styling, make it your own

Epic Mode

• Render your victory/failure message as it's own "screen".
• On that screen add a button to restart or play again.
• Store the current game id in localStorage, and render the same game, rather than creating a new one every time (until the player presses the restart button).
• Add sound effects.

Additional Resources

• React Mouse Events

Create a Roshambo (Rock-Paper-Scissors) game.

Objectives

• Work with JavaScript and the DOM
• Practice conditional logic

Background

See the Wikipedia page about
Rock, Paper, Scissors

How to get started

• Get familiar with rock, paper, scissors if you haven't played before (or in a while)
• Draw out on paper/whiteboard/computer the rough design of your application
  • See Explorer Mode for the UI requirements
• Start by placing all the HTML elements on the page
• Style the user interface
• Write out in English, ALL the steps the application needs to take
  • For example "When user one clicks on Rock, remember that user one chooses
    Rock"

Explorer Mode

Part 1

NOTE: Complete part 1 before moving on to part 2

• There should be three buttons for Player One: Rock, Paper, Scissors
• There should be three buttons for Player Two: Rock, Paper, Scissors
• Player One should be able to select their throw
• Player Two should be able to select their throw
• After both players make their selection, I should be told who won and the game should be over.

Part 2

• You have heard about Rock, Paper, Scissors, but have you tried
  Rock, Paper, Scissors, Lizard, Spock?
  Modify your game to allow the extra options!
• Have fun with the CSS by adding colors, animations, and effects to make the
  game more enjoyable

Part 3

• Find at least THREE codewar you have not completed from our daily warmups and complete them. If you don't have THREE incomplete codewar warmups, find some new ones to tackle. I encourage for those who want an extra level of challenge, just let me know which codewar you are solving.
• For each, copy your solution into a gist: See https://gist.gitub.com and include those links in your homework comment.

Adventure Mode

• Your game is currently only 1 vs 1, add the ability to add more computer or users players to the game

GitHub has a great mascot called Octocat. Octocat even has its own gallery of variations, created by GitHub itself and fans, called Octodex.

You can use all the tools you have at your disposal to get the job done. Use your browser's Developer Tools to inspect their site to find the exact font sizes and padding amounts.

Objectives

• Build on your knowledge of HTML & CSS
• Implement, from scratch, a given design
• Understand HTML/CSS Layout
• Be able to place elements on a page where you want them.
• Use flexbox and grid techniques layout pages.
• Work with media queries to build a responsive page.

Requirements

• You should strive to implement the design as close as possible, though, especially if you've never touch HTML or CSS before, this can be extraordinarily difficult and will take a lot of practice and mileage.

Explorer Mode

• Use app-app with alpha and name your project Octodex
• Recreate the page as closely as you possibly can. Use the same fonts, sizes, and colors. Use your browser's developers tool to determine the colors and fonts.
• Select some Octocats to use on your page (12 to 16 or so). Your layout should be flexible but doesn't need to perfectly responsive.
  • Don't bother downloading details of the Octocat, we've [made a site]((https://sdg-octodex.herokuapp.com/) that will give you all the data you need.
• Use CSS media queries to resize the Octocat containers to look great as the screen changes size. Even though the site has a desktop, laptop, tablet, and mobile display, for explorer mode only worry about desktop and mobile.
• Deploy your site.
• TIP Reminder to breakdown the layout into smaller chunks that are easier to style

Adventure Mode

• Add a tablet display to accommodate a tablet screen size
• Add a laptop display to accommodate a tablet screen size.
• For the responsiveness of your cats, if you used flexbox for explorer mode, now use grids, if you grids, now use flexbox.

Epic Mode

• Go back to one past homework and make it responsive.
• Use this API to make your website data-driven. HINT: fetch, javascript and document.createElement. This is a big jump, but I think you can handle it.

Additional Resources

• Watch this video to work more with media queries

In your first assignment, you will end up with a web page, no matter how simple,
published on the web.

You will create a simple website that will showcase one of your passions. This
is not about making the website flashy, but more about focusing on creating a
website and learning your new tools.

Objectives

• Get to know your text editor
• Introduce yourself to working on the command line
• Write some HTML
• Publish a web page

Requirements

• If you have experience with existing HTML/CSS frameworks (bootstrap, Bulma, etc) you may not use them for these assignments.

Explorer Mode

• use app-app HelloWorld to create your first website.
• Compose a short essay (just a couple paragraphs at most) about a hobby you either enjoy or would like to learn about. We might expand on this page in future assignments, so pick something fun!
• Put your short essay into an HTML page, using appropriate semantic HTML elements. Give your webpage a simple header and footer as well.
• Deploy your site.

Objectives

• Create a simple API
• Practice problem solving

Requirements

• Create 2 endpoints, /mumbling and /explosion, that are based off of the katas,[https://www.codewars.com/kata/mumbling](https://www.codewars.com/kata/mumbling) and [https://www.codewars.com/kata/digits-explosion(https://www.codewars.com/kata/digits-explosion) respectfully.

Explorer Mode

• Create a new webapi api project
• Create a endpoint for the mumbling endpoint
  • Create a new Controller called MumblingController
  • This will have one HttpGet method
  • The method will accept a string either as a URL parameter or a query parameter. Your choice.
  • This endpoint method will take the string passed to it, manipulate according to the kata [https://www.codewars.com/kata/mumbling(https://www.codewars.com/kata/mumbling) and return the result
  • Have your code return the string
• Create a endpoint for the explosion endpoint
  • Create a new Controller called ExplosionController
  • This will have one HttpGet method
  • The method will accept a string either as a URL parameter or a query parameter. Your choice.
  • This endpoint method will take the string passed to it, manipulate according to the kata
    [https://www.codewars.com/kata/digits-explosion(https://www.codewars.com/kata/digits-explosion) and return the result
  • Have your code return the string

Adventure Mode

None

Epic Mode

None

Resources

• Use Insomnia for interacting with your API.

In this assignment, you'll create an HSL(a) color picker with React.

First, a little bit of color theory...

On the web, and computers in general, we often think of colors using the RGB color model. In HTML and CSS, we often use hexadecimal triplets to describe colors in RGB. For example, #76BCBB represents a nice shade of blue: . 76 is the red component, BC for green, and BB for blue. Those hexadecimal numbers translate, respectively, to 118, 188, 187 in decimal. The range for each color is 0 through 255.

Here is a short video to explain how hexadecimal colors work -- and here is a slightly longer video if the short video doesn't explain enough.

In this model, the three additive primary colors (red, green, and blue) are combined to create colors. The absence of these colors creates black, while all three colors at full strength combine to create white. In hexadecimal, FF represents the decimal value 255. This helps to explain why #FFFFFF represents white. We can also use other notations in CSS to specify colors, such as rgb(118, 188, 187), where the decimal values are given.

RGB isn't the only way we can use numbers to represent colors; there exists many color models, some with specialized purposes, such as CMYK a subtractive model used in printing. In many color models, the relationship between the color components isn't always evident in any meaningful way, especially if you're trying to combine them to find a specific color. Try looking for that perfect shade of blue on an RGB color picker, you will probably find it to be a little counter-intuitive. Some color models are easy to reason about, such as HSL (hue, saturation, lightness) and HSB (hue, saturation, brightness). Like RGB, CSS supports defining colors in HSL:

hsl(50,8%,20%)

The first value hue is given in degrees (around a color wheel), the second value is a percentage of saturation (0% being grey, 100% fully saturated), and the third value, a percentage of lightness (0% black, 100% white).

You can also read this short guide to HSL

Objectives

• Respond to user events in React
• Use state in react to drive changes to a user interface
• Use props to drive inline styles to dynamically update the appearance of DOM elements
• Understand RGB vs HSL color models
• Use controlled form inputs in React

Requirements

Use range type input elements to drive a color display. You'll end up with something like this:

HINT: You will want to combine techniques of string interpolation and using
inline styles in React, for
example:

const currentColor = `hsl(50,8%,20%)`

<div style={{ backgroundColor: currentColor }} >
  Hello World
</div>

Explorer Mode

• Represent the three values, hue, saturation, and lightness in your state.
• Add three sliders that update their respective values (hue, saturation, and lightness) in the state when changed.
• Display the color on the screen, in both text (i.e. hsl(50, 8%, 20%)) and the actual color as a background color on an element.
• Initialize the state to a random color when the page is loaded.
• Add a button that picks a new random color.
• In all cases, the sliders should be in the correct positions to represent the current color.

Adventure Mode

• Add a fourth slider for alpha, be sure to put some kind of pattern behind your color so the user can see the transparency effect.
• Add a section that displays a CSS class that applies the current background color to an element, just like https://cssgradient.io/
• Only display the output color text in hsla() if the alpha value is less than 1.

Additional Resources

• HSL Color Picker
• Inline styles in React
• HSL colors on MDN

Every application uses data in some way. In many of our applications we will be
storing information in a database. In this assignment we will be practicing
using SQL databases.

Objectives

• Create a database
• Write some queries to use the database

Setup

1. Fork this repository to your
   own account.
2. Change into your project's directory.
3. Clone your repository:
   git clone https://github.com/YOUR_NAME_HERE/sql-intro
4. Change into your newly cloned project's directory: cd sql-intro
5. code .
6. All your SQL queries should be placed inside the queries.sql file.

Explorer Mode

• Create a database: CompanyDatabase.

• Create a table: Employees with the following columns. Use your best judgment for data types. Copy the query you used to create this table and paste it into queries.sql.

  • FullName
  • Salary
  • JobPosition
  • PhoneExtension
  • IsPartTime

• Create a few employees. Review the requirements below to see some examples of the values you may need. For instance, you may need employees of certain job positions, employees with certain names, etc. Add enough data (maybe 10 rows) such that you can validate your queries. Copy the queries you used to create your data into queries.sql

• Create queries that can do the following. Each query should be attempted in your database. When it works, copy the query to queries.sql. You may optionally copy and paste the query output to your queries.sql if you wish.

  • Select all columns for all employees.
  • Select only the full names and phone extensions for only full-time employees.
  • Insert a new part-time employee, as a software developer, with a salary of 450. Make up values for the other columns.
  • Update all employees that are cooks to have a salary of 500.
  • Delete all employees that have the full name of "Lazy Larry".
  • Add a column to the table: ParkingSpot as textual information that can store up to 10 characters.

Adventure Mode

• Add queries to queries.sql that show how to:
  • Recreate your database and tables and use NOT NULL for columns you feel are required.
  • Add a primary key named Id to your table.

Epic Mode

• Add queries to queries.sql that show how to:
  • Create a second table: Departments that has these columns:
    • Name
    • BuildingNumber
  • Create a column on the Employees table named DepartmentId to relate
    to the Departments table. Make it a foreign key.
  • Insert employees and related departments.

Additional Resources

• PostgreSQL Documentation

Rhythm's gonna get you - ERD

For this project, we will model and create a database. We are starting a record
label company, and we a place to store our bands, albums, and eventually songs.
You are creating a console app that stores our information in a database.

Objectives

• Practice creating an Entity Relationship Diagram
• Practice working with SQL

Requirements

Create the ERD (Entity Relationship Diagram) and resulting tables that allows a
user to store and manage the company's bands, albums, and (eventually) songs.

How to turn in this assignment.

1. If you draw your ERD on paper, attach a photo. If you draw your ERD in a software tool, attach a screenshot of the image.
2. Paste all the SQL you wrote to create tables, insert rows, and try out SELECT/JOIN statements as a comment to this assignment.

Explorer Mode

• Create an ERD for Albums, and Bands. They should have the following properties, use your best judgment for types.

  • Album

    • Id
    • Title
    • IsExplicit
    • ReleaseDate

  • Band

    • Id
    • Name
    • CountryOfOrigin
    • NumberOfMembers
    • Website
    • Style
    • IsSigned
    • ContactName
    • ContactPhoneNumber

  • Add ERD relationships that show:

    • One Band has many Albums

  • Create SQL statements that:

    • Add a new band
    • View all the bands
    • Add an album for a band
    • Let a band go (update isSigned to false)
    • Resign a band (update isSigned to true)
    • Given a band name, view all their albums
    • View all albums ordered by ReleaseDate
    • View all bands that are signed
    • View all bands that are not signed

ALTERNATIVES

• If you do not wish to take on Band + Album you may go back to any of these assignments with an equivalent effort:
  • First Bank of Suncoast - Generate an ERD that supports multiple Users. Users have "Name", "Address", "Phone Number" - There will also be Transactions, each transaction will have a type (Deposit or Withdraw) and an account Checking or Savings. Generate the ERD and demonstrate SQL to create the tables, insert users, make transactions for users.
  • Jurassic Park - Generate an ERD that supports the existing Dino as well as an entity for Enclosures. The Enclosure should keep track of its Name, Capacity (number of Dinos), Location in the park. The Dinos should be able to be assigned to an enclosure. Generate the ERD and demonstrate SQL to create the tables, insert enclosures, insert Dinos, transfer dinos from one enclosure to another.

Rhythm's gonna get you

For this project, we will model and create a database. We are starting a record
label company, and we a place to store our bands, albums, and eventually songs.
You are creating a console app that stores our information in a database.

Objectives

• Practice working with SQL
• Practice working with ORMs (EF Core)

Setup

Create a console that allows a user to store and manage the company's bands,
albums, and (eventually) songs.

Top Tips

Although in reality an album could be done by more than one band, our system
will just have an album involving one band. That is, an album belongs to one
band.

Explorer Mode

• Create a database that stores Albums, and Bands. They should have the following properties, use your best judgment for types. (We will add foreign keys in the next step)

  • Album

    • Id
    • Title
    • IsExplicit
    • ReleaseDate

  • Band

    • Id
    • Name
    • CountryOfOrigin
    • NumberOfMembers
    • Website
    • Style
    • IsSigned
    • ContactName
    • ContactPhoneNumber

  • Add foreign keys to fulfill the following

    • One Band has many Albums

  • Create an interface to let the user:

    • Add a new band
    • View all the bands
    • Add an album for a band
    • Let a band go (update isSigned to false)
    • Resign a band (update isSigned to true)
    • Prompt for a band name and view all their albums
    • View all albums ordered by ReleaseDate
    • View all bands that are signed
    • View all bands that are not signed

Adventure Mode

• Add the ability for an album to have many songs. NOTE a song will only belong to a single album. Even if the same-named song appears on different albums we'd have a second entry for it.

  • Song

    • Id
    • Title
    • Lyrics
    • Length
    • Genre

• Track the individual members of a band. Create a new table called
  Musicians and give it a many to many relationships with a Band

• Add the following queries

  • View albums in a genre
  • View all members of a band

Epic Mode

• Add another entity that you feel would benefit the system. Update your ERD,
  tables and user interface to support it.

Additional Resources

• PostgreSQL Documentation

To start your journey you will be creating an API that allows a user to create and care for a virtual pet, reminiscent of a Tamagotchi. The basic functionality will walk you through the four basic parts of a web API, create, read, update and delete.

Objectives

• Create an API that can implement CRUD features against a Database.
• Practice creating ASP.NET Web API endpoints.
• Practice EF Core.

Explorer Mode

• Create and new sdg-api that has the following features

• Create a database with one table named Pets.

  • Should use a POCO called Pet with the following columns:
    • Id (int)
    • Name (string)
    • Birthday (DateTime)
    • HungerLevel (int)
    • HappinessLevel (int)

Your API should have the following endpoints

• GET /pets, should return all pets in your database.
• GET /pets/{id}, should return the pet with the corresponding id.
• POST /pets, should create a new pet. The body of the request should contain a JSON object with a key of "name" and a value of the pet's name. The pets Birthday should default to the current datetime, HungerLevel defaults to 0 and HappinessLevel defaults to 0.
• POST /pets/{id}/playtimes, should find the pet by id and add 5 to its happiness level and 3 to its hungry level.
• POST /pets/{id}/feedings, should find the pet by id and subtract 5 from its hungry level and 3 from its happiness level.
• POST /pets/{id}/scoldings, should find the pet by id and subtract 5 from its happiness level.
• DELETE /pets/{id}, should delete a pet from the database by Id

Adventure Mode

Add the following features to your API

• Add columns LastInteractedWithDate (DateTime). Every time a pet us updated in the database, set the LastInteractedWithDate to the current time. Add a property named IsDead to your Pets that has logic such that if the LastInteractedWithDate is over 3 days old, the property returns true otherwise false.
• Add a query parameter go GET /pets that only returns Pets that are alive.

Epic mode

Create a console app that interacts with your API that:

• Allows the user to see all pets
• Select a pet to take care of and then play with, scold, or feed the selected pet.
• Create a new pet.
• Delete a pet.

Resources

• Web API Tutorial
• Web API docs

It's 1989 and the Internet has just come online and Tim Berners-Lee is going to invent the World Wide Web. The Cold War is ending, and the Berlin Wall will be coming down. It's also going to be a great year for film. In this assignment, you're going to build a small webpage that showcases some of the most popular movies of 1989.

The data for this assignment comes from The Movie DB API.

You will need to sign up and make an account to get an API key. In the URL below replace the text YOUR_KEY_HERE with the key you receive when signing up for an account.

NOTE: If you have any challenge signing up for an account, see your instructor.

This is the API end-point that supplied the data file for this project:

https://api.themoviedb.org/3/discover/movie?primary_release_year=1989&sort_by=popularity.desc&api_key=YOUR_KEY_HERE

An example of the movie object is

{
  "popularity": 22.582,
  "vote_count": 2896,
  "video": false,
  "poster_path": "/2FC9L9MrjBoGHYjYZjdWQdopVYb.jpg",
  "id": 2493,
  "adult": false,
  "backdrop_path": "/aQ2ZbNqIaecoQsryNe33UmDtms.jpg",
  "original_language": "en",
  "original_title": "The Princess Bride",
  "genre_ids": [
    12,
    35,
    14,
    10749,
    10751
  ],
  "title": "The Princess Bride",
  "vote_average": 7.6,
  "overview": "In this enchantingly cracked fairy tale, the beautiful Princess Buttercup and the dashing Westley must overcome staggering odds to find happiness amid six-fingered swordsmen, murderous princes, Sicilians and rodents of unusual size. But even death can't stop these true lovebirds from triumphing.",
  "release_date": "1987-09-25"
}

You'll notice that the poster images are just the file names. You can get the full URL to a poster by concatenating the path with the following base URL:

https://image.tmdb.org/t/p/w185

In this case:

https://image.tmdb.org/t/p/w185/2FC9L9MrjBoGHYjYZjdWQdopVYb.jpg

NOTE: in place of w185 you can also use w92, w154, w185, w342, w500, w780, or original for different image widths based on your design's need.

Objectives

• Work with API data
• Understand and use React components
• Understand and use "props" in React
• Use map to render a collection of components in React

Explorer Mode

• Use the API to fetch the data and render it on the page, rather than the supplied JSON file.
• You should have at least two components; App and Movie.
• Render at least the title, poster image, and plot overview. Feel free to include other pieces of the data.
• Try to capture a 1980's or early 90's aesthetic when you style your page. Have fun with it!

Adventure Mode

• Sort the films by release date, rather than as they appear in the file.'
• Add a search bar that filters down the shown results. Note that is not making a new API call, just filtering the current list
• Display the release date in a formatted manner, e.g. "May 24th", rather than 1989-05-24. HINT: moment.js or date-fns or some utility code you write yourself!

Epic Mode

• Give the user a chance to "favorite" movies and store favorite movies in local storage
• Explore the API and use other endpoints.
• Allow the user to change the year they are searching for
• Change the style based on the decade they user selected

Additional Resources

• React Documentation
• .map, .reduce & .filter, Oh My!
• Array map

As we continue to explore databases and ideas, this project will help you
practice model databases and relationships.

We will be expanding on our CompanyDatabase from the INSERT INTO Student (knowledge) VALUES ('SQL') assignment. You will be adding new tables and be writing queries for these new tables.

Reuse the same repository from that assignment for this assignment. Add the new queries below the queries from that assignment such that the one repository will have both sets of queries. Use the same repository URL to turn in tonight's homework.

Objectives

• Work with foreign keys
• Craft queries that join tables

Explorer Mode

• In your CompanyDatabase, add a table named Departments with the following columns:
  • Id as a primary key
  • DepartmentName as text
  • Building as text
• Add a Foreign key DepartmentId to your Employees Table. If you have trouble, remove the existing employees by running truncate table "Employees".
• Add tables named Products and Orders.
  • Orders should have the columns
    • Id as a primary key
    • OrderNumber as a string
    • DatePlaced as a datetime
    • Email as a string
  • Products should have the columns
    • Price as a double
    • Name as a string
    • Description as a string
    • QuantityInStock as an integer
• In our company, one Order can have many Products and one Product can have many Orders. This will be a Many-to-Many relationship. Create the necessary table ProductOrders, foreign keys, and the OrderQuantityfield needed for this to happen.

• Create queries that can do the following:

  • Insert the following Departments

  Department Name	Building
  Development	Main
  Marketing	North

  • Insert the following Employees

  FullName	Salary	JobPosition	PhoneExtension	IsPartTime	Department Id
  Tim Smith	40000	Programmer	123	false	1
  Barbara Ramsey	80000	Manager	234	false	1
  Tom Jones	32000	Admin	456	true	2

• Insert the following Products

  Price	Name	Description	QuantityInStock
  12.45	Widget	The Original Widget	100
  99.99	Flowbee	Perfect for haircuts	3

• Insert a new order with order number X529, placed on Jan 1st, 2020 at 4:55PM, by someone with the email address "[email protected]"
• Add an order quantity of 3 for the product named Widget to the order X529
• Add an order quantity of 2 for the product named Flowbee to the order X529
• Given a department id, return all employees in the department.
• Given a department name, return all the phone extensions.
• Find all orders that contain the product id of 2.
• Remove the Flowbee product from order with order number X529.

Adventure Mode

Epic Mode

• Give these SQL Koans a try.

Additional Resources

• PostgreSQL Documentation

In this assignment, you will create a React application that will convert various currencies.

For the data, you will use the API available here

Objectives

• Work with an API to display data
• Work with React
• Work with the React lifecycle (componentDidMount with classes or useEffect with hooks)

Requirements

• Use this API documentation to build a page that allows for conversion between multiple currencies

Explorer Mode

• Create a page that loads and shows the current currency conversion rates.
• Design the page yourself or use utility CSS libraries like: Bootstrap or Bulma or Tailwind
• Use USD as the base currency.
• Allow the user to enter a currency amount (allow for decimal amounts like 42.12) in USD.
• Show the converted amount in each of the available currencies.
  • Either update as the user types or include a button that performs the conversion when clicked.

Adventure Mode

• Allow the user to choose a new base currency other than USD.
• Allow the user to use a specific day in the past.
  • HINT
  • Fetch the conversion rates for that day.
  • Show the updated conversion rates and converted amount.

Epic Mode

• Use react router to allow the user to specify the base currency in the URL

Now that you have created some HTML, its time to give your page some personality.

For this assignment you will be taking the HTML you made for the last project and extending it to have some styling.

Requirements

• Apply the ideas and stylings that you learn about in class.

Explorer Mode

• Take the CSS ideas and tools that were discussed in class and apply those to your homework.
• Apply colors, margin, padding, background colors, and font styles to the various elements of the page. Add class= where needed but try to keep to element selectors if you can!

Explorer Mode

• Research fonts.google.com and find an alternative font, or two, for your site. Use two different fonts (but no more than two) to style different aspects of your page. Maybe headers in one font and text in another.

Additional Resources

• Cool game to learn CSS selectors
• Introduction to CSS
• Getting Started with CSS Rules
• All the CSS properties
• pseudo-classes and pseudo-elements
• http://www.csszengarden.com/

The Octodex is a fun way to celebrate a powerful tool we use for development. In that same spirit, recreate this site

You'll identify the main Components on the page and create React components for each, breaking down those Components into smaller ones as needed.

Objectives

• Learn to identify parts of a web site as Components
• Use app-app (GAMMA stack) to build a React project
• Understand and use React components

Stretch Objectives

• Understand and use "props" in React

Explorer Mode

• Create your React app using app-app GAMMA
• If you have done the non-React version of octodex, use your existing HTML as the render() method of your App component. Otherwise, figure out the main components of the page and implement the render() method of App
• Your CSS should be in index.css -- feel free to copy your previous project's css if you have done the non-React version of this assignment.
• You should have at least two components... (Hint, perhaps Header, and an Octocat)
• Use props to try to reuse components (reuse the Octocat component)

Adventure Mode

• Place the definition of each Octocat in an array of objects and use map to generate the Octocat components

Epic Mode

• Put the array of Octocats in an octocats.json file and import that into your app.
• OR
• Use the fetch API to retrieve the list of Octocats from this api instead

Additional Resources

• React Documentation
• .map, .reduce & .filter, Oh My!
• Array.prototype.map

Now that we have learned the power of flexbox we will apply it to the sites we
are building. We'll also go back to a past assignment and see how flexbox would
simplify our HTML and CSS.

Objectives

• Build on your knowledge of HTML & CSS
• Use flexbox techniques layout pages.
• Implement, from scratch, a given design
• Understand HTML/CSS Layout
• Be able to place elements on a page where you want them.

Requirements

Explorer Mode

• Recommended: Go through the Flexbox Froggy and Grid Garden resources at the end of this homework.
• Recreate the page 'The Daily Kitteh' using flexbox and grids as closely as you possibly can. Use similar fonts, sizes, and colors. Feel free to use any cat photo you wish, just respect the relative size of the photo.
  • 

Adventure Mode

• Recreate the page Flexbox Article Layout as closely as possible. Feel free to use flexbox, or grids, or both if needed. Here a link to the HTML
  

Additional Resources

• CSS-Tricks guide to
  flexbox
• CSS-Tricks guide to
  grids
• http://www.evolutionoftheweb.com

Recommended Practice:

• https://flexboxfroggy.com/
• https://http://cssgridgarden.com/
• https://mastery.games/p/flexbox-zombies

In this project, you will practice accessing an API. You'll see how an API request is made from code, and see how data is returned from an API.

Objectives

• Demonstrate usage of APIs
• Understand how an API request is sent.
• Understand the request and response for an API.

Explorer Mode

• TOP TIP: Choose an API that has a simple, less nested API. Perhaps one that just returns an array of one-level-deep objects. This will make your task_significantly_ easier.
• Choose one of the APIs from this list that does not request "AUTH" (Authorization) since an API that requires authorization is a little more difficult to use when first learning. I have also selected some sample APIs that will be good choices:

• After choosing your API read the documentation.
• Create a new sdg-console application for accessing the API.
• Create a class to store information that comes back from your API.
• Write code to query the API and show results.
• If your API has more than one endpoint (URL) support a few options,
  perhaps by creating a menu system in your application.

Adventure Mode

Build a command line link shortening tool using this API: https://rel.ink/

Determine for yourself how you would like the tool to work, what the output
would look like, etc.

Epic Mode

Use the site Mockaroo to create a mock API. You may
need an account and then learn how their "Mock API" feature works.

Once you have created your Mock API for whatever schema you wish, implement a
client application to work with it.

Objectives

After completing this assignment, you should be able to:

• Demonstrate understanding of iteration/enumeration

Instructions

1. Fork this repository to your own account.
2. Change into your projects directory:
3. Clone your repository: hub clone js-iteration
4. Change into your project's directory: cd js-iteration
5. Install the dependencies: yarn install (or just yarn for short)
6. Open in your editor]
7. Start the test runner: yarn test
8. Open src/functions.test.js and work on functions until tests pass.
9. Commit and push your work to GitHub.
10. Turn in the URL to your GitHub repo.

Explorer Mode

• All tests passing

Epic Mode

• Using the forEach looping method and no other looping or enumeration helper, write your own version of the following methods, except name yours _map,
  _filter, etc.
  • map
  • filter
  • reduce
  • every
  • some
• Write some example usage of your new methods to demonstrate that they work

Additional Resources

Reference the documentation on DevDocs to find what kind of helpful functions
might already be in JavaScript.

• String Functions on DevDocs.
• Array Functions on DevDocs.

Practice is key to gaining the mileage needed to conquer programming. A very common practice problem is to recreate a working calculator. A basic calculator is a good exercise in using state, effects, and components to create a powerful and robust UI.

Objectives

• Practice using functional components with hooks
• Practice implementing a UI wire-frame

Requirements

Create a simple calculator that allows the user to add, multiply, subtract, and divide two numbers. Here is a sample UI:

Notes

• Take this in small steps just like we did in class. Start with the HTML, then CSS, then with basic functionality.

Explorer Mode

• Implement something similar to the example UI using HTML and CSS inside a React app
• As a user, I should be able to add two numbers
• As a user, I should be able to add subtract numbers
• As a user, I should be able to add multiple numbers
• As a user, I should be able to add divide numbers
• The clear button should reset the current calculation

Adventure Mode

• Show the user their history in a list
• Be able to chain together results. For example, the user should be able to input 2 + 3 - 4 + 5 and get the correct answer
• Let the user use their keyboard in addition to the mouse

Epic Mode

• Using your systems calculator app as inspiration, implement as many features as you can, including, but not limited to scientific mode, exponents, and the order of operations.

Complete your capstone project.

Learning programming takes practice and the best practice is repetition. This
exercise will allow you time to work on the basics of .NET and how to apply that
logic to solving problems.

Objectives

After completing this assignment, you should be able to:

• Demonstrate understanding of iteration/enumeration

Instructions

1. Fork this repository to
   your own account.
2. Change into your projects directory:
3. Clone your repository:
   git clone https://github.com/YOUR_NAME_HERE/net-iteration
4. Change into your project's directory: cd net-iteration
5. Install the dependencies: dotnet restore
6. Open in your editor: code .
7. Start the test runner: dotnet watch test
8. Open Iterations.cs and work on functions until the test passes. Once you
   are done with a test you can move to the next one by removing the
   (Skip = "Remove to run test") from the Fact attribute. There are a total
   of 10 questions.
9. Commit and push your work to GitHub.
10. Turn in the URL to your GitHub repo.

Explorer Mode

• All tests passing
• No linter warnings
• Turn in the homework using the URL to your repository on GitHub.

Additional Resources

Reference the documentation to find what kind of helpful functions
might already be in C#.

• String Functions.
• Official LINQ

In this project, you will use C# to model a deck of playing cards. You'll also add functionality such as shuffling and dealing.

Shuffling Cards

As we have seen, computers do exactly what we tell them to do. Thus, computers are bad at generating truly random numbers. Randomness is a deep and complex topic, but it's worth pointing out that most random numbers we use in computing are what we call "pseudorandom". That is, they generate numbers that appear to be random such that guessing the next random number the computer's fixed algorithm is going to generate is very difficult. This makes it good enough for most purposes. For this assignment, you will read about, then implement, a popular algorithm that shuffles the order of a finite set using C#'s built-in Random.Next() function as a pseudorandom number generator.

Objectives

• Demonstrate usage of arrays to model resources.
• Understand and implement algorithms.
• Understand loops.

Requirements

• Your deck should contain 52 unique cards.
• All cards should be represented as as string such as "Ace of Hearts"
• There are four suits: "Clubs", "Diamonds", "Hearts", and "Spades".
• There are 13 ranks: "Ace", "2", "3", "4", "5", "6", "7", "8", "9", "10",
  "Jack", "Queen", and "King".

You will model these in code, in any way you see fit. It may require you to experiment and try several techniques. There are many valid solutions.

NOTE: The more you plan this out (focus on the algorithm) the better you will do.

To shuffle the cards, you should implement the Fisher–Yates shuffle algorithm. The shuffling algorithm starts with the last element in our collection (in our case a deck of cards) and swaps it with a randomly selected element that comes before it. This continues downward through the elements towards the first element. Watch the first few minutes of this video for a visual description of the algorithm.

If we were going to write an algorithm for this we would write something like:

make n = 52 since we are dealing with 52 elements

for firstIndex from n - 1 down to 1 do:
  secondIndex = random integer that is greater than or equal to 0 and LESS than firstIndex

  Now swap the values at firstIndex and secondIndex by doing this:
    firstValue = the value from items[firstIndex]
    secondValue = the value from items[secondIndex]
    items[firstIndex] = secondValue
    items[secondIndex] = firstValue

hint: understand the algorithm before you try to implement it.

Explorer Mode

• Once the program starts, you should create a new deck.
• After deck creation, you should shuffle the deck.
• After the deck is shuffled, display the top two cards.

Adventure Mode

• In addition to displaying the top two cards, also store these two "dealt" cards in a variable named playerHand. Consider what type of variable playerHand will have to be.
• Implement a way to deal cards into two different hands.

Epic Mode

• Implement the game of War

Resources

• List

For this assignment, you will be creating your own personal bank account manager. You will be creating an app that will let you track both a savings account and a checking account total by performing transactions, such as withdrawals, deposits, and transfers. The application will also save your information in a file so you can track your account totals over time.

Objectives

• Practice control structures.
• Practice data structures.
• Practice working with user data.
• Practice with LINQ.
• Practice with OOP concepts.
• Practice working with files.

Requirements

Create a console app that allows a user to manage a banking account.

As user should be able to make transactions against their accounts.

The transaction information should be stored in a file, using a CSV(or JSON) format to record the data.

Balances will be computed by determining the cumulative effect of all the transactions in order. For instance, if a user deposits 10 to their savings account and then withdraws 8 from their savings account, their balance is computed as 2.

Explorer Mode

• The app should load past transactions from a file at start up.
• As a user I should be able to see the balances in my saving and checking account when the program first starts.
• Never allow withdrawing or depositing more money than allowed. That is, we cannot allow our accounts to go negative.
• When prompting for an amount to deposit or withdraw always ensure the amount is positive.
• As a user I should be able to deposit funds to my savings account.
• As a user I should be able to deposit funds to my checking account.
• As a user I should be able to withdraw funds from my savings account.
• As a user I should be able to withdraw funds from my checking account.
• As a user I should be able to see my account balances.
• The app should, after each transaction, write all the transactions to a file using a standard format.

Adventure Mode

• Add the ability to transfer funds from my checking account to my savings account.
• Add the ability to transfer funds from my savings account to my checking accounts.
• Add the ability to have multiple users. There are many steps to take here, so take the time to plan out the changes needed. This includes changes to the interface as well as changes to how you store the data.

Epic Mode

• Add simple password protection to your user's accounts

Additional Resources

• .NET

  • .NET Documentation

  • CsvHelper

A good way to practice the concepts of creating full-stack web applications is to duplicate an existing site. For this project, you will be creating a copy of a site that you know very well, StackOverflow.

Objectives

• Create a full-stack web app, from the database to the API, to the styled and responsive frontend.

Requirements

Create an anonymous question and answer site that allows users to up-vote and down-vote questions and answers.

Here are the user stories for this application:

• As a user I should be able to view and search previously asked questions.
• As a user I should be able to view a specific question and all of its answers.
• As a user I should be able to anonymously post a question.
• As a user I should be able to answer an existing question.
• As a user I should be able to upvote or downvote a question.
• As a user I should be able to upvote or downvote an answer.

Day 1

Explorer Mode

You have a choice to create a custom design or to start with existing HTML and CSS we provide.

• If you are going to create a custom design:
  • Create wireframes for your app.
• Create an ERD for the core functionality.
• Generate your dotnet new project.
• If you are going to create a custom design:
• Create the static HTML and CSS for all the pages the app will need.
• If you are going to use our starter files:
• Update the design or layout to fit your needs. Practice some HTML and CSS.
• Create React components for each page
• Setup React Router to render these, but still just static representations

Day 2

• Generate your database migrations based on your ERD.
• Insert sample questions, and corresponding answers into your database.
• Create the API for generating the list of questions to show on the home page.
• Create the API for posting a new question.

Day 3

• Create the API for fetching a single question along with its answers.
• Create the API for posting a new question.

In this project, you are creating a playable game of
Blackjack. If you haven't played this
game ever, or in a while, grab a deck of cards and play a few games.

Objectives

• Practice the skills and ideas you have learned so far.
• Effectively use loops, conditionals, and other control structures to implement
  control flows
• Demonstrate usage of data structures to model resources.

Requirements

Create a single-player blackjack game that plays against the house, i.e., a
human player and computer dealer. You are free to create the user interface
however you want, but keep it simple for Explorer Mode.

Explorer Mode

General Rules:

• The game should be played with a standard deck of playing cards (52).

• The house should be dealt two cards, hidden from the player until the
  house reveals its hand.

• The player should be dealt two cards, visible to the player.

• The player should have a chance to hit (i.e. be dealt another card) until
  they decide to stop or they bust (i.e. their total is over 21). At which
  point they lose regardless of the dealer's hand.

• When the player stands, the house reveals its hand and hits (i.e. draw
  cards) until they have 17 or more.

• If dealer goes over 21 the dealer loses.

• The player should have two choices: "Hit" and "Stand."

• Consider Aces to be worth 11, never 1.

• The app should display the winner. For this mode, the winner is who is
  closer to a blackjack (21) without going over.

• There should be an option to play again; this should reset the hands and
  reshuffle the deck.

Adventure Mode

• Reveal one of the house's cards to the player when cards dealt.
• Consider aces be worth one or eleven.
• Allow the player to
  "Split".
• Improve the win requirements. From Wikipedia:

  Players win by not busting and having a total higher than the dealer, or not
  busting and having the dealer bust, or getting a blackjack without the
  dealer getting a blackjack. If the player and dealer have the same total
  (not counting blackjacks), this is called a "push," and the player typically
  does not win or lose money on that hand. Otherwise, the dealer wins.

Epic Mode

• Add a betting system that carries between rounds.
• Allow the player to "Double down" or "Surrender."
• Add more players.

Let's get started

Today, we are starting our journey into development. This journey has to start somewhere. For this assignment, you will be making a program that demonstrates some programming fundamentals.

Objectives

• Ensure your development environment is setup
• Practice creating variables
• Practice working with user input

Requirements

Make sure you have followed the setup instructions for your computer's operating system

Follow this guide to review how to create and run C# applications

All your code should place inside the static void Main(string args[])

Explorer Mode

• Create a new app that does the following.

  • Practice Creating Variables

    • Create a variable (use your best judgment for type) that stores the numberOfCupsOfCoffee that you drink every day.
    • Create a variable (use your best judgment for type) called fullName and set it equal to your full name.
    • Create a variable (use your best judgment for type) call today and set it equal to today's date.
    • Use Console.WriteLine and your variables, numberOfCupsOfCoffee, fullName, and today, to output all three on one line.

  • Practice Getting Input From the User

    • Ask the user for their name and store it in a variable named userName.
    • Print out a greeting to the user, using their name.

  • Practice Getting Different Types of Input From the User

    • Ask the user to input two numbers.
    • Get the numbers as strings using Console.ReadLine, store them in variables named firstNumberAsString and secondNumberAsString

  • Converting String Input Into Numbers

    • Convert each string above to a double using Double.parse. Save the first value in a variable named firstOperand and the second value in a variable named secondOperand.

  • Doing Math

    • Add the operand variables from above and save the results in a variable named sum.
    • Subtract the secondOperand variable from the firstOperand variable and save the results in a variable named difference.
    • Multiply the operand variables and save the results in a variable named product.
    • Divide the firstOperand by the secondOperand and save the results in a variable named quotient.
    • Find the remainder when one operand is divided by the other and save the results in a variable named remainder. See this page if you need to learn more about the modulo operator.
    • Use Console.WriteLine to present the user, in a meaningful way, each of the values for the sum, difference, quotient, product, and remainder variables. (e.g. perhaps one of your outputs is similar to If you add 4 and 5 you get 9 if 4 and 5 were the input)

Adventure Mode

• Using Logic
  • Add some logic to your program that prints a different, special, greeting to the user if their name happens to be Alice.
• Using Advanced Types
  • Use the type DateTime to represent the data variables.

Epic Mode

• Move all of your code to separate file and invoke it from the Main method.

Additional Resources

• Types and variables

Reading Material

• Microsoft intro to C#