Page content

Policies Overview

  • Communications: The course web is used for providing information and policies; Canvas is used to make announcements, communicate grades, and provide documents; Piazza is used to communicate with course staff; and GitHub is used to get workbooks and hand them in. Avoid email - use Piazza to communicate with course staff. (See Communications)
  • Lectures and Attendance: Lecture attendance is required. Lecture materials (when available) are not meant to replace lectures. (See Lectures and Attendance)
  • Grading: 35% exams (midterm, final), 65% workbooks, adjustment made for quizzes (see Grading) Grading policy changed for COVID-19.
  • Readings: All required readings will be provided online. The workbooks will tell you what to read and where to get it. Purchasing books is optional. (see Readings)
  • Workbooks: There will be a workbook for almost every week on the class. You must get the workbooks via GitHub, read them (and the readings they describe), add your programming assignments in them, and turn them in via GitHub. Workbooks are due on Mondays (except for the final Workbook). (see Workbooks)
  • Quizzes: There will be an online Quiz almost every week. These will be done on Canvas and can affect your grade (see Quizzes)
  • Exams: There will be a midterm and a final exam. They will count for 35% of your grade. (see Exams)
  • Late Policy: Workbooks are due on Mondays (except for the final workbook), Quizzes on Fridays. We cannot give extensions to individuals. (see Late Policy)
  • GitHub Policy: All students must have a GitHub account and use it to obtain and turn in workbooks. (see Policies for GitHub)
  • Collaboration Policy: It is OK to discuss assignments with classmates and help each other with workbooks. However, everyone must substantively do their own assignments. (see Collaboration Policy)
  • Using Web Resources: If you use a web resource, give it proper attribution. Avoid taking too much from any resource. (see Using Web Resources)
  • Policy on JavaScript usage: You should use “standard” JavaScript, and not add any libraries that we do not provide. (see Policy on JavaScript usage)


  • The course web will be used to provide information (such as this page). You are responsible for the materials on it. If new material is posted to the course web, an announcement will be made on Canvas.
  • We will use Canvas as a way to communicate grades to students. Announcements will be made on Canvas. We will also use Canvas as a way to distribute “private” documents (e.g., files that cannot be shared with students outside of class, or links to set up GitHub classroom). We will also use Canvas as a way to announce when there are updates to the course web. Students should not use Canvas as a way to communicate back to the course staff. Do not use messages or grade comments to communicate to course staff - we may not see it. We may use grade comments as a way to give feedback to you - do not reply to them!
  • We will use Piazza as a way for students to communicate - to course staff as well as to discuss course content publicly.
  • We will use GitHub (via GitHub Classroom) as a way to distribute “workbooks” (the starting framework for assignments), as well as to turn them in. (see the Git and GitHub in CS559 page)
  • In general, we will avoid using email for class. We will use the course mailing list a few times at the beginning of the semester to point people to the other systems. Please use Piazza to communicate with the course staff. If you send email to a specific course staff member, there may be a delay in a response (and the response might be “ask on Piazza”).
  • We may use email as a way to ask a specific question to a specific student. If you are sent an email directly, please respond to it.
  • If you have a personal issue (e.g., a medical pr family emergency), you can send email to the Professor. However, for any other kind of question, please use Piazza.

The preferred method for communicating with the course staff is via Piazza.

Lectures and Attendance

The class meets from 2:30-3:45 on Tuesdays and Thursdays in room B130, Van Vleck Hall (map).

Lectures are required - material will be presented in lecture that may not be available any other way. There will be no way to make up the material - so if you miss a lecture, ask a classmate. While materials from lectures (slides, videos, code samples, etc.) may be available after class, these are meant as a reminder/supplement for people who attended lecture, not as a replacement. Lecture materials are not meant to replace the lecture.

The lecture room may be full for class. Please arrive at lecture on time so you don’t disrupt your classmates by coming late. If your late arrivals are a problem (e.g., you often come late and disturb others), you may not be allowed to enter.

You may use laptops, tablets, or other devices during class for class related activities (e.g., taking notes, trying the code examples the instructor is doing, looking up reference materials). Please be aware that the other students around you will see your screen and may be distracted by it. Your privilege to use a device in class may be revoked if it is abused.

There may be optional lectures, including help sessions, bonus topic sessions, or collaborative coding sessions. These will be held outside of class time. We understand that not everyone will be able to attend.

Class attendance is required. You are responsible for what is said in class. We may make announcements, present material that does not appear in any other forms, or other things that you can only get by listening in class.

We will not take attendance, so we have no way to enforce attendance. If you miss a class, it is your responsibility to find out what you missed.

We plan to record the lectures for this class, but we cannot promise that these will always be available (e.g., sometimes the system doesn’t work). Watching the videos is not as good as attending the lecture in person (there is science behind this). The lectures are designed to be seen in person - the recordings (when available) are fine for review, or better than nothing as a backup (if you miss one).

Anecdotal experience says that attendance in class is correlated with doing well.

Lecture Materials

The lecturer may use visual aids (slides or demos) in class.

The slides are not meant as a replacement for listening to the lecture. They are designed to complement the lecture. You should not expect the slides to work “on their own” (to teach you without the lecture).

Often the slides will be “sparse” so that the instructor can draw on them as part of the lecture. We will try to capture the resulting drawings and make these available after class. However, sometimes the capture doesn’t work.

We intend to make lecture materials available after class. These generally will be posted on Canvas. We cannot guarantee that all materials will be made available.

Past students have asked to have the slides available before class so they can use them to take notes. We will try to provide the slides before lecture, but may not always be able to do this.

Remember: the slides are designed to complement the lecture, not replace it.


Note: I will use the letter grade scale (A,AB,…F) and 4-point scale (4=A, 3=B, 0=F) interchangeably.

We will give a grade for the “workbooks and programs” and for the exams. Your final grade will be:

(COVID-19 Update: see the updated grading scheme - we de-emphasized the final exam and made it non-cumulative).

  • 35% exams (13% midterm, 17% final, 5% whichever you did better on).
  • 65% workbook grade - all programming assignments are part of workbooks.
  • We will consider your quiz grade when giving your final grade. We may adjust your final grade up or down (1-3 percentage points) based on your quiz scores.

We will drop your lowest 2 workbook grades (but not the final workbook). We will drop your lowest 2 quiz grades.

Each exam and workbook will be curved individually. The final grades will generally be the strict average of the (already curved) component grades.

In order to pass the class, you must receive a non-F grade on at least half of the workbooks, a non-zero grade on the final workbook, and a non-zero grade on both exams.

We will use the following conversion from curved scores (percentages) to grades: 90=A, 85=AB, 80=B, 75=BC, 70=C, 60=D, 50=F.

Requests for workbook regrades must be made as private messages to the course staff within 1 week after the grades are posted.


Required readings will be described in the workbooks. All readings will be provided online - either by Canvas (for materials that cannot be shared beyond class), links to the web, or through the UW Library.

You do not need to purchase any books for the class. However, you may choose to buy a physical copy of one of the books we are using if you prefer. See the Books page.

Readings are required. Materials in the readings may be tested in the exams or used in projects. The readings are designed to complement the lectures. In some cases, you will be expected to read before lecture to have context for the lecture material. In other cases, you will be expected to read after lecture to reinforce or get detail on topics that were discussed.

Readings include the contents of workbooks and the web pages.

You may need to supplement your reading with other materials from the web. This is especially important for practical issues of the programming assignments. We will make suggestions.

The example code and materials in the workbooks are part of the required readings.


See the Workbooks page for more details.

There will be “weekly” workbooks (there are 12 over the course of the semester).

With each workbook, you will use a GitHub classroom link to get a repository on GitHub, clone this repo to your own computer, complete the workbook committing your work as you go, and then push the repo back to GitHub so that we can grade it. For each assignment, a description will be posted on Canvas with specific instructions.

With a workbook, you will be expected to read all required parts - which may include the code (the parts you are responsible for will be made clear). You will be expected to add to the programs, and to fill in text areas. Instructions will be given as to what you need to do. You are not only responsible for completing the workbook and turning it in, but also for understanding the material. We will ask questions about the content of the workbooks on the exams.

We will grade workbooks and give you score (a percentage).

The workbooks are designed such that the first 85 points (what you need for an AB) are different than the points beyond 85. Points beyond 85 are harder to get. These “bonus points” will be described specifically in the assignments. Different assignments may have different numbers of bonus points - some assignments may have a lot of bonus point opportunities (so you can score more than 100), while others may have fewer (so that you cannot get an A+).

The idea of the bonus points is that it gives you flexibility on when you want to put effort above and beyond the basics. Because the grades are averaged, you can do the basic assignment one week (and get an 85=AB), and then get lots of bonus points in another week so things average out to an A.

Workbooks will explain opportunities for getting bonus points. It may be by doing an optional part, by doing an extra creative job in some way.

Workbooks will be due on Mondays (at midnight Madison time - 12:01am Tuesday is not Monday), except for the final workbook which is due on the last day of classes. At some point after the deadline, we will “harvest” the assignments (download them from GitHub). If you miss the grading collection, you will receive a 0 score. We cannot grant extensions. If you turn in an assignment late, and we happen to collect things even later, you are lucky. Don’t count on it. To be safe, turn things in on time. We may be lenient on the first workbook or two while people figure out how to turn things in.

If you miss handing in an assignment in time, you should still push it to the repository. If you miss the grading collection, you will receive a 0 score. We cannot grant extensions. However, if you have extenuating circumstances (e.g., you have a family emergency, you get sick, you have a job interview), please let us know. We can re-assess missed assignments at the end of the semester if necessary. (if you miss an assignment, you must tell us as soon as possible - do not wait until the end of the semester!)

We will drop your lowest two workbook scores for the non-final (first 11) workbooks.

Your workbook grade will be the average of the workbook grades (we drop the lowest 2 scores). If you got lots of bonus points beyond the maximums you could earn on individual workbooks, we might add extra to your grade.

If you turn in fewer than half of the workbooks in time to be graded, you may receive a failing grade for the class. Even if the half of the workbooks you did turn in received good grades.


There will be a quiz almost every week. These will be online (in Canvas).

Quizzes will generally be made available sometime after lecture on Thursday (if they are made available earlier, you probably want to wait until after Thursday’s lecture to take it). They must be completed by Friday. The Quiz deadline will be at least 48 hours after the Quiz is released. After the quiz deadline, we may discuss the answers. (this was updated 1/29/2020)

You can retake the quiz as many times as you like (so you can keep trying until you get a good score). The quizzes are to help you check that you understand the material. If you didn’t understand something, go back and try again.

At least half of the questions on the exam will come from the quizzes (we may change some details).

We will look at your quiz grades when determining your final grade. We will ignore the lowest 2 quiz grades. The quizzes will be used for students who are close to grade boundaries to push things one direction or the other. It is important to take each quiz and do reasonably.


There will be a midterm (7:30pm on March 11th) and a final exam.

The exams will count for 35% of your grade. The midterm will count for 13%, the final for 17%, and 5% will be whichever you score higher on.

Exams cannot be made up. If you miss it, you miss it.

In order to pass the class, you must receive a non-zero grade on both exams.

The final exam will be cumulative, although there will be an emphasis on the material that was not covered on the midterm.

Late Policy

Exams cannot be made up. If you miss it, you’ve missed it. If you have a good excuse, we can make alternative arrangements.

Workbooks are due on Monday, Madison time (except for the final workbook, which is due on a Friday). If it’s 12:01 Tuesday, then it’s not Monday. Remember, that you need to push your repository to GitHub for us to get it.

Workbooks will be collected from GitHub sometime after the Monday (following the Friday). Probably early Tuesday morning. So be sure to turn things in on (or before) Monday in order to have them graded. If you turn things in (which involves pushing it to GitHub) after Monday, we will not grade it. This hard deadline allows us to give out the answers.

If you don’t turn your workbook in in time to be graded, you will receive a 0 grade for it. However, we may look at it in exceptional cases at the end of the semester. We drop the lowest 2 workbook grades, so missing one is probably not catastrophic.

Quizzes have a hard deadline (Friday). If you miss it, you miss it. We drop the lowest 2.

Collaboration Policy

Computer graphics is (usually) a team sport. In fact, learning computer graphics (and, arguably, learning in general) is best done in collaboration with others. Unfortunately, in a university class setting, we have the unfortunate constraint that we must grade individuals independently, so we need to have people work independently on graded assignments so that we can assess them. Therefore, there is a fine line between “collaboration” and “academic misconduct”.

For CS559, we want to encourage collaboration. However, we also need to make sure that each individual gets appropriate credit for their work.

Students are encouraged to discuss class topics and assignments with other students, subject to the following rules:

  1. If you are unsure if something is collaboration or academic misconduct, please ask the instructor or TA for clarification.
  2. No collaboration is allowed on the exams or quizzes.
  3. Assignments and projects must be substantively from the person claiming to have done it. It’s OK to ask for help, but most of the work should be your own.
  4. Ultimately, each student is responsible for the material. Projects, assignments and exams will require you to understand the assignments, so be careful not to rely on help since at some point you might need to do it your self.
  5. Collaboration must be a two way street. The person giving help agree. (e.g. don’t look at someone else’s work without their permission).
  6. Every student must turn in their own assignment, and is responsible for it, unless it is explicitly a group project. For group projects, specific instructions will be given.
  7. Projects must be “substantially” written by the student handing it in. In particular, the key parts of the project must be completed by the student handing in the project.
  8. Any code that you didn’t write must be given proper attribution. If you grab a piece of code from the web, another student, some book, … – you must say so!
  9. We will give you large amounts of example code to work with for various assignments and projects. Be sure to give it proper attribution.
  10. You may only use external libraries that we provide.
  11. With JavaScript, you can do “View Source” in the web browser to see how programs you find (including our sample solutions) work. While we encourage you to use this to learn, we discourage you from just copying too much stuff. We urge you not to snoop to find answers to things we want you to figure out yourself, or to steal large pieces of code. Again, this is a fine line: use your judgment, or ask.
  12. You should make reasonable efforts to keep your work private (from your classmates) so that others do not copy it. You can show them things you made, but please do not give people access to your programs (until after the assignments are due).
  13. Avoid putting large fragments of code on Piazza, or giving away the answers to key parts of assignments. If you are in doubt, send things privately to the course staff who can help you decide if it is appropriate to make public.


  • It is OK to ask a classmate for help. It is not OK to “borrow” their assignment and copy it without their permission. It is not OK to just copy it without understanding it (since you won’t learn the material).
  • It is OK to ask a classmate for help looking over your code to find a bug. It is not OK to use a piece of their code without giving them proper attribution, or if its an important part of a project.
  • If you ever have a question, ask.

The fact that we are using JavaScript in the web browser creates challenges and opportunities for class with respect to collaboration. You can always do “view source” in a web browser to look at someone’s program. If we give you a sample solution, you can look at it. There are steps one can take to hide their programs, but this complicates things.

You must give proper attribution for anything that you did not create in your README file. This should not be more than a few lines of code (for example, copied from a web tutorial). It may be an “artistic asset” (such as an image, texture, or 3D model), however you may only use things that you have license to use (e.g., it is public domain or has a creative commons license). Instructions will be provided when it is appropriate to use someone else’s artwork.

Programming assignments and workbooks will be turned in via GitHub. You must follow the GitHub classroom procedure to create your own repository (with the starter materials) on GitHub as part of each assignment (instructions will be provided with the assignment). You must clone your personal repository. You must commit changes to this repository. To hand in your work, you must push it back to the GitHub repository you were provided.

Your work will involve modifying the starter materials for each assignment. Sometimes, you will be asked to add new files - but often, you will modify existing files. The assignment will tell you which files you are allowed/required to change/ While you may change any parts of the files as you see fit, we recommend not making unnecessary changes.

All of the code and documentation that you submit should either be (1) the provided starter materials or (2) changes or additions that you conceived-of and typed.

Using Web Resources

Using the web as a resource to help with programming is part of programming these days. We understand that when you have a question, the first thing to do is to search for it. This is especially true for web programming things (like we’re doing) where the official documentation is online.

We understand that you will be using the web as a resource. Discussion sites like Stack Overflow are a valid resource. You should never copy more than a few lines of code from a resource (and even then, be sure to give attribution). Please try to avoid searching for complete solutions: if we ask you to implement something yourself, please implement it. It’s OK to look up details that you can’t remember: but make sure you understand what you put into your code.

Please ask questions about course assignments on Piazza, not on public forums.

Remember to give proper attribution if you get code or help from any online resource (including Piazza).

Policy on JavaScript usage

Basic rule: you should start with what we give you, and type everything yourself. If you didn’t type it, you shouldn’t turn it in.

Ironically, these rules are more targeted at JavaScript experts who might want to use things we cannot support in class. If you’re a JavaScript novice and these rules don’t make sense, don’t worry - we’re basically asking you not to do fancy stuff. The Javascript in CS559 page will explain.

Your program must run as handed in (no compilation steps). You may not use a transpiler (e.g., Babel, Typescript) to create the files that you hand in for use.

You may not add any new libraries that you did not write. You must use the library files that we provide. You should not change the libraries that we provide unless instructed to do so.

You may use whatever features of JavaScript work in the web browser that the grader will use for testing (Google Chrome). If your program only works with Firefox, you can specify that in your README file when you turn the assignment in.

See theJavascript in CS559 page for more details.

These same rules apply to HTML and CSS (e.g., you need to write all the HTML and CSS “by hand” - rather than using a pre-processor for a higher level language like SASS or LESS).