• Specifications Grading
• Assignments
• Submitting Assignments
• Resubmissions and Late Submissions
• Using GitHub
• Working with Git Branches
• Grade Reporting
• 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 my perspective, and the grading scheme describes precisely what is required to get that grade—no more, no less. Here’s how it works:

1. 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.
2. Completed assignments are graded using the Satisfactory/Needs Improvement/Unsatisfactory (or SNU) scale.
3. Your final grade is determined by a "bundle", based on the number of Satisfactory assignments completed and your performance on quizzes as defined in the table below.




"A" Bundle	"A–" Bundle	"B+" Bundle	"B" Bundle	"B–" Bundle	"C+" or "P/F" Bundle
Complete all assignments from Group 1 at "Satisfactory"	Complete all assignments from Group 1 at "Satisfactory"	Complete all assignments from Group 1 at "Satisfactory"	Complete at least 9 (nine) assignments from Group 1 at "Satisfactory"	Complete at least 8 (eight) assignments from Group 1 at "Satisfactory" and at 2 (two) at "Needs Improvement"	Complete at least 8 (eight) assignments from Group 1 at "Satisfactory" and at least 1 (one) at "Needs Improvement"
Complete at least 2 (two) assignments from Group 2 at "Satisfactory"	Complete at least 2 (two) assignments from Group 2 at "Satisfactory"	Complete at least 1 (one) assignment from Group 2 at "Satisfactory"	Complete at least 1 (one) assignment from Group 2 at "Satisfactory"	Complete at least 1 (one) assignment from either Group 2 or Group 3 at "Satisfactory"	Score 50% or higher on at least 1 (one) quiz or the challenge test
Complete all assignments from Group 3 at "Satisfactory"	Complete all assignments from Group 3 at "Satisfactory"	Complete all assignments from Group 3 at "Satisfactory"	Complete assignment A16 from Group 3 at "Satisfactory"	Score 50% or higher on at least 1 (one) quiz or the challenge test
Complete at least 2 (two) assignments from Group 4 at "Satisfactory"	Complete at least 1 (one) assignment from Group 4 at "Satisfactory"	Score 50% or higher on at least 2 (two) quizzes or 1 (one) quiz plus the challenge test	Score 50% or higher on at least 2 (two) quizzes or 1 (one) quiz plus the challenge test
Score 50% or higher on all quizzes	Score 50% or higher on all quizzes or 2 (two) quizzes plus the challenge test
Score 50% or higher on the challenge test

The SNU scale is defined as follows:

Satisfactory (S)
Work is complete and demonstrates adequate understanding of the material.
• Code works as specified
• Code contains no/very few minor errors
• Code implements some error handling
• Specific references provided
Needs Improvement (N)
Work is mostly complete and/or demonstrates some understanding of the material, but is missing one or more critical elements.
• Code works partially as specified
• Code contains some errors
• Code implements no error handling
• Only general references provided
Unsatisfactory (U)
Work is incomplete and/or demonstrates limited/no grasp of the material.
• Code does not work as specified
• Code contains significant errors
• No references provided

Assignments

Assignments are submitted via GitHub as described below. You also have the option to re-submit some unsatisfactory work; see Resubmissions and Late Resubmissions 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 much 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 please be advised now.

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

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: Thursday, January 23, 2023 at 5:30pm CST.

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.

Resubmissions and Late Submissions

Under our grading scheme you have the option to resubmit an assignment in order to improve your grade or request a 24-hour extension to submit an assignment late. During the quarter you may exercise these options up to three times, in total (for either resubmissions or late assignments).

Resubmissions

If you receive a “U” or an "N" on an assignment you may revise and resubmit it. 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 three days of receiving the original grade on the grading branch in your GitHub repository—no exceptions/extensions!
• You may not resubmit an assignment more than once.

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 14 you must create branch a14-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 know that there is a resubmission for grading 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 in GitHub.

Late Submissions

Late submissions will not be considered for grading but you may request a 24-hour extension. If you want to exercise this option, you must notify us before the due date/time by posting a private note in Ed Discussion. Any submission beyond 24 hours after the due date/time will not be graded. 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 Git 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 above) 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.

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.