Assignment 1 - Currency

CS 1110 Spring 2019

Due to CMS by Thursday, February 14, 2019 @ 11:59pm

---

Overview

Thinking about going overseas? If you can swing it, it is best to go when the exchange rate is in your favor. When your dollars buy more in the foreign currency, you can do more on your vacation. It would be nice to have a tool that, given your current amount of cash in US dollars, tells you how much your money is worth in another currency.

Becuase the value of one currency with respect to another is constantly changing, there is no set mathematical formula to compute currency conversion. In fact, in the time that it takes you to read this paragraph, the exchange rate between the dollar and the Euro has probably changed several times. How can we write a program to perform this task?

One solution is to make use of a web service. A web service is a program that, when you send it web requests, automatically generates a web page with the information that you asked for. In our case, the web service will tell us the current exchange rate for most of the major international currencies. Your job will be to use string-manipulation methods to read the web page and extract the exact information we need. Full instructions are included below.

Table of Contents

• Before You Get Started
• Academic Integrity
• Partner Policy
• The Currency Exchange Web Service
• Part 1: The Assignment Files
• Part 2: The Core Functions
• Part A: Breaking up Strings
• Part B: Processing a JSON String
• Part C: Contacting the Server
• Part D: Computing the Exchange
• Part 3: The Application Script
• Finishing the Assignment
• Appendix: Connecting to Rate-Exchange Service

Before You Get Started

Academic Integrity

With the exception of your CMS-registered partner, we ask that you do not look at anyone else's code, seek solutions online or from students of past offerings of this course, or show your code to anyone else (except a CS1110 staff member) in any form whatsoever. This is in keeping with the the Academic Integrity Policy for CS 1110. It is okay to post error messages on Piazza, but not code. If we need to see your code, we will do that in person.

Partner Policy

You may do this assignment with one other person. Form your group on CMS as soon as possible. This can only be done after the assignment is released on CMS, but it must be completed before you submit the assignment. Both people must do something to form the group. The first person proposes, and then the other accepts. CMS does not allow you to form groups once grades are released. Once you have grouped on CMS, only one person needs to submit the files.

If you do this assignment with a partner, you must work together. It is against the rules for one person to do some programming on this assignment without the other person sitting nearby and helping. Furthermore, this assignment is not designed for you to split the work cleanly between partners. Sit together and take turns "driving" (using the keyboard and mouse) and "navigating" (guiding the code that's being typed, spotting errors, keeping track of what's done and what's still on your todo list).

---

Assignment Instructions

These instructions are long because we have tried to give you all the information you need in one document. The meat of the instructions are Parts 1, 2, and 3. Those cover exactly what code we want you to write. You should read everything, since the other parts explain why and how we are asking you to do these things.

Before you write any code at all, read the instructions in their entirety. This will greatly increase your chances of completing the assignment quickly. Many requests for resubmission are caused not by issues with programming but simply by not following instructions.

Assignment Scope

Everything that you need to complete this assignment should have been covered by Lecture 6 (Specifications and Testing) in class. In particular, you may not use if-statements anywhere in this assignment, as they are not necessary. Submissions containing if-statements will be returned for you to revise. Similarly, do not use loops or recursion.

Start early and make sure you're online. The program you are writing contacts a web service. This means that you'll need to be online in order to test your assignment. Also, hundreds of students trying to contact the same web service at once will slow everybody down. Connecting to, and reading from, a web page is not instantaneous. It will take several seconds for some of the functions you will write to complete their calculations. If everyone waits until the last minute to test this assignment, the server is going to be frustratingly slow.

Development Environment

To do this assignment, Python must be set up properly. If you have not already done this, follow the installation instructions to set it up on your computer. Alternatively, you can just work in the ACCEL lab.

You should also create a folder on your hard drive that is dedicated to this assignment and this assignment only. Every time that you work on a new assignment, we want you to make a new folder, to keep things organized and avoid problems with naming collisions. Make sure that the command shell and Atom Editor are both open in the current folder before you start.

Assignment Help

If you do not know where to start, if you do not understand testing, or if you are completely lost, please see someone immediately. This can be the course instructor, a TA, or a consultant. Do not wait until the last minute, particularly since this is due on Valentine's Day. A little in-person help can do wonders. See the staff page for more information.

---

The Currency Exchange Web Service

Before you do anything at all, you might want to play around with the currency exchange web service. You do not need any Python to do this; just a web browser.

For this assignment, you will use a simulated currency exchange service that never changes values. This is important for testing; if the answer is always changing, it is hard to test that you are getting the right answers. The appendix explains how you can make a few minor changes to get real-time currency-exchange results. However, we do not want you to submit such code for your assignment; stick with the fixed, unchanging server.

To use the service, you employ special URLs that start with the following prefix: http://cs1110.cs.cornell.edu/2019sp/a1server.php?
This prefix is followed by a currency query. A currency query has three pieces of information in the following format (without spaces; we have included spaces here solely for readability):

from=source & to=target & amount=amount

where source is a three-letter code for the original currency, target is a three-letter code for the new currency and amount is a float value for the amount of money in the original. For example, if you want to know the value of 2.5 dollars (USD) in Euros (EUR), the query is

from=USD&to=EUR&amount=2.5

The query is not enough by itself. To use it, you have to make it part of a web page URL. The full URL for this query is

http://cs1110.cs.cornell.edu/2019sp/a1server.php?from=USD&to=EUR&amount=2.5

Click on the link to see it in action.

You will note that the "web page" in your browser is just a single line in the following format:

{ "valid" : true, "from" : "2.5 United States Dollars", "to" : "2.1589225 Euros", "error" : "" }

This is what is known as a JSON representation of the answer. JSON is a way of encoding complex data so that it can be sent over the Internet. You will use what you know about string operations and methods to pull out the relevant data out of the JSON string.

You should try a few more currency queries to familiarize yourself with the service. Note that if you enter an invalid query (for example, using a non-existent currency code like "AAA"), you will get the following response in error:

{ "valid" : false, "from" : "", "to" : "", "error" : "Source currency code is invalid." }

Similarly, if you enter a query with two valid currency codes, but with an invalid quantity value, you will get the following error:

{ "valid" : false, "from" : "", "to" : "", "error" : "Currency amount is invalid." }

For all error queries, the "from" and "to" values are blank, while "valid" is false. The value "error" is a specific error message describing the problem. This will be important for error handling in this assignment.

Currency Application

Your primary goal in this assignment is to write an interactive application that queries the user for input and responds as follows:

[user@machine]:a1 > python a1app.py 
3-letter code for original currency: USD
3-letter code for the new currency: EUR
Amount of the original currency: 2.5
You can exchange 2.5 USD for 2.158923 EUR.

To create this application, you will create three files:

• a1.py: A modules with a collection of functions to perform the calculation.
• a1test.py: A unit test script verifying that a1.py is working correctly.
• a1app.py: The script to receive user input and provide an answer.

Of the three files, a1app.py will be the easiest. It will be no more complex that than scripts you wrote for lab. The vast majority of the work will be in the file a1.py. This file will contain a definition for following function:

def exchange(currency_from, currency_to, amount_from):
   """
   Returns: amount of currency received in the given exchange.
   
   In this exchange, the user is changing amount_from money in currency 
   currency_from to the currency currency_to. The value returned represents the 
   amount in currency currency_to.
   
   The value returned has type float.
   
   Parameter: currency_from -- the currency on hand (the LHS)
   Precondition: currency_from is a string for a valid currency code
   
   Parameter: currency_to -- the currency to convert to (the RHS)
   Precondition: currency_to is a string for a valid currency code
   
   Parameter: amount_from -- amount of currency to convert
   Precondition: amount_from is a float
   """

This function will involve several steps. You will get the JSON string from the web service, break up the string to pull out the numeric value (as a substring), and then convert that substring to a float. As this is the very first assignment, we are going to take you through this process step-by-step. However, not every function that we ask you to implement will be used by exchange.

This assignment might feel like you are working in reverse. You will write the functions to break up the string first, and the functions to interact with the web service last. This is because we want you to develop the following programming habit: always complete and test the helper functions before finishing the functions that use them.

Part 1: The Assignment Files

One of the most important outcomes of this assignment is that you understand the importance of testing. This assignment will follow an iterative development cycle. That means you will write a few functions, then fully test them before you write any more. This process makes it easier to find bugs; you know that any bugs must have been part of the work you did since the last test.

Iterative development requires that you work on each of the files simultaneously. In particular, you will write some code in a1test.py, move to a1.py and then back to a1test.py. Therefore, to get you started we want you to first create all three files. You are not going to put (much) code in the files right now. We just want you to have the files created so that you have a starting point to work from.

The very first thing you should do is specifically create a directory for this assignment. This folder should contain the three assignment files and nothing else.

The Module a1

In your newly created directory, you should create the module a1 (with file name a1.py). This will be the main module for this assignment. Following the style guidelines your file should start with a descriptive docstring, and the last two lines should be (1) the name and netid of the authors and (2) the date the file was last edited. This is the docstring that we would like you to use:

"""
Module for currency exchange

This module provides several string parsing functions to implement a 
simple currency exchange routine using an online currency service. 
The primary function in this module is exchange.

Author: YOUR NAME(S) AND NETID(S) HERE
Date:   THE DATE COMPLETED HERE
"""

Cut-and-paste this docstring into a1, making sure to insert your name and date as appropriate.

The Module a1test

Iterative development hinges on proper unit testing, which will be covered in class and lab. In the same folder as a1.py, create the file a1test.py. This will be the unit test script for the a1 module.

As with a1.py, this file should start with a docstring specification that includes (1) your name and netid and (2) the date the file was last editted. This is the docstring that we would like you to use:

"""
Unit test for module a1

When run as a script, this module invokes several procedures that 
test the various functions in the module a1.

Author: YOUR NAME(S) AND NETID(S) HERE
Date:   THE DATE COMPLETED HERE
"""

You will get experience writing your own docstrings in a later assignment. After this docstring, add the following two lines.

import introcs
import a1

Finally, add four procedure stubs to the file a1test.py: testA, testB, testC, and testD. Remember that a procedure stub should have the keyword pass (indented) after the header, but nothing else. For example, here is the code for the first one.

def testA():
    """
    Test procedure for Part A
    """
    pass

We will add our test cases to these procedures later.

These procedures will eventually contain your unit tests, which we introduce on slide 17 on the Lecture Notes on Testing.

Finally at the end of a1test, you will need to add code to active the test procedures. Add these lines:

testA()
testB()
testC()
testD()
print("Module a1 passed all tests")

Again, see the lecture slides for an explanation of why you are doing this. The script code will call your four test procedures, which are (currently) empty. If everything is working, then the module will print out the message

"Module a1 passed all tests"

Try this out.

The Script a1app.py

You will write the script a1app.py last. We do not want you to put any code in this file until a1.py is complete and fully tested. However, it is a good idea to have all three files in your directory, so you should create a file called a1app.py right now. When you create this file, add the following docstring:

"""
User interface for module currency

When run as a script, this module prompts the user for two currencies and amount.
It prints out the result of converting the first currency to the second.

Author: YOUR NAME(S) AND NETID(S) HERE
Date:   THE DATE COMPLETED HERE
"""

You can now ignore this file until Part 3 of the instructions.

---

Part 2: The Core Functions

Iterative Development

In this part of the assignment, you will work on the files a1.py and a1test.py. It is is broken into four parts (listed as Parts A, B, C, and D). In each part, you will do the following:

Write a function header into a1

We will give you the header to write. We will also give you a detailed docstring specification for the function. You should copy-and-paste the specification into the function body, indented.

Add test cases to a1test

Yes, this means you are writing tests before writing the function bodies. We talk about this in class.

Unless otherwise instructed, each test case should be a call to an assert function in the introcs module. Furthermore, your tests should be representative. While we talked about this in class, you might be a little unsure of what we are asking for here. If so, you might want to go over the lab on testing with a consultant before going any further.

Write the function bodies

Make sure that the function satisifies the specifications exactly. If the specification says to return something, you need a return statement. Make sure that the value returned is of the correct type.

Run the unit test a1test

If errors are found, fix them and re-test. Keep doing this until no more errors are found.

---

Function Specifications

The descriptions that we provide in each part below represent the level of completeness and precision we are looking for in your docstring comments. In fact, it is best to copy-and-paste these descriptions to create the first draft of your docstring comments. If you do not cut and paste, please adhere to the conventions we use, such as using a single line, followed by a blank line and a more descriptive paragraph, or by using "Returns: ..." for fruitful-functions. While we have provided the contents of the specification, we have not always formatted them properly for you.

If you want to see if your specifications are written correctly, enter the Python interactive shell and check them like this:

C:/> python            <-- type this from the command shell
>>> import a1          <-- now you're in the python interactive shell
>>> help(a1)

This should list all the functions with their specifications.

---

Part A: Breaking Up Strings

A large part of this assignment is breaking up a JSON string. Conceptually, you want to separate the currency amount from the currency name. For example, if we are given the string "0.863569 Euros", we want to break it up into "0.863569" and "Euros".

This is the motivation for the two functions below. The implementation of these functions should be relatively simple. We were able to implement them both in one or two lines.

before_space(s)
Returns: Substring of s; up to, but not including, the first space

Parameter: s -- the string to slice
Precondition: s has at least one space in it

after_space(s)
Returns: Substring of s after the first space

Parameter: s -- the string to slice
Precondition: s has at least one space in it

Implement these functions according to their specification, as described in the Iterative Development. In other words,

• Write the header and specification in a1.py
• Place test cases in the procedure testA() of a1test.py
• Implement the functions in a1.py.
• Test for and correct errors until no errors remain.

Testing

To test the functions, you should make use of assert_equals in the module introcs to compare the result of each functions with the string that you expect to get back. Our solution has four test cases for each of the two functions above. When you think about what test cases you want to include, consider the following:

• Does the specification allow for strings with more than one space?
• Does it allow for strings that start with a space?
• Does it allow for strings that don't have any spaces?

Keep in mind that the answer to any of the above questions might be No. In addition, do not forget to add a specification to testA(). Just because it is used for testing does not mean that it should not be properly specified.

---

Part B: Processing a JSON String

All of the responses to a currency query, whether valid or invalid, contain the keywords "from" and "to". If it is a valid currency query, then the answer is in quotes after the keyword "to". If it is invalid, then the quotes after "to" are empty. Hence the next step is to extract the information in quotes after these keywords.

While working on each of the functions below, remember to write the test cases in a1test.py before implementing the body. All test cases in this section go in the procedure testB(), which you should remember to specify. You should thoroughly test each function before implementing the next one.

first_inside_quotes(s)
Returns: The first substring of s between two (double) quote characters

A quote character is one that is inside a string, not one that delimits it.  We
typically use single quotes (') to delimit a string if want to use a double
quote character (") inside of it.

Example: If s is 'A "B C" D', this function returns 'B C'
Example: If s is 'A "B C" D "E F" G', this function still returns 'B C' because it only picks the first such substring.

Parameter: s -- a string to search
Precondition: s is a string with at least two (double) quote characters inside.

Completing the function above is part of a lab. Because this function is technically part of the lab, and not the assignment, you may talk to students other than your partner about it (collaboration is always allowed on labs). This is the only function for which this is allowed. The rest of the functions are part of the assignment, so you may only collaborate with your partner.

Once you have this function completed, you should move on to the following functions.

get_from(json)
Returns: The FROM value in the response to a currency query.

Given a JSON response to a currency query, this returns the string inside double quotes (") immediately following the keyword "from".  For example, if the JSON is
   '{ "valid" : true, "from" : "2 United States Dollars", "to" : "1.727138 Euros", "error" : "" }'
then this function returns '2 United States Dollars' (not '"2 United States Dollars"').  It returns the empty string if the JSON is the result of an invalid query.
Parameter: json -- a json string to parse
Precondition: json is the response to a currency query

get_to(json)
Returns: The TO value in the response to a currency query.

Given a JSON response to a currency query, this returns the string inside double quotes (") immediately following the keyword "to".  For example, if the JSON is
  '{ "valid" : true, "from" : "2 United States Dollars", "to" : "1.727138 Euros", "error" : "" }'
then this function returns '1.727138 Euros' (not '"1.727138 Euros"').  It returns the empty string if the JSON is the result of an invalid query.
Parameter: json -- a json string to parse
Precondition: json is the response to a currency query

has_error(json)
Returns: True if the query has an error; False otherwise.
Given a JSON response to a currency query, this returns the opposite
of the value following the keyword "valid".  For example, if the JSON is 
    '{ "valid" : false, "from" : "", "to" : "", "error" : "Source currency code is invalid." }'
then the query is not valid, so this function returns True (It does NOT return the message 'Source currency code is invalid').
Parameter: json -- a json string to parse
Precondition: json is the response to a currency query

Testing

As always, write your test cases before implementing the two functions. Look carefully at the specifications. You only need to test valid JSON queries. To get some JSON responses for testing, enter a query URL into the web service and copy the result into a test case.

You should not need a conditional statement to implement these functions; simply find the position of the appropriate keyword and extract the value in quotes immediately after it. Your implementation must make use of the find() or index() string methods, plus the helper function first_inside_quotes().

---

Part C: Contacting the Server

Now it is time to interact with the web service. In this part, you will implement a single function. The test cases for this function should go in procedure testC() in a1test.py. Do not forget to specify testC() properly.

currency_response(currency_from, currency_to, amount_from)
Returns: a JSON string that is a response to a currency query.
A currency query converts amount_from money in currency currency_from 
to the currency currency_to. The response should be a string of the form    
   '{ "valid" : true, "from" : "<old-amount>", "to" : "<new-amount>", "error" : "" }'
where the values old-amount and new-amount contain the value and name for the 
original and new currencies. If the query is invalid, both old-amount and 
new-amount will be empty, while "valid" will be followed by the value false.
Parameter: currency_from -- the currency on hand (the LHS)
Precondition: currency_from is a string with no spaces

Parameter: currency_to -- the currency to convert to (the RHS)
Precondition: currency_to is a string with no spaces

Parameter: amount_from -- amount of currency to convert
Precondition: amount_from is a float

While this function sounds complicated, it is not as bad as you think it is. There is a function inside of the introcs module called urlread. This function takes a single web address as an argument, and returns the contents of the web page. Try this now in the Python interactive shell by typing:

>>> import introcs
>>> introcs.urlread('http://www.cornell.edu')

You will notice that this function does exactly what you want. So what is the challenge? The challenge is coming up with the correct web address. Revisit our explanation of how the currency service works to see why this is a potential challenge.

Testing

You need to ensure that the function returns exactly the right JSON string for the value given. The best way to test this is to use a web browser to manually get the right JSON answer. For example, one test case can be constructed by seeing the result of going to the URL

http://cs1110.cs.cornell.edu/2019sp/a1server.php?from=USD&to=EUR&amount=2.5

Copy the value from this web page into a test case in testC(). Then check that the function returns the same JSON string. Remember to be thorough with your choice of test cases; one is not enough.

Important: Fetching a web page takes time, especially if too many people are trying to do so simultaneously. You should give each call to this function at least 5-10 seconds to complete before restarting any tests.

---

Part D: Computing the Exchange

We are now ready for the final part of the assignment. Implement the following specifications, again using our test-case-before-function-body approach. The test cases should go in procedure testD() in a1test, which you should properly specify. You may wish to use assert_true() instead of assert_equals() in some of your test cases. There is also a case in which you will want to use assert_floats_equal().

iscurrency(currency)
Returns: True if currency is a valid (3 letter code for a) currency. It returns False otherwise.

Parameter: currency -- the currency code to verify
Precondition: currency is a string with no spaces.

In implementing iscurrency(), you should not use the currency exchange table. That would make a very large function with a lot of if-statements. You are not allowed if-statements in this lab. Instead, you must use the functions currency_response and has_error as helper functions.

exchange(currency_from, currency_to, amount_from)
Returns: amount of currency received in the given exchange.
In this exchange, the user is changing amount_from money in currency currency_from to the currency currency_to. The value returned represents the amount in currency currency_to.
The value returned has type float.

Parameter: currency_from -- the currency on hand (the LHS)
Precondition: currency_from is a string for a valid currency code

Parameter: currency_to -- the currency to convert to (the RHS)
Precondition: currency_to is a string for a valid currency code

Parameter: amount_from -- amount of currency to convert
Precondition: amount_from is a float

Testing

In the case of iscurrency(), you will find the currency exchange table useful in determining correct answers for your test cases. While it is not okay to use the table in the body of iscurrency() itself, it is okay to use the table to to decide on some test cases.

You may also use the table to craft some test cases for the function exchange. However, you might find it easier to use a currency query URL to look up the correct answer, and then paste the answer into your test case.

A bigger issue with testing exchange is that problem that we saw in class: real numbers cannot be represented exactly. This creates problems when you try to test equality between floats. To solve this problem, introcs provides a function called assert_floats_equal(). You should use this function to test exchange() instead of assert_equals(). There is an example of this in the exercises of lab 3.

Finally, bear in mind that, like currency_response, these functions connect to the web service, and so are not instantaneous. In our solution, with complete test procedures for everything, it can take up to 2 seconds to run the unit test on campus. This will be a bit slower if you are working closer to the deadline.

---

Part 3: The Application Script

You are essentially done. The last part of the assignment is to complete the file a1app.py. This file will be no more complicated than the script dice.py that you made for lab 2. In fact, it will have a similar number of lines.

At the top of the file a1app.py remember to add the line

import a1

This will allow you to access the exchange function in this script. This is the only function of a1.py that you will need to use. Everything else will be either an input function, a print function, or some other built-in function, just as you did in the lab.

We are not going to give you much more guidance than that. Use your file dice.py as a guide if you are unsure what to do. In this end, the script should prompt the user and provide an answer, as shown below.

[user@machine]:a1 > python a1app.py 
3-letter code for original currency: USD
3-letter code for the new currency: EUR
Amount of the original currency: 2.5
You can exchange 2.5 USD for 2.158923 EUR.

Obviously you will get different answers for different currencies and amounts. But otherwise, the output displayed must look exactly like it does above. You must use those exact words for your final print statement and end with a period.

Finishing the Assignment

Once you have everything working you should go back and make sure that your program meets the class coding conventions, including the following:

• You have indented with spaces, not tabs (this is not an issue if using Atom Editor).
• Functions are each separated by two blank lines.
• Lines are short enough (~80 characters) that horizontal scrolling is not necessary.
• The specifications for all of the functions are complete.
• Function specifications are immediately after the function header and indented.
• Your name(s) and netid(s) are in the comments at the top of the modules.

One of the things that you may have the biggest difficulty with is breaking up long lines. First, you may not be aware when your lines are too long. If you are using Atom Editor, you should see a vertical line on the right side of the window. This is the wrap guide. If you go past this, you have gone too far; it is time to break up your lines.

As for breaking up long lines, there are two solutions. First, Python allows you to "hit Return" within any expression inside of parentheses. So if you are adding together several expressions together, like

  a = 'Hello ' + name + ', it is good to meet you'

you can break it up over several lines, using parentheses, as follows:

a = ('Hello ' + name +
    ', it is good to meet you')

Another solution is to use the backslash symbol \. Remember that this is the escape character for making special characters in strings. It also has a special effect outside of a string. If you type this symbol, immediately followed by a return, then Python will know to continue to the next line. So you can rewrite the addition above as

a = 'Hello ' + name + \
    ', it is good to meet you'

Turning it In

Upload the files a1.py, a1test.py, and a1app.py to CMS by the due date. Do not submit any files with the extension/suffix .pyc. It will help to set the preferences in your operating system so that extensions always appear.

Grading Policy (Revise-and-Resubmit Cycle)

In grading your code, we will focus on the following issues in order:

• Correct function specifications and/or formatting
• Adequate test cases
• Correctness of the code (does it pass our test cases?)

Formatting is graded according to the course style guidelines, available on the course web page.

We want everyone to master this assignment and get a perfect score of 10. To accomplish this, we use an iterative feedback process. If one of the objectives above is not properly met, we will give you feedback and the opportunity to revise and resubmit. We stop checking once we find the first few errors, so you should not assume that the errors we point out are the only errors present.

Check CMS daily until you get feedback from a grader. Make sure your CMS notifications for CS 1110 are set so that you are sent an email when one of your grades is changed. To find the feedback, click on the Assignment 1 link in CMS. On the page you are brought to, click on the red word "show" in the line "Grading Comments & Requests (show)." You can contact your grader if you have questions about their feedback; you can see their netid in the place you can see their feedback.

Within 24 hours, do the 4Rs: Read the feedback, Revise your program accordingly, Resubmit, and Request a Regrade using CMS. If you do not request a regrade, we have no simple way of knowing that you have resubmitted.

Until your code meets all of the above objectives and your assignment is considered completed (earning 10/10), your "grade" on CMS will be the number of revisions so far. This allows us to keep track of your progress. Do not be alarmed if you see a "1" for the assignment at first!

The resubmission cycle continues until you receive a perfect score of 10 or until Thursday, February 21st at 11:59PM, whichever comes first. In our experience, almost everyone is able to achieve a perfect score within two submissions.

Survey

In addition to turning in the assignment, we ask that you complete a feedback survey, which will be posted on Canvas on Feburary 9. We would like to know how long you spent on the assignment, your impression of the difficulty, and what could be done to improve it. Please complete the survey within a day of turning in the assignment. Remember that participation in surveys compromise 1% of your final grade. Your honest feedback is very helpful to us.

---