Answers.Body: <p>What I'm doing is: I give points for each relevant idea / concept in the program. E.g. if you have to loop through a data structure and you have to do something with the content, I would give point for the loop construction and points for the content. </p>
  
  <p>The graders can now check whether the loop is correct and if the inner content is correct and give points for this. If students use a different technique (e.g. while instead of for), they can still decide whether the loop is doing as intended and give the points. </p>
  
  <p>If you are insisting in specific soliutions (e.g. you <em>have</em> to use a "for"-loop), you should note this. Still, it would be possible to get some points for the content. </p>
  
  <p>For a simple test about python lists this could look like this:</p>
  
  <pre><code>feld = [5, 55, 555, 5555, 55555] # 1Pkt.
  
  print("Output:")
  print(feld[0]) # 0,5 Pkt.
  print(feld[4]) # 0,5 Pkt.
  print(feld[2]) # 0,5 Pkt.
  
  feld[1] = 42 # 1Pkt.
  
  for z in feld: # 1,5 Pkt
      print(z, end=", ") #0,5 Pkt. ("end" is not relevant)
  print()
  
  print(feld[:2]) # 0,5 Pkt.
  print(feld[2:])     # 0,5 Pkt.
  print(feld[::-1]) # 0,5 Pkt.
  print(feld[::2]) # 0,5 Pkt.
  
  summe = 0 #0,5 Pkt.
  for z in feld: # 1 Pkt.
      summe += z # 1 Pkt.
  print("Summe =", summe) #0,5 Pkt.
  </code></pre>
  
  <p>The problem becomes more difficult the larger the assignments are and the more variations you are having in the solutions. You could still try to decompose the overall problem and give points for parts of the solution.</p>
  
  <p>In general, I suggest that you try to avoid to have different grades for the same (sub-)task - this ensures at least consistency of the grades. </p>
  
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2019-01-06T11:17:45.833Z
Answers.LastActivityDate: 2019-01-06T11:17:45.833Z
Answers.UserDisplayName: OBu
Answers.Body: <p>Grading coding assignments should consist of the following parts</p>
  
  <ul>
  <li>automated tests</li>
  <li>plagiarism checks</li>
  <li>code quality (lint checks)</li>
  <li>a short manual review of each submission</li>
  </ul>
  
  <p>If the tests are written properly, I would imagine that anyone who passes the automated tests, plagiarism checks, and code quality checks should qualify for at least a B (or the equivalent in your course). On top of that, the manual review of the code determines whether the student used the correct approach and whether the submission matches expectation. This is where the student can reach A or A+.</p>
  
  <p>There are many tools that can help you streamline this process. I recommend checking <a href="https://autogradr.com" rel="nofollow noreferrer">AutoGradr.com</a> (disclaimer: I'm one of the authors)</p>
  
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2019-05-14T16:17:43.460Z
Answers.LastActivityDate: 2019-05-14T16:17:43.460Z
Answers.UserDisplayName: tusharsoni
Answers.Body: <p>This is what I have for my Java assignments. Notice that this is not a programming course, but an algorithms course.</p>
  
  <ol>
  <li><p>Compiling and running (8 points)</p>
  
  <p>1.a 0 points if the program doesn't compile. No points for the rest. Grading complete.</p></li>
  </ol>
  
  <p>1.b If the code compiles and runs:</p>
  
  <pre><code>a   Full points if it succeeds in all test cases.
  b   0.5 deducted for each failing test case.
  </code></pre>
  
  <p>2. Readability and submission (2 points)</p>
  
  <pre><code>2.1 Documentation (Oracle official)
      a. 0.5 points for complete commenting
      b. 0.4/0.2/0 (%) if we detect 0-25/25-50/75-100 (%) missing comments where expected.
      You should at least use clear commenting for the following:
  
          a. Classes and interfaces
          b. Fields
          c. Methods, including all input parameters and return values
  
  2.2 Indentation (Oracle official)
  
      a. 0.5 for appropriate indentation
      b. 0.4/0.2/0 (%) for 3/6/more violations
  </code></pre>
  
  <p>2.3 Submission:</p>
  
  <pre><code>(0) 1 points for (not) correctly following the requirements for submission.
  </code></pre>
  
  <p>I would appreciate your feedback on this.</p>
  
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2019-01-10T22:12:05.723Z
Answers.Text: Welcome to [cseducators.se] and thank you for a nice anwer. Once you have enough [Reputation](https://cseducators.stackexchange.com/help/whats-reputation) (20pts.), why don't you stop by the sites chatroom [The Classroom](https://chat.stackexchange.com/rooms/59174) to discuss this, but my sense here is that this would make a good question on its own. The concept of feedback doesn't work well in comments, which are considered ephemeral here, but could make good answers to a question. Not that it is not also a good answer to this question, of course.
Answers.UserDisplayName: Gypsy Spellweaver
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2019-01-10T18:03:11.597Z
Answers.LastActivityDate: 2019-01-10T18:03:11.597Z
Answers.UserDisplayName: CS Instructor
Answers.Body: <p>Since the nature of your question implies sharing personal experience rather than providing some guidelines grounded on hard evidence, I'll take the liberty to share mine.</p>
  
  <p>In the past I tried to develop a fine-grained scheme for my courses, but now I think it was a mistake. Such schemes cause more troubles than they do good: they are difficult to follow for the graders, students ask why someone got 8 points instead of 9 points, and there is too much room for subjective interpretation.</p>
  
  <p>After years of teaching, I realised a simple thing: we must separate educational goals from the grading process. As an educator I strive to provide the best explanations as I can and I try to give them examples of good code and show the difference between good and bad practices. However, as a grader, I only have to rank students according to their performance, and my practice shows that <em>regardless of the scheme</em> the same students tend to go up or down. Therefore, I try to simplify my scheme every year.</p>
  
  <p>Thus, currently I tend to focus on rather short assignments, each taking at most 2-3 hours to accomplish for a skillful student. Then I grade each of them on the scale 0-3 and give the same weight for each assignment (this is of course simplification as they aren't equal, but it works reasonably well).</p>
  
  <p>The subsequent logic is as follows:</p>
  
  <ul>
  <li>0 - empty submission / plagiarism / doesn't compile </li>
  <li>1 - passes some tests </li>
  <li>2 - passess most tests, but fails sometimes </li>
  <li>3 - perfect submission</li>
  </ul>
  
  <p>Sometimes I extend it to 0-5 if I want to ask some additional questions that had to be answered within their submission and/or want to give an additional point for coding style.</p>
  
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2019-01-07T09:52:13.737Z
Answers.Text: And tests should be automated, and published so students know what they have to do, and can test their own code.
Answers.UserDisplayName: ctrl-alt-delor
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2019-01-11T22:27:24.680Z
Answers.Text: Personally, I think that if you are using an automated test suite, those test should not be published. Using a website like gradescope, you can allow students to run the tests as many times as they wish, but the risk is that they just hard-code in the solutions to the individual test cases.
Answers.UserDisplayName: Green Griffin
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2019-01-06T11:08:55.770Z
Answers.LastActivityDate: 2019-01-06T11:08:55.770Z
Answers.UserDisplayName: rg_software
Answers.Body: <p>When students are learning to program they should be focused on more than getting the "right" answer. If a pro is writing quick-n-dirty code that will be discarded, the answer is important. But in all other cases, a program will have a lifetime and this needs to be considered. Therefore it also needs to be taught - and learned. Focusing too much on details works against this goal. </p>
  
  <p>The rubric should reward correctness, of course, but it should also reward structure. It should <em>not</em> reward speculative programming, however: programming that <em>might</em> be useful in the future but isn't now. </p>
  
  <p>But, in my view, the comments that are put on the students work should be more important than the points assigned. This is how you teach individual students and get them to advance. I realize that in the modern world, if you are teaching 800 students and have a staff of 40 to help you do it, someone else has to provide those specific comments. But if you ignore that altogether you are leaving the world of teaching and entering the world of pure performance - like a play - where there are not real requirements on the "audience". </p>
  
  <p>It is also difficult to justify a too specific grading rubric. If one student has earned 88 points and another has 89 or 90, can you say that there is some essential difference in their learning? Broad grading categories and the opportunity to revise work are much more valuable to the student than a strict point scale. It also lessens the need, in their minds, to argue about small points - especially when they need guidance and practice on bigger ones. </p>
  
  <p>If the scale is very large, it is useful to have a meeting with the graders before grading begins, but after some of the papers have been looked at (briefly). Only then can you get an idea about what is needed. Making it perfectly objective isn't the goal. The goal is to elicit change in the brains of the students. It will help, in such situations if the TAs have a stable set of students to work with, so that they can help with the individual guidance. To do this and to assure some uniformity can be difficult, of course. It might require that grades and comments are reviewed, perhaps by another TA than the one that normally works with a given student. </p>
  
  <p>Note, that I may be defining "improve the grading process" differently than you originally did. To me, things only improve if the students skills improve. Everything else should work to achieve that. </p>
  
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2019-01-07T09:58:38.767Z
Answers.Text: I can't remember the name of the study. But if you give sumative feedback (grades), then you negate formative feedback, and learning. You can measure or you can teach, you have to choose. It may be that you can separate these things.
Answers.UserDisplayName: ctrl-alt-delor
Answers.ContentLicense: CC BY-SA 4.0
Answers.CreationDate: 2019-01-06T17:33:34.730Z
Answers.LastActivityDate: 2019-01-07T09:53:46.273Z
Answers.LastEditDate: 2019-01-07T09:53:46.273Z
Answers.UserDisplayName: Buffy
Body: <p>I'm trying to improve the grading process and I need to write some guidelines for the graders. Students submit Java code for the assignments. Any ideas/suggestion about how to structure the grading?</p>
  
Comments.ContentLicense: CC BY-SA 4.0
Comments.CreationDate: 2019-01-20T02:17:48.443Z
Comments.Text: A course may have mixed objectives. For example, when given an assignment to sort an array, the student may struggle with the development environment, the algorithm, the syntax, the analysis of the problem, writing test data, naming variables, programming structure, proper indenting of code and of course the programming paradigm. The course must have a specific set of objectives and using these objectives the marking can be set accordingly by giving the appropriate weight to each of the above factors.
Comments.UserDisplayName: NoChance
Tags: <grading>
Title: How to write a grading rubric for coding assignments?
ThreadText: # How to write a grading rubric for coding assignments?
  
  (Asked by: username_0 on 2019-01-06)
  
  I'm trying to improve the grading process and I need to write some guidelines for the graders. Students submit Java code for the assignments. Any ideas/suggestion about how to structure the grading?
  
  **Tags:** grading
  
  > **Comments:**
  > **username_1**: A course may have mixed objectives. For example, when given an assignment to sort an array, the student may struggle with the development environment, the algorithm, the syntax, the analysis of the problem, writing test data, naming variables, programming structure, proper indenting of code and of course the programming paradigm. The course must have a specific set of objectives and using these objectives the marking can be set accordingly by giving the appropriate weight to each of the above factors.  
  
  ---
  
  ## 5 answers
  
  ### Answer by username_4 on 2019-01-10. Score: 5
  
  This is what I have for my Java assignments. Notice that this is not a programming course, but an algorithms course.
  
  1. Compiling and running (8 points)
  
     1.a 0 points if the program doesn't compile. No points for the rest. Grading complete.
  
  1.b If the code compiles and runs:
  
  ```
  a   Full points if it succeeds in all test cases.
  b   0.5 deducted for each failing test case.
  
  ```
  
  2. Readability and submission (2 points)
  
  ```
  2.1 Documentation (Oracle official)
      a. 0.5 points for complete commenting
      b. 0.4/0.2/0 (%) if we detect 0-25/25-50/75-100 (%) missing comments where expected.
      You should at least use clear commenting for the following:
  
          a. Classes and interfaces
          b. Fields
          c. Methods, including all input parameters and return values
  
  2.2 Indentation (Oracle official)
  
      a. 0.5 for appropriate indentation
      b. 0.4/0.2/0 (%) for 3/6/more violations
  
  ```
  
  2.3 Submission:
  
  ```
  (0) 1 points for (not) correctly following the requirements for submission.
  
  ```
  
  I would appreciate your feedback on this.
  
  > **Comments:**
  > **username_5**: Welcome to [cseducators.se] and thank you for a nice anwer. Once you have enough [Reputation](https://cseducators.stackexchange.com/help/whats-reputation) (20pts.), why don't you stop by the sites chatroom [The Classroom](https://chat.stackexchange.com/rooms/59174) to discuss this, but my sense here is that this would make a good question on its own. The concept of feedback doesn't work well in comments, which are considered ephemeral here, but could make good answers to a question. Not that it is not also a good answer to this question, of course.  
  
  ---
  
  ### Answer by username_6 on 2019-01-06. Score: 4
  
  Since the nature of your question implies sharing personal experience rather than providing some guidelines grounded on hard evidence, I'll take the liberty to share mine.
  
  In the past I tried to develop a fine-grained scheme for my courses, but now I think it was a mistake. Such schemes cause more troubles than they do good: they are difficult to follow for the graders, students ask why someone got 8 points instead of 9 points, and there is too much room for subjective interpretation.
  
  After years of teaching, I realised a simple thing: we must separate educational goals from the grading process. As an educator I strive to provide the best explanations as I can and I try to give them examples of good code and show the difference between good and bad practices. However, as a grader, I only have to rank students according to their performance, and my practice shows that *regardless of the scheme* the same students tend to go up or down. Therefore, I try to simplify my scheme every year.
  
  Thus, currently I tend to focus on rather short assignments, each taking at most 2-3 hours to accomplish for a skillful student. Then I grade each of them on the scale 0-3 and give the same weight for each assignment (this is of course simplification as they aren't equal, but it works reasonably well).
  
  The subsequent logic is as follows:
  
  * 0 - empty submission / plagiarism / doesn't compile
  * 1 - passes some tests
  * 2 - passess most tests, but fails sometimes
  * 3 - perfect submission
  
  Sometimes I extend it to 0-5 if I want to ask some additional questions that had to be answered within their submission and/or want to give an additional point for coding style.
  
  > **Comments:**
  > **username_7**: And tests should be automated, and published so students know what they have to do, and can test their own code.  
  > **username_8**: Personally, I think that if you are using an automated test suite, those test should not be published. Using a website like gradescope, you can allow students to run the tests as many times as they wish, but the risk is that they just hard-code in the solutions to the individual test cases.  
  
  ---
  
  ### Answer by username_9 on 2019-01-06. Score: 3
  
  When students are learning to program they should be focused on more than getting the "right" answer. If a pro is writing quick-n-dirty code that will be discarded, the answer is important. But in all other cases, a program will have a lifetime and this needs to be considered. Therefore it also needs to be taught - and learned. Focusing too much on details works against this goal.
  
  The rubric should reward correctness, of course, but it should also reward structure. It should *not* reward speculative programming, however: programming that *might* be useful in the future but isn't now.
  
  But, in my view, the comments that are put on the students work should be more important than the points assigned. This is how you teach individual students and get them to advance. I realize that in the modern world, if you are teaching 800 students and have a staff of 40 to help you do it, someone else has to provide those specific comments. But if you ignore that altogether you are leaving the world of teaching and entering the world of pure performance - like a play - where there are not real requirements on the "audience".
  
  It is also difficult to justify a too specific grading rubric. If one student has earned 88 points and another has 89 or 90, can you say that there is some essential difference in their learning? Broad grading categories and the opportunity to revise work are much more valuable to the student than a strict point scale. It also lessens the need, in their minds, to argue about small points - especially when they need guidance and practice on bigger ones.
  
  If the scale is very large, it is useful to have a meeting with the graders before grading begins, but after some of the papers have been looked at (briefly). Only then can you get an idea about what is needed. Making it perfectly objective isn't the goal. The goal is to elicit change in the brains of the students. It will help, in such situations if the TAs have a stable set of students to work with, so that they can help with the individual guidance. To do this and to assure some uniformity can be difficult, of course. It might require that grades and comments are reviewed, perhaps by another TA than the one that normally works with a given student.
  
  Note, that I may be defining "improve the grading process" differently than you originally did. To me, things only improve if the students skills improve. Everything else should work to achieve that.
  
  > **Comments:**
  > **username_7**: I can't remember the name of the study. But if you give sumative feedback (grades), then you negate formative feedback, and learning. You can measure or you can teach, you have to choose. It may be that you can separate these things.  
  
  ---
  
  ### Answer by username_2 on 2019-01-06. Score: 2
  
  What I'm doing is: I give points for each relevant idea / concept in the program. E.g. if you have to loop through a data structure and you have to do something with the content, I would give point for the loop construction and points for the content.
  
  The graders can now check whether the loop is correct and if the inner content is correct and give points for this. If students use a different technique (e.g. while instead of for), they can still decide whether the loop is doing as intended and give the points.
  
  If you are insisting in specific soliutions (e.g. you *have* to use a "for"-loop), you should note this. Still, it would be possible to get some points for the content.
  
  For a simple test about python lists this could look like this:
  
  ```
  feld = [5, 55, 555, 5555, 55555] # 1Pkt.
  
  print("Output:")
  print(feld[0]) # 0,5 Pkt.
  print(feld[4]) # 0,5 Pkt.
  print(feld[2]) # 0,5 Pkt.
  
  feld[1] = 42 # 1Pkt.
  
  for z in feld: # 1,5 Pkt
      print(z, end=", ") #0,5 Pkt. ("end" is not relevant)
  print()
  
  print(feld[:2]) # 0,5 Pkt.
  print(feld[2:])     # 0,5 Pkt.
  print(feld[::-1]) # 0,5 Pkt.
  print(feld[::2]) # 0,5 Pkt.
  
  summe = 0 #0,5 Pkt.
  for z in feld: # 1 Pkt.
      summe += z # 1 Pkt.
  print("Summe =", summe) #0,5 Pkt.
  
  ```
  
  The problem becomes more difficult the larger the assignments are and the more variations you are having in the solutions. You could still try to decompose the overall problem and give points for parts of the solution.
  
  In general, I suggest that you try to avoid to have different grades for the same (sub-)task - this ensures at least consistency of the grades.
  
  
  ---
  
  ### Answer by username_3 on 2019-05-14. Score: 0
  
  Grading coding assignments should consist of the following parts
  
  * automated tests
  * plagiarism checks
  * code quality (lint checks)
  * a short manual review of each submission
  
  If the tests are written properly, I would imagine that anyone who passes the automated tests, plagiarism checks, and code quality checks should qualify for at least a B (or the equivalent in your course). On top of that, the manual review of the code determines whether the student used the correct approach and whether the submission matches expectation. This is where the student can reach A or A+.
  
  There are many tools that can help you streamline this process. I recommend checking [AutoGradr.com](https://autogradr.com) (disclaimer: I'm one of the authors)
  
  
  ---
  
  