Milestone Assessment
What we’re looking for:
Self-improvement
- identifying problems, and coming up with concrete/specific ways to address them
- setting realistic and achievable goals, and making a plan for how to work towards each goal
- reflecting on your progress towards achieving each goal, and ways to improve in the future
Code style and clarity
- clear and correct code for most programming activities, and for the assignments
- an understanding of the attributes of good code
- an appreciation for programming style
Code improvement
- reflecting on the style and quality of your own code, and identifying ways of improving your code
- evidence of debugging skills and of reflecting on and learning from mistakes
- evidence of planning and reflection on craftsmanship and code quality and correctness
Not all of these will be applicable to every milestone, but these are the skills that we hope you will gain over the course of the semester.
Assessment Rubric
For each milestone write-up, you will be assessed on a specific subset of the overall criteria below.
Identifying Problems |
Scale | Description |
---|---|
Needs Improvement | Was unable to identify any problems. |
Okay | Was able to somewhat identify problems. |
Good | Was able to identify some relevant problems. |
Great | Was able to identify some specific, relevant problems. |
Awesome | Was able to identify many/all specific, relevant problems. |
Coming up with concrete/specific ways to address problems |
Scale | Description |
---|---|
Needs Improvement | Was unable to identify any solutions to address problems. |
Okay | Was somewhat able to identify solutions (which may not be sensible or feasible). |
Good | Was able to identify possible solutions to address problems. |
Great | Was able to identify specific solutions to address problems. |
Awesome | Was able to come up with specific feasible and realistic solutions to address problems. |
Setting realistic and achievable goals |
Scale | Description |
---|---|
Needs Improvement | Did not attempt to set any goals. |
Okay | Attempted to set goals (which may not have been appropriate or achievable). |
Good | Set appropriate goals (which may not have been sufficiently specific). |
Great | Set specific, appropriate goals. |
Awesome | Set specific goals that were appropriate, realistic, and achievable. |
Making a plan for how to work towards goals |
Scale | Description |
---|---|
Needs Improvement | Did not attempt to make a plan. |
Okay | Attempted to make a plan (which may not have been realistic or specific). |
Good | Made a realistic plan for how to achieve the goal. |
Great | Made a specific plan for how to achieve the goal (which may not have been sufficiently detailed or thorough). |
Awesome | Made a specific and thorough plan for how to achieve the goal, which could have been easily carried out. |
Reflecting on progress towards goals |
Scale | Description |
---|---|
Needs Improvement | No mention of progress towards goal. |
Okay | Some mention of progress towards goal (without any reflection, e.g. purely a statement of facts). |
Good | Some reflection on progress towards goals. |
Great | Reflection on progress towards goals. |
Awesome | In-depth, thoughtful reflection on progress towards goal. |
Reflecting on “lessons learned” or ways to improve in the future (from setting and attempting goals) |
Scale | Description |
---|---|
Needs Improvement | No mention of ways to improve in the future. |
Okay | Some/vague mention of ways to improve in the future. |
Good | Identified “lessons learned” or ways to improve in the future. |
Great | Identified specific “lessons learned” or ways to improve in the future. |
Awesome | In-depth, thoughtful reflection on lessons learned from working towards the goal, and how to apply those to future situations. |
Clear and correct code for most programming activities |
Scale | Description |
---|---|
Needs Improvement | No attempt to make code readable and/or correct. |
Okay | Some effort has been made to make code readable and/or correct, but there are still issues. |
Good | Code is overall mostly clear and correct, but there are still some issues. |
Great | Code is clear and correct, with no technical style issues but still room for improvement. |
Awesome | A significant and very successful attempt to make code that is clear, elegant, and correct. |
Clear and correct code for assignments |
Scale | Description |
---|---|
Needs Improvement | No attempt to make code readable and/or correct. |
Okay | Some effort has been made to make code readable and/or correct, but there are still issues. |
Good | Code is overall mostly clear and correct, but there are still some issues. |
Great | Code is clear and correct, with no technical style issues but still room for improvement. |
Awesome | A significant and very successful attempt to make code that is clear, elegant, and correct. |
An understanding of the attributes of good code |
Scale | Description |
---|---|
Needs Improvement | No evidence of any understanding of the attributes of good code. |
Okay | Some/minimal understanding of the attributes of good code. |
Good | A basic understanding of the attributes of good code. |
Great | A good understanding of the attributes of good code. |
Awesome | A deep and thoughtful understanding about the attributes of good code. |
An appreciation for programming style |
Scale | Description |
---|---|
Needs Improvement | No evidence of any understanding of programming style. |
Okay | Some/minimal understanding of programming style. |
Good | A basic understanding of programming style. |
Great | A good understanding of programming style. |
Awesome | A comprehensive and convincing understanding of programming style. |
Reflecting on the style and quality of your own code |
Scale | Description |
---|---|
Needs Improvement | No mention of style or quality of own code. |
Okay | Some mention of style or quality of own code (without any reflection, e.g. purely a statement of facts). |
Good | Some reflection on style and quality of own code. |
Great | Reflection on style and quality of own code. |
Awesome | In-depth, thoughtful reflection on style and quality of own code. |
Identifying ways of improving your work |
Scale | Description |
---|---|
Needs Improvement | No mention of ways to improve code. |
Okay | Was somewhat able to identify ways to improve code (which may not be sufficient or feasible). |
Good | Was able to identify possible ways to improve code (which may not be specific). |
Great | Was able to identify specific ways to improve code. |
Awesome | Identified specific, accurate, realistic, and thoughtful ways to improve code. |
Evidence of debugging skills |
Scale | Description |
---|---|
Needs Improvement | No mention of debugging or debugging skills. |
Okay | Some mention of bugs encountered, and/or approach taken to fix them. |
Good | Description of bugs encountered, and the methods/approach taken to fix them. |
Great | Analysis of bugs encountered, with a sensible and methodical approach taken to fix them. |
Awesome | Thorough analysis of bugs encountered, with a well-developed and effective general approach to identifying and fixing bugs, that could be applied to any future programming situations. |
Reflecting on and learning from (technical) mistakes |
Scale | Description |
---|---|
Needs Improvement | No mention of ways to improve in the future. |
Okay | Some/vague mention of ways to improve in the future. |
Good | Identified “lessons learned” or ways to improve in the future. |
Great | Identified specific “lessons learned” or ways to improve in the future. |
Awesome | In-depth, thoughtful reflection on lessons learned from technical mistakes, and how to apply those to future situations. |