Overview

This course will be using skills based grading, meaning that a student’s grade will be solely based on their ability to prove competency of the core skills covered throughout the course. Some key components of this grading framework are:

  • All skills will be rated on a 0-4 scale.
  • Students will be given multiple opportunities to show mastery of each skill.
  • The skills will be clearly listed on the course syllabus.
  • Skill grades will be based on assessments (exams, quizzes, projects, labs, etc) only.
    • Assessments will be clearly noted when assigned.
  • Homework, classwork, entrance/exit tickets and other assignment types will be given, but will not factor into a students skill grade.

Assignment Types

Homework And Classwork

The purpose of these assignments is for students to practice, discover and try things out. These assignments are vital elements of a student’s path to skill mastery. These are not included in a students grade because they are not designed to assess skills but rather to hone them. Student’s grades should not be affected by how long or quickly it takes to complete. Students should also not be discouraged from trying out something different, exploring new possibilities or even failure to complete these assignments, as all of those activities are integral to learning and eventually mastering skills.

These assignments will also provide the teacher with important information about the current abilities of each student and the class as a whole. These assignments will not be graded, but they will be used in class, solutions may be provided, and feedback will be given as often as needed and possible.

Assessments

All assessments are designed to assess a students skill competency. It will be clear which skills are to be assessed for a given assessment. Instead of a single grade for an assignment (i.e. 92/100, 41/50, 3.5/4), students will be given a single grade for each skill assessed on a 0 - 4 scale as follows:

  • 4: Mastery of the skill demonstrated.
  • 3: Competency of the skill demonstrated.
  • 2: Developing competency of the skill demonstrated.
  • 1: Minimal competency of the skill demonstrated.
  • 0: No part of the skill demonstrated.

Exams & Quizzes

Exams and quizzes will be in class assessments taking the course of a period (or part of a period for quizzes). Students are not to work collaboratively or share information about the exam/quiz to any other student.

Lab Assignments

Lab assignments will be programming tasks that may include both in and out of class time to complete. Students must submit their own work, though they may use class-approved resources (including notes, classmates, CS Dojo) to complete the assignments. Rubrics detailing what skills will be assessed and what constitutes a particular grade for each skill will be provided for each lab.

Projects

Projects will be larger-scale assignments. Students will be given more time to complete the work than labs, and specific time will be set aside for planning and design, in addition to the project itself. Rubrics detailing what skills will be assessed and what constitutes a particular grade for each skill will be provided for each project.

Final Project and/or Exam

The course will culminate in a final assessment that will take the form of an exam, project, or both. The final(s) will assess all the skills for the course.

Late Assessment Submissions

  • Late labs and projects will be allowed within reason.
    • If a submission is deemed too late (i.e. after solutions have been posted, after marking period grades are due, etc.), there will be other opportunities to assess skill competency.
  • Since homework and classwork are not included in a students grade, that late work will not be penalized.

Retakes/Retests/Redos

All students will be given multiple attempts to demonstrate competency of each skill. This can take many different forms, including(but not limited to) the following:

  • Re-submission of an assessment.
  • Re-taking an exam.
  • Submitting corrections/explanations of incorrect answers.
  • Submitting a similar (but not identical) assessment.
  • Taking a similar (but not identical) exam.
  • Not allowing retakes or resubmissions, but instead using skill grades from other (previous or later) assessments.

Final Grade Calculation

A student’s final grade should reflect their demonstrated skill competency level from throughout the semester, including how well they’ve maintained those skills through to the end. A student’s skill grade will consist of their skill level demonstrated over the course of the semester and their skill level demonstrated on the final assessment(s):

Final grades will take the average of all of a student’s individual skill grades and map that to a 100 point grading scale as follows:

  • 4: 100
  • 3: 90
  • 2: 75
  • 1: 55

Skills for NeXTCS

N.B. This list may change slightly over the course of the semester. Any changes will be made clearly during class and updated here as well.

Skill Minimal Competency Developing Competency Competency Mastery
1. Basic Drawing Functions (line, circle, square, rect, ellipse) Can use one basic 2D drawing function. Can use two basic drawing functions. Can use all the basic drawing functions. Can use multiple basic drawing functions to draw a complex shape.
2. Controlling Color State Can set the fill or stroke color of a 2D shape. Can set the fill and stroke color of a 2D shape. Can set the fill and stroke color and the stroke weight of a 2D shape. Can control the fill and stroke colors and the stroke weights of multiple 2D shapes.
3. Using Colors Can set colors using separate Red, Green, and Blue values. Can set colors using RGB values or hexcode values. Can create and work with color variable types. Can explain how the color data type represents color values.
4. Primitive Variables and Types Can declare, initialize, and use int variables. Can declare, initialize, and use int and float variables. Can explain the differences and use the different integer and floating point variable types. Can explain the differences between, use, and explain how the different primitive variables types represent data.
5. Working with Boolean Values Understands the purpose of boolean values. Demonstrates the appropriate use of comparison operators. Demonstrates the appropriate use of comparison and boolean operators. Writes functions that take in boolean values and/or return boolean values.
6. Working with setup and draw Can write a valid setup function that sets initial conditions for a processing program. Can write a valid setup function, and can write a valid draw function that generates different program output each frame. Can create global variables that are initialized in setup and modified in draw. Can use global variables, custom functions, and setup and draw to produce a full processing program.
7. Controlling Program Speed Can set the frame rate for a processing program. Can set the frame rate based on a specified speed. Can control program output based on the current frame number. Can start and stop the action of a processing program.
8. Custom Functions Can identify the return type, name, parameter list, and body of a function. Can write a function given a header and description. Can write a function, including selecting appropriate return and parameter types. Can write multiple functions and use variable scope accurately.
9. Writing Readable Code Uses descriptive identifiers. Uses indentation and newlines to create more readable code, and descriptive identifiers. Uses inline and block comments when appropriate. Uses indentation and newlines, and descriptive identifiers. Can take a large programming task and break it up into smaller functions.
10. Debugging Practices Can use println statements to help debug code. Consistently uses println statements while debugging. Consistently uses println statements and commenting while debugging. Creates visual output in the program window while debugging.
11. Conditional Statements Can use a single if statement correctly. Can use combined if and else statements correctly. Can use if, else if, and else correctly multiples times in a program. Can use multiple styles of combinations of conditional statements (i.e. nested, sequential) in a single program.
12. Loops Can use a basic while loop. Can use a basic for loop with a variable modified by an increment (++) or decrement (--) operator. Can use for loops with a variable controlled by --, ++, and other arithmetic operations as appropriate. Can use both for and while loops when appropriate, and explain why one is a better choice over another in a given situation.
13. Handling Events Can modify the state of a running program using the keyPressed() method. Can modify the sate of a running program using multiple keys via the keyPressed() method. Can modify the state of a running program using mouePressed(), using the mouse’s coordinates in some way, as well as using keyPressed() Can work with all the keyboard and mouse event handling Processing functions.
14. Using Objects Can declare and Object variable and instantiate an Object using a constructor. Can use multiple Objects in a program by calling methods on appropriately declared and instantiated Object variables. Can use Objects in a program, describe how reference variables work, and how they are different from primitive variables. Can use Objects and accurately make heap diagrams of Object variables and data.
15. Writing Classes Can design a class by grouping together ideas that should be encapsulated into a single class. Can separate out the fields from the methods while designing a class. Can write a class with fields, a single constructor and methods. Can write classes with fields, and overloaded methods and constructors.
16. 1D Arrays Can declare and instantiate a primitive 1D array. Can declare, instantiate, and use primitive 1D arrays, including iterating though them with loops. Can declare, instantiate, and use primitive and object 1D arrays. Can work with 1D arrays in non-sequential ways. Understands the concepts of deep and shallow copies of arrays.
17. 2D Arrays Can declare and instantiate primitive and object 2D arrays. Can declare, instantiate, and use primitive and object 2D arrays, including iterating though them with loops. Can work with both square and rectangular 2D arrays. Can use 2D arrays to model grid-based structures (i.e. game boards, images, cellular automata)
18. Searching Can linearly search a 1D array. Can linearly search a 2D array. Can write linear and binary search algorithm. Can write linear and binary search algorithms and keep track of their performance.
19. Sorting Can describe how a single n^2 sorting algorithm works. Can describe how more than one n^2 sorting algorithm works. Can program at least two n^2 sorting algorithms. Can program 3 n^2 sorting algorithms and keep track of their performance.
20. Algorithm Analysis Can describe the difference in how long two different algorithms that perform the same task using measured data. Can describe the difference between time complexity and space complexity. Can describe the main complexity classes using Big-O notation. Can assign the correct Big-O complexity class to a given algorithm or piece of code.
21. Using Git & Github Can create ssh keys and add them to Github one one computer. Can use git to properly add, commit and push files. Can use git to maintain a repository on multiple computers and Github. Can correct merge conflicts appropriately when they appear.