• Specifications Grading
• Assignments
• Satisfactory/Unsatisfactory Rubric
• Submitting Assignments
• Late Submissions
• Using GitHub
• Working with Branches
• Grade Reporting
• Resubmissions
• Using External Sources

Specifications Grading

We use specifications grading in this course in an effort to motivate you to engage at whatever level you decide. Whether a “C+” is fine or you feel you must get an “A”, either is perfectly acceptable from our perspective, and we describe precisely what is required to get that grade—no more, no less. Here’s how it works:

1. You submit assignments and accrue tokens for each assignment.
2. You select which assignments to submit. A certain minimum set is required; how many additional assignments you complete beyond that minimum is up to you.
3. Completed assignments are graded on a Satisfactory/Unsatisfactory basis.
4. Satisfactory work accrues all tokens for the assignment; unsatisfactory work, none.
5. Your grade is determined by the total number of tokens you accrue, the number of satisfactory assignments completed at the “O” level and performance on quizzes.
6. The requirements for specific letter grades are defined below. This is good (I think!) because there is no “curving” of grades/dependency on your peers’ performance. Your final grade is determined by a "bundle" that combines your performance across all three areas. For example, a "B+" grade requires that you accrue at least 109 tokens, and that you receive and "Outstanding" grade in at least 2 assignments, and that you get a passing grade (50% or higher) in at least 3 quizzes.
   
   

   Letter Grade	Total Tokens	"Outstanding" Required Assignments	Quizzes
   A	125+	8+	Four quizzes at ≥50%
   A-	117+	6+	Three quizzes at ≥50%
   B+	109+	2+	Three quizzes at ≥50%
   B	105+	N/A	Two quizzes at ≥50%
   B-	97+	N/A	Two quizzes at ≥50%
   C+	88+	N/A	One quiz at ≥50%
   F	<88	N/A	N/A

7. Everyone starts out with 4 bonus tokens in their account—yay! These bonus tokens can be used to:
   
   • Request an extension to submit the assignment within 24 hours of the due date/time - cost: 2 tokens.
   • Re-do unsatisfactory (U) work on a required assignment (no re-submissions allowed on optional assignments) and request regrading - cost: 2 tokens.
   Unused bonus tokens are added to your account balance to determine the final grade.

Assignments

You must attempt all the assignments marked "Required" (with bold names). Quizzes are optional, but you must attempt and pass at least one for a passing final grade. Assignments are submitted via GitHub as described below.

A note on the workload in this class: Over the years, students have reported the amount of time they spent on each assignment; the average range of hours spent is shown in parentheses next to the assignment name. Your experience may be very different, but I want you to have some indication of what to expect going into this class so that you're not surprised later in the quarter (when it will likely be too late to make changes to your schedule). Pay particular attention to these numbers if you're taking multiple classes that have final projects due in the last couple of weeks of the quarter: the workload in this class also becomes heavier during that time, and some students have found it difficult to cope. We cannot help you if you take on more than you can handle, so be advised now!

* Dates may change depending on our progress in class. Notifications of any changes will be posted on Ed Discussion.

Satisfactory/Unsatisfactory Rubric

The rubric below will be used to determine whether your work is satisfactory or not. Work rated as “O” or “S” is satisfactory. Work rated as “U” is unsatisfactory.

Submitting Assignments

You are required to submit all assignments in this class via GitHub. A submission link to our GitHub classroom is provided in each assignment. You must follow the link to create your repository for each assignment. The first time you do this you will be prompted to link your GitHub account to your CNetID listed in the GitHub classroom roster. You must link your GitHub ID to the class roster, otherwise your assignments will not be graded.

The basic flow for using GitHub to submit assignments is described below—please ask on Ed if anything is unclear; do not wait until the last minute to tell us that you’re having GitHub issues and that your assignment will be late.

The due date and time is listed at the top of each assignment, e.g., Due: Saturday, May 4, 2024 at 5:30pm CDT.

We will treat the most recent commit timestamp displayed in GitHub as your submission time. In the case where an assignment specifies that you include a commit message (e.g., “A14 - Final Submission”), we will consider the most recent commit with that message as the submission time. Please make sure you understand this. You will receive a “U” if there are any changes to your code or commits after the deadline—please don’t modify the repository or any other part of your code in the AWS environment after the deadline.

Late Submissions

Late submissions will not be considered for grading. You may use two tokens to request a 24-hour extension. If you want an extension, you must notify us before the due date/time by posting a private note in Ed Discussion. Submissions beyond 24 hours post due date/time will accrue no tokens. Please don’t ask for exceptions.

Using GitHub

There are countless GitHub “quickstart” guides online (e.g. git—the simple guide ), but for our purposes you can just follow this process:

1. Create a remote repository on GitHub. For each homework submission, simply click on the “Submit” link that will be provided in the assignment document and follow the prompts. For example, if I were submitting A3, it would create a repo called a3-vasv.


2. Clone the repository to your laptop (or EC2 instance):
   

   $ git clone https://github.com/mpcs-cc/a3-vasv.git
   Cloning into 'a3-vasv...
   ...
   remote: Total 4 (delta 0), reused 3 (delta 0), pack-reused 0
   Unpacking objects: 100% (4/4), done.
                   



3. Add your homework file(s) to the working directory:
   

   $ cd a3-vasv
   $ touch a3.py
                   



4. When you're ready to commit your new file(s) to the GitHub repository, first add them to the staging area (there is no output from this command): git add .


5. Create a commit (with an appropriate comment):

$ git commit -m "My first A3 commit"
1 file changed, 58 insertions(+)
create mode 100644 a3.py
                



6. Push the local changes to the remote (GitHub) repository:

   $ git push origin main
   Enumerating objects: 7, done.
   Counting objects: 100% (7/7), done.
   Delta compression using up to 8 threads
   Compressing objects: 100% (4/4), done.
   Writing objects: 100% (6/6), 532 bytes | 532.00 KiB/s, done.
   Total 6 (delta 1), reused 0 (delta 0)
   remote: Resolving deltas: 100% (1/1), done.
   To https://github.com/mpcs-cc/a3-vasv.git
      1afd4fd..74fe452  main -> main
                   



7. Repeat the "add → commit → push" cycle every time you want to update the remote repository.

Working with Branches

Since you’re the only one working in your repository you can make and commit all changes directly into the main (default) branch. However, when the work becomes a bit more complex during the capstone project, you will need to use branches to avoid breaking any working code.

Let’s say your main branch contains code from past assignments, and you have one last assignment to complete. You can create a branch and work on the assignment in that branch:

$ git checkout -b 'a20'
Switched to a new branch 'a20'
              

Now make all your changes. Once you have it working, commit updated code as before:

$ git add .
$ git commit -m "Finished the CAPSTONE!!"
[a20 8deb085] Finished the CAPSTONE!!
 1 file changed, 1 insertion(+), 1 deletion(-)
              

Then, merge the a20 branch back into main:

$ git checkout main
Switched to branch 'main'
Your branch is up to date with 'origin/main'.
$ git merge a20
Updating 74fe452..8deb085
Fast-forward
... | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
              

And, finally, push main to the remote (GitHub) repo:

$ git push
Enumerating objects: 5, done.
Counting objects: 100% (5/5), done.
Delta compression using up to 8 threads
Compressing objects: 100% (2/2), done.
Writing objects: 100% (3/3), 271 bytes | 271.00 KiB/s, done.
Total 3 (delta 1), reused 0 (delta 0)
remote: Resolving deltas: 100% (1/1), completed with 1 local object.
To https://github.com/mpcs-cc/gas-instructor.git
  74fe452..8deb085  main -> main
              

Grade Reporting

When your assignment is graded, we will add a “grading” branch to your repository. This branch includes a file called grade.txt that contains your grade and comments/feedback from the grader. You are expected to review the grading branch and, if you have questions/concerns about the accuracy of your grade that you would like us to review, please post a private note on Ed—DO NOT email me or the TAs directly.

Make sure that you have GitHub notifications turned on so that you're notified when the grading branch is pushed to your repository. You are responsible for checking the grading branch in a timely manner if your wish to re-submit an assignment (see below) or otherwise have your grade reviewed.

The grade in your grading branch is not the final/official grade. Once the TA pushes the grading branch to remote I will review and then publish grades on Canvas (as Canvas is the only officially sanctioned system for communicating grades). There will typically be a few days lag between your grade being pushed to GitHub and my posting it on Canvas. Please do not wait until Canvas grades are posted before resubmitting because it will usually be past the re-submission deadline.

Resubmissions

If you receive a “U” on a required assignment you may revise and resubmit the assignment using your tokens. Assuming you don’t use any of your tokens to request a late submission, you‘re allowed a maximum of two re-submissions. The following apply to resubmissions:

• You may only resubmit an assignment if the assignment was originally submitted on time, i.e., before the deadline specified in the assignment.
• All revised work must be resubmitted within five days of receiving the original grade on the grading branch in your GitHub repository—no exceptions/extensions!
• You may only revise and submit required assignments for regrading—if you resubmit an optional assignment for re-grading, we will not consider it.
• You may not resubmit an assignment more than once for re-grading.
• You may not resubmit a Satisfactory assignment (i.e., one on which you received an “S”) for re-grading.

If you decide to revise your work and resubmit, please do the following:

• Create a branch named <assignment_number>-resubmit, e.g., if re-submitting Assignment 11 you must create branch a11-resubmit.
• IMPORTANT: Post a private note on Ed informing us that you have resubmitted. If you don’t notify us via Ed we will not be able to grade your assignment and, if the AWS environment is cleaned up in the interim, your efforts will have been wasted.

After reviewing your resubmission we will update the grade.txt file in the grading branch.

Using External Sources

I fully expect you will use external sources (such as StackOverflow) to research potential solutions and find sample code for your assignments. While you may consult and be guided by such sources, you are expected to write your own code.

In particular, you may not use AI systems, such as ChatGPT or GitHub Copilot, to write or generate any of your code. Using those systems in a manner similar to consulting online resources (e.g., asking ChatGPT something like “How do I play a sound using pygame?”) is technically acceptable, but you should take any answer with a healthy dose of salt, as these systems will sometimes provide unequivocally wrong answers.

Any evidence or suggestion that your code was written/generated by someone or something other than you will be grounds for an immediate Unsatisfactory grade, without recourse on your part ...yes, you will be guilty without being offered the chance to defend yourself :-(( In some cases, the penalty may be an “F” for the class.