diff --git a/Assignments/Assignment-1/README.md b/Assignments/Assignment-1/README.md
new file mode 100644
index 0000000..719f6c2
--- /dev/null
+++ b/Assignments/Assignment-1/README.md
@@ -0,0 +1,281 @@
+# Assignment 1: Sockets, Mininet, & Performance
+
+### Due: Sep 22, 2021, 11:59 PM
+
+## Overview
+
+`iPerf` is a common tool used to measure network bandwidth. You will write your own version of this tool in C/C++ using sockets. You will then use your tools to measure the performance of virtual networks in Mininet and explain how link characteristics and multiplexing impact performance.
+
+* [Part 1](#part1): Write `iPerfer`
+* [Part 2](#part2): Mininet Tutorial
+* [Part 3](#part3): Measurements in Mininet
+* [Part 4](#part4): Create a Custom Topology
+* [Submission Instructions](#submission-instr)
+* [Autograder](#autograder)
+
+Before you start doing anything with this project, however, please [register your github username with us](https://docs.google.com/forms/d/e/1FAIpQLSdYfoGeP9YbMOsxFrOWM03YXNRArSppqQ3RqNKIp0fFHgyKbQ/viewform?usp=sf_link) if you have not done so yet. This is so that we can create a private repository for you to store your code and answers for this project.
+
+## Learning Outcomes
+
+After completing this programming assignment, students should be able to:
+
+* Write applications that use sockets to transmit and receive data across a network
+* Explain how latency and throughput are impacted by link characteristics and multiplexing
+
+
+## Part 1: Write `iPerfer`
+
+For the first part of the assignment you will write your own version of `iPerf` to measure network bandwidth. Your tool, called `iPerfer`, will send and receive TCP packets between a pair of hosts using sockets.
+
+> **NOTE:** You may refer to [Beej's Guide to Network Programming Using Internet Sockets](https://beej.us/guide/bgnet/html/) for socket programming. Discussion sections will also review the some of the basics.
+
+When operating in client mode, `iPerfer` will send TCP packets to a specific host for a specified time window and track how much data was sent during that time frame; it will calculate and display the bandwidth based on how much data was sent in the elapsed time. When operating in server mode, `iPerfer` will receive TCP packets and track how much data was received during the lifetime of a connection; it will calculate and display the bandwidth based on how much data was received and how much time elapsed during the connection.
+
+### Server Mode
+
+To operate `iPerfer` in server mode, it should be invoked as follows:
+
+`./iPerfer -s -p `
+
+* `-s` indicates this is the `iPerfer` server which should consume data
+* `listen_port` is the port on which the host is waiting to consume data; the port should be in the range `1024 ≤ listen_port ≤ 65535`
+
+> For simplicity, you can assume these arguments will appear exactly in the order listed above.
+
+You can use the presence of the `-s` option to determine `iPerfer` should operate in server mode.
+
+If arguments are missing or extra arguments are provided, you should print the following and exit:
+
+`Error: missing or extra arguments`
+
+If the listen port argument is less than 1024 or greater than 65535, you should print the following and exit:
+
+`Error: port number must be in the range of [1024, 65535]`
+
+When running as a server, `iPerfer` must listen for TCP connections from a client and receive data as quickly as possible. It should then wait for some kind of message from the client indicating it is done sending data (we will call this a FIN message). The server should then send the client an acknowledgement to this FIN message. It is up to you to decide the format of these FIN and acknowledgement messages.
+
+Data should be read in chunks of 1000 bytes. Keep a running total of the number of bytes received.
+
+After the client has closed the connection, `iPerfer` server must print a one-line summary in the following format:
+
+`Received=X KB, Rate=Y Mbps`
+
+where X stands for the total number of bytes received (in kilobytes), and Y stands for the rate at which traffic could be read in megabits per second (Mbps).
+Note X should be an integer and Y should be a decimal with three digits after the decimal mark.
+
+For example:
+`Received=6543 KB, Rate=5.234 Mbps`
+
+The `iPerfer` server should shut down gracefully after it handles one connection from a client.
+
+> **Note:** Please use setsockopt to allow reuse of the port number, this will make your life easier for testing and will allow you to pass the autograder, which runs the `iPerfer` server with the same port number each time. <- We recognize this isn't ideal, and will be fixed in the future.
+
+### Client Mode
+
+To operate `iPerfer` in client mode, it should be invoked as follows:
+
+`./iPerfer -c -h -p -t `
+
+* `-c` indicates this is the `iPerfer` client which should generate data
+* `server_hostname` is the hostname or IP address of the `iPerfer` server which will consume data
+* `server_port` is the port on which the remote host is waiting to consume data; the port should be in the range 1024 ≤ `server_port` ≤ 65535
+* `time` is the duration in seconds for which data should be generated. We will only test this with an integer value (i.e feel free to use time.h)
+
+> For simplicity, you can assume these arguments will appear exactly in the order listed above.
+
+You can use the presence of the `-c` option to determine that `iPerfer` should operate in the client mode.
+
+If any arguments are missing or extra arguments are provided, you should print the following and exit:
+
+`Error: missing or extra arguments`
+
+If the server port argument is less than 1024 or greater than 65535, you should print the following and exit:
+
+`Error: port number must be in the range of [1024, 65535]`
+
+If the time argument ends up parsing to less than 0, you should print the following and exit:
+
+`Error: time argument must be greater than 0`
+
+If both the port and time argument are invalid, print only the port error message.
+
+When running as a client, `iPerfer` must establish a TCP connection with the server and send data as quickly as possible for `time` seconds. Data should be sent in chunks of 1000 bytes and the data should be all zeros. Keep a running total of the number of bytes sent. After the client finishes sending its data, it should send a FIN message and wait for an acknowledgement before exiting the program.
+
+`iPerfer` client must print a one-line summary in the following format:
+
+`Sent=X KB, Rate=Y Mbps`
+
+where X stands for the total number of bytes sent (in kilobytes), and Y stands for the rate at which traffic could be read in megabits per second (Mbps).
+Note X should be an integer and Y should be a decimal with three digits after the decimal mark.
+
+For example:
+`Sent=6543 KB, Rate=5.234 Mbps`
+
+You should assume 1 kilobyte (KB) = 1000 bytes (B) and 1 megabyte (MB) = 1000 KB. As always, 1 byte (B) = 8 bits (b).
+
+> **NOTE:** When calculating the rate, do not use the `time` argument, rather measure the time elapsed from when the client first starts sending data to when it receives its acknowledgement message.
+
+### Testing
+
+You can test `iPerfer` on any machines you have access to. However, be aware the certain ports may be blocked by firewalls on end hosts or in the network, so you may not be able to test your program on all hosts or in all networks.
+
+The primary mode for testing should be using Mininet. You should complete [Part 2](#part2) of this assignment before attempting that.
+
+You should receive the same number of bytes on the server as you sent from the client. However, the timing on the server may not perfectly match the timing on the client. Hence, the bandwidth reported by client and server may be slightly different.
+
+The autograder will be released about halfway through the assignment. Instructions for submission are [here](#submission-instr). It is not meant to be your primary source of testing/debugging, but is rather intended for you to see your overall progress.
+
+
+## Part 2: Mininet Tutorial
+
+To test `iPerfer`, you will learn how to use Mininet to create virtual networks and run simple experiments. According to the [Mininet website](http://mininet.org/), *Mininet creates a realistic virtual network, running real kernel, switch and application code, on a single machine (VM or native), in seconds, with a single command.* We will use Mininet in programming assignments throughout the semester.
+
+### Running Mininet
+
+It is best advised to run Mininet in a virtual machine (VM). We will be using [VirtualBox](https://www.virtualbox.org/), which is a free and open-source hypervisor. Please download and install the latest version of VirtualBox.
+
+You will be using our VM image ([link here](https://www.dropbox.com/s/r5mi9bv4iqjsn3o/EECS489VM-A1-1804-v3.ova?dl=0)) with Mininet 2.3 pre-installed. Please download and import the VM image into VirtualBox. To transfer files to/from your VM you can use the Shared Folder feature provided in VirtualBox. We will go over this in more detail in discussion.
+
+You are welcome to try to set up your own testing environment using the methods outlined in options 2 and 3 [here](http://mininet.org/download/#option-2-native-installation-from-source), however we will only officially be supporting the provided VM above.
+
+### Mininet Walkthrough
+
+Once you have a Mininet VM, you should complete the following sections of the standard [Mininet walkthrough](http://mininet.org/walkthrough/):
+
+* All of Part 1, except the section "Start Wireshark"
+* The first four sections of Part 2—"Run a Regression Test", "Changing Topology Size and Type", "Link variations", and "Adjustable Verbosity"
+* All of Part 3
+
+At some points, the walkthrough will talk about software-defined networking (SDN) and OpenFlow. We will discuss these during the second half of the semester, so you do not need to understand what they mean right now; you just need to know how to run and interact with Mininet. We will review using mininet in discussion as well.
+
+> You do not need to submit anything for this part of the assignment.
+
+
+## Part 3: Measurements in Mininet
+
+For the third part of the assignment you will use the tool you wrote (`iPerfer`) and the standard latency measurement tool `ping` (`ping` measures RTT), to measure the bandwidth and latency in a virtual network in Mininet. You must include the output from some of your experiments and the answers to the questions below in your submission. Your answers to the questions should be put in the file `answers.txt` **that we provide**. Please do **NOT** change the format of the `answers.txt` file (none of the answers to the questions should take more than one or two sentences).
+
+Read the `ping` man page to learn how to use it.
+
+A python script to run Mininet with the topology described below is provided [here](https://github.com/mosharaf/eecs489/tree/f21/Assignments/Assignment-1/starter_code) along with other files that you will find useful in completing this assignment.
+
+To run Mininet with the provided topology, run the Python script `assignment1_topology.py` using sudo:
+
+`sudo python assignment1_topology.py`
+
+This will create a network with the following topology:
+
+
+
+If you have trouble launching the script, a common fix is to first try running `sudo mn -c`, and then try launching the script again.
+
+Hosts (`h1` to `h10`) are represented by squares and switches (`s1` to `s6`) are represented by circles; the names in the diagram match the names of hosts and switches in Mininet. The hosts are assigned IP addresses 10.0.0.1 through 10.0.0.10; the last number in the IP address matches the host number.
+
+> **NOTE:** When running ping and `iPerfer` in Mininet, you must use IP addresses, not hostnames. Also, if you are not confident your `iPerfer` is working correctly, feel free to use `iperf` for any throughput measurements noted below. Output using either program will be accepted.
+
+#### Q1: Link Latency and Throughput
+First, you should measure the RTT and bandwidth of each of the five individual links between switches (`L1` - `L5`). You should run ping with 20 packets and store the output of the measurement on each link in a file called `latency_L#.txt`, replacing # with the link number from the topology diagram above. You should run `iPerfer` for 20 seconds and store the output of the measurement on each link in a file called `throughput_L#.txt`, replacing # with the link number from the topology diagram above.
+
+#### Q2: Path Latency and Throughput
+Now, assume `h1` wants to communicate with `h10`. What is the expected latency and throughput of the path between the hosts? Put your prediction in the `answers.txt` file under question 2.
+
+Measure the latency and throughput between `h1` and `h10` using `ping` and `iPerfer`. It does not matter which host is the client and which is the server. Use the same parameters as above (20 packets / 20 seconds) and store the output in files called `latency_Q2.txt` and `throughput_Q2.txt`. Put the average RTT and measured throughput in the `answers.txt` file and explain the results. If your prediction was wrong, explain why.
+
+#### Q3: Effects of Multiplexing
+Next, assume multiple hosts connected to `s1` want to simultaneously talk to hosts connected to `s6`. What is the expected latency and throughput when two pairs of hosts are communicating simultaneously? Put your predictions in your `answers.txt` file under question 3.1.
+
+Use `ping` and `iPerfer` to measure the latency and throughput when there are two pairs of hosts communicating simultaneously; it does not matter which pairs of hosts are communicating as long as one is connected to `s1` and one is connected to `s6`. Use the same parameters as above. You do not need to submit the raw output, but you should put the average RTT and measured throughput for each pair in your `answers.txt` file under question 3.1 and explain the results. If your prediction was wrong, explain why.
+
+Repeat for three pairs of hosts communicating simultaneously and put your answers in `answers.txt` under question 3.2.
+
+Do not worry too much about starting the clients at the exact same time. So long as the connections overlap significantly, you should achieve the correct results. One simple way is to open up terminals for each of the hosts you will use, start the iPerfer servers, type in the iPerfer client command on each of the client hosts without hitting ENTER, and then quickly hit ENTER on all client hosts so that they start at roughly the same time.
+
+#### Q4: Effects of Latency
+Lastly, assume `h1` wants to communicate with `h10` at the same time `h3` wants to communicate with `h8`. What is the expected latency and throughput for each pair? Put your prediction in your `answers.txt` file under question 4.
+
+Use `ping` and `iPerfer` to conduct measurements, storing the output in files called `latency_h1-h10.txt`, `latency_h3-h8.txt`, `throughput_h1-h10.txt`, and `throughput_h3-h8.txt`. Put the average RTT and measured throughput in your `answers.txt` file and explain the results. If your prediction was wrong, explain why.
+
+
+## Part 4: Create a Custom Topology
+For the last part of this assignment, write a python script to create a custom network topology in Mininet that has at least 5 hosts and 5 switches. Save your python script as `_topology.py`. You might find looking into the source code for `assignment1_topology.py` particularly helpful.
+
+Finally, create a visualization of your custom topology (using circles to denote switches and squares to represent hosts) and save it as `_topology.png`.
+
+
+## Submission Instructions
+Submission to the autograder will be done [here](https://eecs489.eecs.umich.edu/). It will be released about halfway through the assignment.
+
+To submit:
+1. `git push` your work to the github repository we provided for the assignment.
+2. Go to autograder website specified above. You can specify what branch on your repository you want us to grade.
+3. Press submit. We will email your results once the autograder is finished.
+
+Your assigned repository must contain:
+
+* The source code for `iPerfer`: all source files for `iPerfer` should be in a folder called `iPerfer`; the folder should include a `Makefile` to compile the sources. The autograder expects an `iPerfer` executable to be present after running `make` in this directory. The autograder will run `make clean` then `make` (must support both), if either do not work the submission will fail.
+* Your measurement results and answers to the questions from Part 3: all results and a text file called `answers.txt` should be in a folder called `measurements`.
+* Your custom network topology code and its visualization (`_topology.py` and `_topology.png`).
+
+Example final structure of repository:
+```
+$ tree ./p1-joebb/
+./p1-joebb/
+├── README.md
+├── assignment1_topology.png
+├── assignment1_topology.py
+├── iPerfer
+│ ├── ** source files **
+│ ├── Makefile <- supports "make clean" and "make"
+│ └── iPerfer <- executable from running make
+├── joebb_topology.png
+├── joebb_topology.py
+└── measurements
+ ├── answers.txt
+ ├── latency_L1.txt
+ ├── latency_L2.txt
+ ├── latency_L3.txt
+ ├── latency_L4.txt
+ ├── latency_L5.txt
+ ├── latency_Q2.txt
+ ├── latency_h1-h10.txt
+ ├── latency_h3-h8.txt
+ ├── throughput_L1.txt
+ ├── throughput_L2.txt
+ ├── throughput_L3.txt
+ ├── throughput_L4.txt
+ ├── throughput_L5.txt
+ ├── throughput_Q2.txt
+ ├── throughput_h3-h8.txt
+ └── throughput_h1-h10.txt
+```
+
+
+When grading your assignment, we will **ONLY** pull from your assigned repository, and only look at commits before the deadline.
+
+
+## Autograder
+
+The autograder tests the following aspects of `iPerfer`
+1. Incorrect argument handling
+2. Format of your iPerfer output
+3. Correctness of iPerfer output (both the `Sent` and `Received` values as well as `Rate`).
+
+Because of the guarantees of TCP, both Sent and Received should be the same. The `Rate` is tested by first running `iperf` over a link, then comparing your `iPerfer` output to the result given a reasonable margin of error.
+
+Our autograder runs the following versions of gcc/g++, please make sure your code is compatible
+```
+$ gcc --version
+gcc (Ubuntu 7.4.0-1ubuntu1~18.04.1) 7.4.0
+Copyright (C) 2017 Free Software Foundation, Inc.
+This is free software; see the source for copying conditions. There is NO
+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+$ g++ --version
+g++ (Ubuntu 7.4.0-1ubuntu1~18.04.1) 7.4.0
+Copyright (C) 2017 Free Software Foundation, Inc.
+This is free software; see the source for copying conditions. There is NO
+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+```
+
+## Acknowledgements
+This programming assignment is based on Aditya Akella's Assignment 1 from Wisconsin CS 640: Computer Networks.
diff --git a/Assignments/Assignment-1/assignment1_topology.png b/Assignments/Assignment-1/assignment1_topology.png
new file mode 100644
index 0000000..3444875
Binary files /dev/null and b/Assignments/Assignment-1/assignment1_topology.png differ
diff --git a/Assignments/Assignment-1/starter_code/281Makefile.txt b/Assignments/Assignment-1/starter_code/281Makefile.txt
new file mode 100644
index 0000000..0df5802
--- /dev/null
+++ b/Assignments/Assignment-1/starter_code/281Makefile.txt
@@ -0,0 +1,218 @@
+## EECS 281 Advanced Makefile
+
+# How to use this Makefile...
+###################
+###################
+## ##
+## $ make help ##
+## ##
+###################
+###################
+
+# IMPORTANT NOTES:
+# 1. Set EXECUTABLE to the command name given in the project specification.
+# 2. To enable automatic creation of unit test rules, your program logic
+# (where main() is) should be in a file named project*.cpp or specified
+# in the PROJECTFILE variable.
+# 3. Files you want to include in your final submission cannot match the
+# test*.cpp pattern.
+
+# Version 4 - 2015-05-03, Marcus M. Darden (mmdarden@umich.edu)
+# * Updated build rules for tests
+# Version 3.0.1 - 2015-01-22, Waleed Khan (wkhan@umich.edu)
+# * Added '$(EXECUTABLE): $(OBJECTS)' target. Now you can compile with
+# 'make executable', and re-linking isn't done unnecessarily.
+# Version 3 - 2015-01-16, Marcus M. Darden (mmdarden@umich.edu)
+# * Add help rule and message
+# * All customization locations are cleary marked.
+# Version 2 - 2014-11-02, Marcus M. Darden (mmdarden@umich.edu)
+# * Move customization section to the bottom of the file
+# * Add support for submit without test cases, to prevent submission
+# deduction while testing, when code fails to compile
+# usage: make partialsubmit <- includes no test case files
+# make fullsubmit <- includes all test case files
+# * Add automatic creation of test targets for test driver files
+# usage: (add cpp files to the project folder with a test prefix)
+# make alltests <- builds all test*.cpp
+# make test_insert <- builds testinsert from test_insert.cpp
+# make test2 <- builds testinsert from test2.cpp
+# * Add documentation and changelog
+# Version 1 - 2014-09-21, David Snider (sniderdj@umich.edu)
+# Vertion 0 - ????-??-??, Matt Diffenderfer (mjdiffy@umich.edu)
+
+# enables c++14 on CAEN
+PATH := /usr/um/gcc-5.1.0/bin:$(PATH)
+LD_LIBRARY_PATH := /usr/um/gcc-5.1.0/lib64
+LD_RUN_PATH := /usr/um/gcc-5.1.0/lib64
+
+# TODO
+# Change EXECUTABLE to match the command name given in the project spec.
+EXECUTABLE = MineEscape
+
+# designate which compiler to use
+CXX = g++
+
+# list of test drivers (with main()) for development
+TESTSOURCES = $(wildcard test*.cpp)
+# names of test executables
+TESTS = $(TESTSOURCES:%.cpp=%)
+
+# list of sources used in project
+SOURCES = $(wildcard *.cpp)
+SOURCES := $(filter-out $(TESTSOURCES), $(SOURCES))
+# list of objects used in project
+OBJECTS = $(SOURCES:%.cpp=%.o)
+
+# TODO
+# If main() is in a file named project*.cpp, use the following line
+PROJECTFILE = $(wildcard project*.cpp)
+# TODO
+# If main() is in another file delete the line above, edit and uncomment below
+#PROJECTFILE = mymainfile.cpp
+
+# name of the tar ball created for submission
+PARTIAL_SUBMITFILE = partialsubmit.tar.gz
+FULL_SUBMITFILE = fullsubmit.tar.gz
+
+#Default Flags
+CXXFLAGS = -std=c++14 -Wconversion -Wall -Werror -Wextra -pedantic
+
+# make release - will compile "all" with $(CXXFLAGS) and the -O3 flag
+# also defines NDEBUG so that asserts will not check
+release: CXXFLAGS += -O3 -DNDEBUG
+release: all
+
+# make debug - will compile "all" with $(CXXFLAGS) and the -g flag
+# also defines DEBUG so that "#ifdef DEBUG /*...*/ #endif" works
+debug: CXXFLAGS += -g3 -DDEBUG
+debug: clean all
+
+# make profile - will compile "all" with $(CXXFLAGS) and the -pg flag
+profile: CXXFLAGS += -pg
+profile: clean all
+
+# highest target; sews together all objects into executable
+all: $(EXECUTABLE)
+
+$(EXECUTABLE): $(OBJECTS)
+ifeq ($(EXECUTABLE), executable)
+ @echo Edit EXECUTABLE variable in Makefile.
+ @echo Using default a.out.
+ $(CXX) $(CXXFLAGS) $(OBJECTS)
+else
+ $(CXX) $(CXXFLAGS) $(OBJECTS) -o $(EXECUTABLE)
+endif
+
+# Automatically generate any build rules for test*.cpp files
+define make_tests
+ ifeq ($$(PROJECTFILE),)
+ @echo Edit PROJECTFILE variable to .cpp file with main\(\)
+ @exit 1
+ endif
+ SRCS = $$(filter-out $$(PROJECTFILE), $$(SOURCES))
+ OBJS = $$(SRCS:%.cpp=%.o)
+ HDRS = $$(wildcard *.h)
+ $(1): CXXFLAGS += -g3 -DDEBUG
+ $(1): $$(OBJS) $$(HDRS) $(1).cpp
+ $$(CXX) $$(CXXFLAGS) $$(OBJS) $(1).cpp -o $(1)
+endef
+$(foreach test, $(TESTS), $(eval $(call make_tests, $(test))))
+
+alltests: clean $(TESTS)
+
+# rule for creating objects
+%.o: %.cpp
+ $(CXX) $(CXXFLAGS) -c $*.cpp
+
+# make clean - remove .o files, executables, tarball
+clean:
+ rm -f $(OBJECTS) $(EXECUTABLE) $(TESTS) $(PARTIAL_SUBMITFILE) $(FULL_SUBMITFILE)
+
+# make partialsubmit.tar.gz - cleans, runs dos2unix, creates tarball omitting test cases
+PARTIAL_SUBMITFILES=$(filter-out $(TESTSOURCES), $(wildcard Makefile *.h *.cpp))
+$(PARTIAL_SUBMITFILE): $(PARTIAL_SUBMITFILES)
+ rm -f $(PARTIAL_SUBMITFILE) $(FULL_SUBMITFILE)
+ -dos2unix $(PARTIAL_SUBMITFILES)
+ COPYFILE_DISABLE=true tar -vczf $(PARTIAL_SUBMITFILE) $(PARTIAL_SUBMITFILES)
+ @echo !!! WARNING: No test cases included. Use 'make fullsubmit' to include test cases. !!!
+
+# make fullsubmit.tar.gz - cleans, runs dos2unix, creates tarball including test cases
+FULL_SUBMITFILES=$(filter-out $(TESTSOURCES), $(wildcard Makefile *.h *.cpp test*.txt))
+$(FULL_SUBMITFILE): $(FULL_SUBMITFILES)
+ rm -f $(PARTIAL_SUBMITFILE) $(FULL_SUBMITFILE)
+ -dos2unix $(FULL_SUBMITFILES)
+ COPYFILE_DISABLE=true tar -vczf $(FULL_SUBMITFILE) $(FULL_SUBMITFILES)
+ @echo !!! Final submission prepared, test cases included... READY FOR GRADING !!!
+
+# shortcut for make submit tarballs
+partialsubmit: $(PARTIAL_SUBMITFILE)
+fullsubmit: $(FULL_SUBMITFILE)
+
+define MAKEFILE_HELP
+EECS281 Advanced Makefile Help
+* This Makefile uses advanced techniques, for more information:
+ $$ man make
+
+* General usage
+ 1. Follow directions at each "TODO" in this file.
+ a. Set EXECUTABLE equal to the name given in the project specification.
+ b. Set PROJECTFILE equal to the name of the source file with main()
+ c. Add any dependency rules specific to your files.
+ 2. Build, test, submit... repeat as necessary.
+
+* Preparing submissions
+ A) To build 'partialsubmit.tar.gz', a tarball without tests used to find
+ buggy solutions in the autograder. This is useful for faster autograder
+ runs during development and free submissions if the project does not
+ build.
+ $$ make partialsubmit
+ B) Build 'fullsubmit.tar.gz' a tarball complete with autograder test cases.
+ ALWAYS USE THIS FOR FINAL GRADING! It is also useful when trying to
+ find buggy solutions in the autograder.
+ $$ make fullsubmit
+
+* Unit testing support
+ A) Source files for unit testing should be named test*.cpp. Examples
+ include test_input.cpp or test3.cpp.
+ B) Automatic build rules are generated to support the following:
+ $$ make test_input
+ $$ make test3
+ $$ make alltests (this builds all test drivers)
+ C) If test drivers need special dependencies, they must be added manually.
+ D) IMPORTANT: NO SOURCE FILES THAT BEGIN WITH test WILL BE ADDED TO ANY
+ SUBMISSION TARBALLS.
+endef
+export MAKEFILE_HELP
+
+help:
+ @echo "$$MAKEFILE_HELP"
+
+#######################
+# TODO (begin) #
+#######################
+# individual dependencies for objects
+# Examples:
+# "Add a header file dependency"
+# project2.o: project2.cpp project2.h
+#
+# "Add multiple headers and a separate class"
+# HEADERS = some.h special.h header.h files.h
+# myclass.o: myclass.cpp myclass.h $(HEADERS)
+# project5.o: project5.cpp myclass.o $(HEADERS)
+#
+# ADD YOUR OWN DEPENDENCIES HERE
+
+# tests
+
+class.o: class.cpp class.h
+
+project0.o: project0.cpp class.h
+
+######################
+# TODO (end) #
+######################
+
+# these targets do not create any files
+.PHONY: all release debug profile clean alltests partialsubmit fullsubmit help
+# disable built-in rules
+.SUFFIXES:
diff --git a/Assignments/Assignment-1/starter_code/answers.txt b/Assignments/Assignment-1/starter_code/answers.txt
new file mode 100644
index 0000000..8e195fc
--- /dev/null
+++ b/Assignments/Assignment-1/starter_code/answers.txt
@@ -0,0 +1,23 @@
+2) Predicted throughput:
+ Predicted latency:
+ Actual throughput:
+ Actual latency:
+ Explanation of results:
+
+3.1) Predicted throughput:
+ Predicted latency:
+ Actual throughput:
+ Actual latency:
+ Explanation of results:
+
+3.2) Predicted throughput:
+ Predicted latency:
+ Actual throughput:
+ Actual latency:
+ Explanation of results:
+
+4) Predicted throughput:
+ Predicted latency:
+ Actual throughput:
+ Actual latency:
+ Explanation of results:
diff --git a/Assignments/Assignment-1/starter_code/assignment1_topology.py b/Assignments/Assignment-1/starter_code/assignment1_topology.py
new file mode 100755
index 0000000..2434b54
--- /dev/null
+++ b/Assignments/Assignment-1/starter_code/assignment1_topology.py
@@ -0,0 +1,61 @@
+#!/usr/bin/env python
+"""
+
+Measurement topology for EECS489, Winter 2017, Assignment 1
+"""
+
+from mininet.cli import CLI
+from mininet.net import Mininet
+from mininet.link import TCLink
+from mininet.topo import Topo
+from mininet.log import setLogLevel
+
+class AssignmentNetworks(Topo):
+ def __init__(self, **opts):
+ Topo.__init__(self, **opts)
+ h1 = self.addHost('h1')
+ h2 = self.addHost('h2')
+ h3 = self.addHost('h3')
+ h4 = self.addHost('h4')
+ h5 = self.addHost('h5')
+ h6 = self.addHost('h6')
+ h7 = self.addHost('h7')
+ h8 = self.addHost('h8')
+ h9 = self.addHost('h9')
+ h10 = self.addHost('h10')
+ s1 = self.addSwitch('s1')
+ s2 = self.addSwitch('s2')
+ s3 = self.addSwitch('s3')
+ s4 = self.addSwitch('s4')
+ s5 = self.addSwitch('s5')
+ s6 = self.addSwitch('s6')
+ self.addLink(h1, s1)
+ self.addLink(h2, s1)
+ self.addLink(h5, s1)
+ self.addLink(h3, s2)
+ self.addLink(h4, s3)
+ self.addLink(h7, s4)
+ self.addLink(h8, s5)
+ self.addLink(h6, s6)
+ self.addLink(h9, s6)
+ self.addLink(h10, s6)
+ self.addLink(s1, s2, bw=20, delay='40ms')
+ self.addLink(s2, s3, bw=40, delay='10ms')
+ self.addLink(s2, s4, bw=30, delay='30ms')
+ self.addLink(s3, s5, bw=25, delay='5ms')
+ self.addLink(s5, s6, bw=25, delay='5ms')
+
+
+if __name__ == '__main__':
+ setLogLevel( 'info' )
+
+ # Create data network
+ topo = AssignmentNetworks()
+ net = Mininet(topo=topo, link=TCLink, autoSetMacs=True,
+ autoStaticArp=True)
+
+ # Run network
+ net.start()
+ CLI( net )
+ net.stop()
+
diff --git a/README.md b/README.md
index 4d0b26d..087246e 100644
--- a/README.md
+++ b/README.md
@@ -12,7 +12,7 @@
| Member (uniqname) | Role | Office Hours |
| :---------------- | :--- | :----------- |
| [Mosharaf Chowdhury](http://www.mosharaf.com/) (mosharaf) | Faculty | [W: 2:00 PM - 2:50 PM](https://officehours.it.umich.edu/queue/421) and by appt.
-| Yinwei Dai | GSI | [F: 1:00 PM - 3:00 PM](https://officehours.it.umich.edu/queue/907)
+| Yinwei Dai | GSI | [F: 10:00 AM - 12:00 PM](https://officehours.it.umich.edu/queue/907)
| Jiaxing Yang | GSI | [T: 10:00 AM - 12:00 PM](https://officehours.it.umich.edu/queue/907)
### Piazza