10
$\begingroup$

I teach undergraduate programming project courses and have traditionally given the same project grade (about 45% of the semester grade) to everyone on each team, unless a team member's participation was clearly minimal, in which case I deduct points from that student's project grade, but I do not add points to other teammates'.

A student complained about their grade not reflecting the amount of work they put in, which was substantially more than their other teammates. I can sympathize with the complaint, although I pointed out to the student that I had followed the syllabus and project grading guide and that they had learned more and would get a better letter of recommendation than students who contributed less.

I would like for students' project grades to reflect their contributions, but just grading projects is time-consuming and difficult enough. What ways have teachers found to provide individual grades on team projects?

$\endgroup$
  • $\begingroup$ Related: Is it possible to ensure division of labor on a group assignment? (at least on the aspect of one student putting in more work than another) $\endgroup$ – Aurora0001 Jun 3 '17 at 17:07
  • $\begingroup$ Thank you for the pointer, although my goal is not to ensure that students do equal work. $\endgroup$ – Ellen Spertus Jun 3 '17 at 17:09
  • $\begingroup$ Could you please clarify the learning objective(s) and the assessment method that gave rise to this particular situation? $\endgroup$ – Adrir Jun 6 '17 at 21:18
  • 1
    $\begingroup$ I believe the learning objective should inform the approach to assessment. So, if the learning objectives are specifically related to teamwork, then the use of single-blind peer assessment via systems like SparkPLUS can be effective. Particularly where students rate each others' collegiality, work ethic, ability to collaborate on particular tasks, etc. Students use a rubric and justify their rating by making comments, which I use to write a brief meta-review as feedback for the team. $\endgroup$ – Adrir Jun 6 '17 at 21:19
10
$\begingroup$

In "Assessing Individual Contributions to Group Software Projects" (WCCCE '03), William Gardner discusses a number of strategies for adjusting team programming project grades for individual performance and ends by recommending a "share-out" approach:

The essence of share-out is that each student is conceptually given a pot of points, and must allocate them among their peers based on some stated criteria. The allocation then represents that student’s numerical evaluation of his or her team members.

In order to provide a straightforward, effective criterion for the sharing out, each student was given 100 points and told to allocate them according to the amount of credit each team member deserved in terms of the total project work. The term “credit” was intentionally selected to be both intuitive and elastic, a single metric that could easily serve as a proxy for time and quality of effort....

Students were required to give themselves at least 100/N points, in recognition that there would likely be little enthusiasm for self-incrimination, but then the self-evaluations were not averaged in with those of the team members. With this constraint in place, ethical struggles over whether to admit one’s own poor performance were shunted aside. If some students really performed poorly, their team members could do the dirty work; their own confessions were not required, nor could their grade be inflated by making phony claims.

The paper provides further details.

Update: Since the paper is 14 years old, I contacted the author to ask if he has any updates. He kindly replied that he had not taught a software engineering course since then so had no further experience to report and that he stands by his recommendation.

$\endgroup$
  • 2
    $\begingroup$ I love this idea for groups of 4 or greater! It seems like 3 would start to break down, and groups of 2 might no longer be accurate. What adjustment could be used for paired projects? $\endgroup$ – Ben I. Jun 4 '17 at 1:36
  • $\begingroup$ I seen this work well, with students not being able to give themselves credits and the lowest and highest credit each student got being ignored. $\endgroup$ – Ian Ringrose Jul 24 '17 at 13:10
4
$\begingroup$

I also like group programming projects (usually pairs, so some of the mutual grading ideas, which I like, don't apply). What I do is have an early phase of the project be a co-authored "plan" document that crucially, includes specific tasks for each member. I make the assumption that they can divide the work equitably or that they can re-negotiate later. Later in the semester, if one partner is lagging behind (and I have one or two such occurrences every semester), I have a way to verify that one person did more and so can adjust the grade accordingly.

But, yes, this does add to the work of grading, and I try to default to equal grades when I can.

What I am thinking of doing in the future is to have the "plan" document include contingency planning: what the team will do if someone is unable to do their share of the work. I will point out that rarely does someone slack off due to laziness; it's more often due to distractions from personal illness, death in the family, and other issues. That helps avoid some of the embarrassment of saying "I didn't do what I said I would."

$\endgroup$
2
$\begingroup$

I've been pondering the same problem, and I've come up with an experiment to try next year: let the students discuss the division of labor among themselves, but once they've decided how to proceed, they should write down what they came up with and submit that to you.

I wouldn't pull these back out unless it's needed, but if there is trouble, it gives you an easy way to grade the individual contributions. Also, if the lower contributions of one student prevented the project from getting completed, or forced the other students to have to do more, you now possess the justification for giving the worker bees full credit even on a partially completed project.

$\endgroup$
  • $\begingroup$ It's an interesting idea, although I want to encourage collaboration and people stepping in where needed. It's an Android programming class, and some things that seem like they'll be easy may turn out to be hard, and vice versa. $\endgroup$ – Ellen Spertus Jun 4 '17 at 1:11
  • 1
    $\begingroup$ I see what you mean. If students want to revise it and all agree, they can do it and not even let me know. It would only ever even come up again if the group dynamic isn't working. By the time it's gotten bad enough that someone is talking to the teacher, preserving the spirit of collaboration seems like a cause already lost. $\endgroup$ – Ben I. Jun 4 '17 at 1:13
  • $\begingroup$ Can you give us an update? $\endgroup$ – Ellen Spertus Oct 16 '18 at 1:26
  • $\begingroup$ @EllenSpertus I'm sorry to say that my update is that I forgot about this entirely. In the interim, I had a kid, and have been rather distracted. I should still try it! $\endgroup$ – Ben I. Oct 16 '18 at 3:20
1
$\begingroup$

I have met teachers that deal with that issue like this:

First, teach the students about version control, and introduce GitHub, and tell them that they need to create an account. Then say that each group should have their projects in a repository.

Then ask the students to provide a link to the repository, along with the project. This allows you to see on GitHub how much work each student contributed.

GitHub allows you to see a person's contribution (# of commits etc.), so this method is quite convenient.

$\endgroup$
  • 1
    $\begingroup$ We do use GitHub. While provided statistics give some indication of contributions, # of commits or lines of code doesn't take into account pair programming, boiler-plate code, automatically generated files (such as javadoc), debugging, documentation, design, time spent on code reviews, etc. $\endgroup$ – Ellen Spertus Jun 3 '17 at 18:10
  • $\begingroup$ @EllenSpertus no but you can see the activity graph, that shows you some useful information $\endgroup$ – ItamarG3 Jun 3 '17 at 18:12
  • 1
    $\begingroup$ How do you grade the student that contributed work equal to or greater than the others, yet needed few commits since their code was near-correct from the beginning? The activity graph, etc. won't show much work, yet they've easily earned their credits. $\endgroup$ – Gypsy Spellweaver Jun 3 '17 at 20:12
  • $\begingroup$ @GypsySpellweaver - Well, GitHub shows number of additions and deletions as well as commits. So overall, it can be used to see a student's contribution. $\endgroup$ – ItamarG3 Jun 3 '17 at 20:23
  • $\begingroup$ Please note! Github's statistics are VERY VERY inaccurate - they have officially stated over and over again that you should never use them for anything official. I can, for instance, point you to mainstream git clients that will silently zero the submission stats for a contributor to github, due to quirks of the protocol. Yes to monitoring, but DO NOT USE Github's fancy web-based graphs, they are literally not correct. $\endgroup$ – user31 Jun 7 '17 at 16:01
1
$\begingroup$

This is one of the reasons I rarely make use of group work in teaching. It is a minefield of problems. Would it be possible to get students to produce a document prior to starting work agreeing who is going to do what? Alternatively in exam boards team leaders are provided with suggested grades based on what the system says individual markers have done (error rate, completion rate, etc) and then the team leader is asked to award grades to the individual markers, varying from suggested grades if necessary. Could this approach be made to work for your situation?

$\endgroup$
1
$\begingroup$

While, in general, I prefer that students on a team get the same grade for the work (see below) I also ask each student on a team to fill out a questionnaire at the end. The questions are simple. Assuming a team of about five, I'll ask each student to name the three most valuable members of the team and to list the contribution of each. They may name themselves as one of the three and are told that. I also ask each "What was your own principal contribution?". For a pair, I ask each, to give the partners main contribution and their own.


The reason for a default equal grade is to have the system encourage sharing and contributing. In Agile Development, one of the key ideas is that the Team shares in the success and reward of the project. It is not up to the team's manager to pick winners and losers on a team. I extend that idea to the classroom.

But I keep my eyes open, of course.

However, most teams do much of their work outside my view. I seldom respond positively to complaints about team members (and get only a few), reminding the complainer that it is also their responsibility to foster team work.

Also, the students need to know that the "product" I'm most interested in isn't their program (or whatever) but the learning. If the project "fails" the students can still succeed. The educational process should be a "safe zone" where you are not yet expected to perform at a professional level.

$\endgroup$

Your Answer

By clicking "Post Your Answer", you acknowledge that you have read our updated terms of service, privacy policy and cookie policy, and that your continued use of the website is subject to these policies.

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