7
$\begingroup$

When I create questions in the style of the College Board's AP Computer Science Free Response Questions, I always attempt to create authentic rubrics that reflect how such questions would be graded. However, I have not found any clear guides about how to do this. I have noticed a few trends, but I wonder if anyone else has more (or something more definitive):

  1. If a method requires a return, making a return is typically worth a point
  2. If parameters are given, utilizing them at all is awarded some points
  3. If arrays are present, looping through them with no chance of an ArrayIndexOutOfBoundsException is awarded 1-2 points. (If you need to loop through a String, that could also go here.)
  4. Dealing with funny edge cases is often worth a point.
  5. Utilizing the appropriate methods from other Objects passed in is often awarded a point, though no penalty is made if they successfully recreate the functionality that the Object would provide.
  6. Appropriately comparing two array neighbors without out-of-bounds potential, if it's that kind of problem, would be 1/2 a point, and correctly comparing all neighbors would be an additional 1/2 point.

You can see rubrics for the 2010 exam here as a sample. Obviously, being able to create high-quality AP CS FRQ rubrics would help get the kids used to such grading - it could be the grading style used on exams through the entire course.

$\endgroup$
  • $\begingroup$ No points for solving the problem? $\endgroup$ – AlG May 25 '17 at 11:41
  • $\begingroup$ Rarely, and only 1/2 to 1 point. The goal (if I can extrapolate) seems to be to award points for properly executed components, and build up the full score that way. $\endgroup$ – Ben I. May 25 '17 at 13:02
  • 1
    $\begingroup$ On #6, they don't use 1/2 point any more. They're all full points. So if I was creating a rubric from scratch I would only use whole points. $\endgroup$ – Ryan Nutt May 26 '17 at 13:02
3
$\begingroup$

In the weeks leading up to the test I typically only use the actual past tests for exactly that reason. But even when I don't use the released FRQs I still grade on a 9 point scale so they get used to it.

Here's a few more that tend to come up.

For return methods, create a variable of the correct type, do something to it, and return it.

If it's a constructor, it should initialize the instance variables.

On full class problems - either write a full class, extend an abstract, or implement an interface - it's usually a point or two for the class signature.

Utilizing the appropriate methods from other Objects passed in is often awarded a point, though no penalty is made if they successfully recreate the functionality that the Object would provide.

Sometimes. And sometimes they explicitly say that you must use the previous method for credit. #3 on the test this year did that.

I also have a negative rubric point for any of the penalties. Destruction of data, unexpected side effects, returning from a void, that sort of thing.

$\endgroup$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.