Standards

As described on the grading page, your grade will be based entirely on demonstrating that you have mastered the material or habits described in the standards on this page.

Numeric expressions

4 Can accurately read and write expressions using numbers, variables and the six operators, +, -, *, /, %, and ** to express basic mathematical relationships. Uses parenthesis appropriately to deal with order of operations.
3 Can usually read and write expressions using numbers, variables, and and the six operators, +, -, *, /, %, and ** to express basic mathematical relationships. Uses parenthesis appropriately to deal with order of operations.
2 Can usually read and write expressions using numbers, variables, and some but not all of the six operators, +, -, *, /, %, and ** to express basic mathematical relationships. May make mistakes due to order of operations.
1 Still struggles to write write expressions using numbers and variables that express basic mathematical relationships.
0 Not enough information.

Boolean expressions

4 Can accurately read and write expressions using the boolean values true and false, variables and the three operators, &&, ||, and ! to express basic logical relationships.
3 Can usually read and write expressions using the boolean values true and false, variables and the three operators, &&, ||, and ! to express basic logical relationships.
2 Can correctly read and write simple expressions involving single operators such as a && b but can’t combine expressions into more complex expressions.
1 Can’t consistently produce correct boolean expressions or explain the meaning of existing expressions.
0 Not enough information.

Basic string expressions

4 Can accurately read and write expressions using literal string values, variables and the two operators + and [] as well as the methods, substring in its one- and two-argument forms, toUpperCase, and toLowerCase to express string manipulations as complex as capitalizing a word or converting a word to Pig Latin.
3 Can usually read and write expressions using literal string values, variables and the two operators + and [] as well as the methods, substring in its one- and two-argument forms, toUpperCase, and toLowerCase to express string manipulations as complex as capitalizing a word or converting a word to Pig Latin.
2 Can read and write some string expressions but cannot consistently combine operators and methods to produce more complex string expressions.
1 Can’t consistently produce correct string expressions or explain the meaning of existing expressions.
0 Not enough information.

GitHub PRs

4 Consistently creates new PRs for completed work. Responds promptly to comments and requests for changes. Merges approved PRs promptly. Uses PRs to communicate and ask questions as well as turn in code.
3 Usually creates new PRs for completed work. Responds promptly to comments and requests for changes. Merges approved PRs promptly.
2 Leaves PRs with requests for changes or comments open without responding. Doesn’t make new PRs consistently. Opens new PRs without working to close old ones.
1 Doesn’t close Approved PRs promptly. This is the easiest thing to do so there’s no excuse not to do it. Merges PRs before they are approved.
0 Not enough information.

Writing basic functions

4 Can consistently write correct and clear functions that compute a value or achieve a desired effect based on a natural language description. Always chooses good names for functions, arguments, and other variables. Introduces variables to make code easier to read. Uses shorthand function syntax when appropriate.
3 Can consistently write correct and clear functions that compute a value or achieve a desired effect based on a natural language description. Usually chooses good names for functions, arguments, and other variables. Introduces variables to make code easier to read.
2 Can write functions that compute a value or achieve a desired effect based on a natural language description but they are not always correct or are hard to understand due to bad naming choices or confusing code.
1 Struggles to write syntactically correct functions that compute a value or achieve a desired effect based on a natural language description.
0 Not enough information.

Basic control constructs

4 Can use if statements and while and for loops correctly. Consistently uses else and else if clauses when appropriate to simplify code. Can write correct finite and infinite loops as well as nested loops. Can trace the execution of code using these control constructs and describe when the different parts of the code will be executed.
3 Can use if statements and while and for loops correctly. Usually uses else and else if clauses when appropriate to simplify code. Can write correct finite and infinite loops. Can trace the execution of code using these control constructs and describe when the different parts of the code will be executed.
2 Can make basic use if statements and while and for loops. Has difficulty tracing execution of code using these control constructs and describing when different parts of the code will be executed.
1 Struggles to write if, while, and for constructs in correct syntax. Has difficulty tracing execution of code using these control constructs and describing when different parts of the code will be executed.
0 Not enough information.

Array basics

4 Can consistently understand and produce code that loops through arrays with length and uses [] to access elements and use them in computations. Understands the difference between modifying an array and reassigning a variable. Can use push, pop, and slice methods appropriately. Can represent two-dimensional data with nested arrays and can understand and produce code to access and modify nested arrays.
3 Can usually understand and produce code that loops through arrays with length and uses [] to access elements and use them in computations. Understands the difference between modifying an array and reassigning a variable. Can use push, pop, and slice methods appropriately.
2 Can understand simple loops over arrays and how to use the [] operator but has trouble producing code to loop through arrays and access elements. Not yet fully clear on the difference between modifying an array and reassigning a variable.
1 Struggles to understand code accessing and manipulating arrays.
0 Not enough information.

Object basics

4 Can consistently understand and produce code that creates and manipulates objects. Understands how to use both the [] operator and dot notation to access properties. Consistently creates cohesive objects to represent related data and uses them to simplify code.
3 Can usually understand and produce code that creates and manipulates objects. Understands how to use both the [] operator and dot notation to access properties. Sometimes creates cohesive objects to represent related data and uses them to simplify code.
2 Can sometimes write correct code that uses objects and their properties.
1 Struggles to understand code using objects and their properties.
0 Not enough information.

Refactoring

4 Can consistently identify opportunities for refactoring and accurately apply refactoring patterns to simplify code. Regularly refactors own code to remove duplication, increase cohesion, and decrease coupling. Can reliably refactor code without changing its behavior.
3 Does not consistently identify opportunities for refactoring but can accurately apply refactoring patterns to simplify code when prompted. Usually refactors own code to remove at least gross duplication. Can reliably refactor code without changing its behavior.
2 Rarely identifies opportunities for refactoring and can not always accurately apply refactoring patterns. Rarely refactors own code without prompting. Has difficulty applying refactoring patterns without changing code’s behavior.
1 Struggles with the mechanics of applying basic refactoring paterns.
0 Not enough information.

Higher-order functions

4 Uses higher-order functions appropriately in own code. Sometimes writes own higher-order functions. Can use higher-order methods on arrays with both anonymous and named functions as the functional arguments. Can translate in both directionns between code that uses higher-order functions and code that does not.
3 Occasionally uses higher-order functions in own code. Can use higher-order methods on arrays with both anonymous and named functions as the functional arguments. Can translate in both directionns between code that uses higher-order functions and code that does not.
2 Rarely uses higher-order functions in own code. Can usually use higher-order methods on arrays with both anonymous and named functions as the functional arguments. Can usually translate in both directionns between code that uses higher-order functions and code that does not.
1 Cannot reliably either higher-order functions or translate between code using higher-order functions and code that does not.
0 Not enough information.

Recursion

4 Can consistently write recursive functions for problems given with a natural recursive structure, e.g. factoral and fibonacci. Can identify base case or cases and the recursive case for functions that recurse on one argument. Given the definition of a more complex recursion (e.g. change counting) can write a recursive function that implements it. Can translate between iterative and recursive solutions for linear recursions. May be able to optimize tree recursion to improve performance.
3 Can usually write recursive functions for problems given with a natural recursive structure, e.g. factoral and fibonacci. Can identify base case or cases and the recursive case for functions that recurse on one argument.
2 Can sometimes write recursive functions for problems given with a natural recursive structure, e.g. factoral and fibonacci. Can usually identify base cases but may struggle to write correct recursive cases.
1 Struggles to write recursive functions correctly.
0 Not enough information.

Projects

4 Picks projects that provide a good challenge without being impossible. Independently breaks larger project down into manageable chunks. Builds iteratively and regularly submits code for review. When submitting pull requests identifies planned next steps and current sticking points. Can frequently debug problems independently but also knows when and how to ask for help, providing details about the current sticking point.
3 Usually picks projects that are about the right challenge level but may over or undershoot. Can break larger project down into manageable chunks with some guidance. May spend too long trying to get too much functionality to work all at once rather than working in smaller chunks. May not regularly submit pull requests and may not use pull requests to communicate about the state of the project. Can usually debug problems idependently but also knows when and how to ask for help, providing details about the current sticking point.
2 Has trouble picking an appropriate project. Has trouble breaking down the project into smaller chunks or even understanding how chunks might be combined to complete the whole project. Has trouble debugging problems and when asking for help says things like, "This doesn't work", or "I'm stuck" without being able to describe what working would look like or what they're stuck on.
1 Struggles to develop an independent project.
0 Not enough information.