
University of Illinois issues DMCA takedown for previous years' homework - ecaron
https://github.com/github/dmca/commit/313ac74e3de8b692adfed5ef2bf60436aa8e2040
======
madaxe_again
This doesn't strike me as unreasonable, given that they likely maintain the
same syllabus for a number of years, and having multiple solutions for
academic assignments out there in the wild will encourage less diligent
students to neglect their own education.

There's also the question of plagiarism. As an undergrad, I'd often post my
work on my site when I handed it in. I stopped this practice when I got a 0 on
a major bit of coursework (cost me a grade boundary in my degree...), as their
software found it online, on my site, and they refused to view my work as
anything but plagiarism. This action potentially saves students from the same
fate.

~~~
akerl_
It seems fairly clear that the repos listed violate the ethical rules that the
university has set, and it's entirely possible that it will aid plagiarists.

That said, the DMCA does not prohibit students from encouraging others to
neglect their own education, it exists to enforce copyright. IANAL, but their
case that they own the copyright over the repos because their syllabus
includes the questions being solved doesn't seem very solid.

~~~
LLWM
It's not visible due to the takedowns, but if the students are including the
original copyrighted work in its entirety, with their own original additions
bundled in, it seems like the DMCA should apply. That's why commentary stuff
like MST3K either only distributes their own additions or pays license fees to
the copyright holders.

~~~
akerl_
Granted. In that case, this seems fairly easy for the folks who own the repos:
Strip the university's IP from their code and re-release. It's a bit obnoxious
because it'll gut the git history, but they have a clear path forward.

------
ianamartin
Seems to me that a university's computer science department should have a
better way to deal with plagiarism than this.

From
[https://news.ycombinator.com/item?id=8806910](https://news.ycombinator.com/item?id=8806910)
there's a link to
[http://matt.might.net/teaching/compilers/spring-2015/](http://matt.might.net/teaching/compilers/spring-2015/)

and I quote: ''' How to cheat in this class

I've caught so many attempts at cheating in my courses that I feel the need to
provide a guide to students.

You may not use code you found on the web, even if modified. You may not use
code you found on the web, even if it's GPL'd. Do not turn in code with a
matching md5sum for your friend's assignment. You can't simply change comments
and spacing. I can tokenize your input to eliminate these differences. You
can't just change variable names. I'm going to diff a token stream of your
assignment against others. You can't just move definitions around. Same reason
as before. You can't copy only part of an assignment. Same reason as before.
If you're going to cheat, you need to rewrite the assignment from scratch. '''

~~~
bumeye
Yes it's common to have software which can find plagiarism like that. However,
if the student actually does these things (change all variable names and move
code around) it will be hard for an examination board to decide whether this
is a false positive or real plagiarism.

------
belorn
The DMCA notice is likely incomplete. "a large portion of the uploaded code"
can not in any reasonable way be specific enough to identify the infringing
material.

Thanks to it being incomplete, the owner of the github accounts can not create
a defense, nor try make any changes for compliance. That should be a clear
sign that the notice is unreasonable vague in the description and thus need to
be denied until a complete notice has been sent.

------
colechristensen
It would likely be trivial to win on the grounds of fair use for educational
purposes. Upper education that relies on graded homework is, in my opinion,
broken anyway. In engineering, my greatest course experiences were those where
the answers were given in full when the exercises were assigned. The feedback
you get by checking yourself while you are doing the work is immensely more
valuable than getting graded papers returned weeks after you've done them.

This, of course, allows people who don't want to learn to avoid learning, but
it's the university's job to certify that you have learned things and make
available the resources to learn. Policing you to learn with the graded
assignments game leads to a lot of people who are really good at playing, not
so good at having interest in their work or the actual material. (I knew so
many people who succeeded through grey-ethical finding answers through peers
and instructor's guides ... 10 people collaborating to each to 1/10th of the
assignment, etc.)

------
moosey
I'm just jealous that university students these days have git. I had to walk
through the snow uphills both ways while I was working on my CS degree.

~~~
spacemanmatt
Or even Google, for that matter. Remember libraries?

------
akerl_
Is anybody aware of the reasoning behind the redacted links? It looks like
only one past DMCA in this repo has received similar treatment:

[https://github.com/github/dmca/blob/4e465059012c946abd3f2fa2...](https://github.com/github/dmca/blob/4e465059012c946abd3f2fa2cc1633cdd20fe2cc/2014-10-08-CS225.md)

Their README suggests they only redact personally identifying info, but I
assumed that was in reference to the submitter (if an individual), as the
other repos didn't receive any redaction.

------
sjreese
The University has no ownership?? Does the Public library have ownership if I
build a program based on a book "CS241 System Programming - Here and Now" ..
The Preferssor has not written or updated the work of Mr Chou - and therefore
has no standing as to DMCA - It's all a UofI Buff - and GitHub folded ..
[https://github.com/mukichou/cs241-2](https://github.com/mukichou/cs241-2)

------
sprkyco
At my university we reviewed and assessed each others code to identify issues
and help each other out. It is possible that I am misunderstanding if this
applicable for this specific course. My presumption is that a vast majority of
students are going to school to acquire gainful employment and jobs often
require some level of code reviewing. While I do not support direct copying of
someone else's homework or the distribution of a github link containing the
answers to homework to students (this did not happen here but would be
evidence of assisting cheating). It seems that the benefits of teaching
students about version control and in depth peer code review outweigh the
negative consequences of this type of "cheating". ianamartin earlier in this
thread provided this link:
[http://matt.might.net/teaching/compilers/spring-2015/](http://matt.might.net/teaching/compilers/spring-2015/)
which is honestly the "best" solution to this particular issue.

------
lettergram
Kind of amazing this is against the universities own stance on copyright
ownership:

"Works created independently and at the student’s own initiative for
traditional academic purposes are owned by the student, but the University
retains certain rights to use such works. These include class notes, reports,
papers, and works prepared by the student as part of the requirements for a
University degree, such as a thesis or dissertation. Note that it is the
copyright only that is owned by the student. The fact that the student owns
the copyright does not influence whether or not the student owns the
underlying intellectual property. For example, if a thesis describes research
performed in a professor’s laboratory, the University has a right to own the
underlying intellectual property (e.g. laboratory notebooks, original records
of the research and any resulting inventions or software.)"

[http://otm.illinois.edu/studentownership](http://otm.illinois.edu/studentownership)

------
calibwam
As this is an issue of copyright violation, I don't have any issue with this.
A DMCA complaint fixes just this.

A few years ago I got an email from a TA in a subject I took the year before,
that they wanted me to take down solutions I hosted on Github. However, there
was no provided code in the assignment, and it was basically implementations
of previously known algorithms (A* among others). Not a formal takedown
request, but they said I should understand that they had to use the same
assignments each year, and if I were providing solutions this could be hard.
My answer was that if they are worried about plagiarism, it's better that my
solutions are public, as they can be checked against.

~~~
lmm
It's not a copyright violation though, or at least not inherently. The
statement of a homework problem is essentially an API, and if those are
copyrightable then we're in big trouble as an industry.

~~~
calibwam
Well, we can't see the code that is taken down here, but if assignment had a
lot of set up code, and the assignment was to fill in some functions, there
can be a copyright violation. If these repositories only included student made
code, then I agree that there is a problem.

~~~
nickofbh
I'm a student in CS@Illinois and I took this class last semester. For
assignment one, they gave us a library and the following where we had to make
a working shell (sorry for formatting):

/ __@file shell.c _/ #include <stdio.h> #include <unistd.h> #include
<stdlib.h> #include <string.h> #include <sys/types.h> #include <sys/wait.h>
#include <unistd.h> #include "log.h"

    
    
      log_t Log;
    
      /**
       *  * Starting point for shell.
       *   */
      int main(int argc, char ** argv) {
          /**
       *       * Analyze command line arguments
       *             */
          while(1)
          {
      	/**
       * 	 * Print a command prompt
       * 	 	 */
      	
      	
      	/**
       * 	 * Read the commands
       * 	 	 */
      	
      	
      	/**
       * 	 * Print the PID of the process executing the command
       * 	 	 */
      	
      	
      	/**
       * 	 * Decide which actions to take based on the command (exit, run program, etc.)
       * 	 	 */
          }
          return 0;
      }
    
    

The provided code is rather sparse (by design), but the University holds
copyright on it.

~~~
lmm
You can use four leading spaces at the start of each line for a code block.

What you've posted doesn't look substantial enough to be copyrightable to me;
the idea of writing a main containing a while loop is certainly not original
to the university, and the comments would presumably not be present in this
repo since they'd've been replaced by working code. I sure hope the university
of Illinois doesn't own the copyright on any shell _I_ write from now on,
because that would be ridiculous.

------
nickofbh
I can speak to this since I actually took this class last semester (Fall
2014).

Homework boilerplate is distributed to students through private SVN. This
typically includes some method headers or libraries. We then complete the
assignment to specifications and commit it through SVN, where it is graded
programmatically. Therefore, we can't modify some of the headers.

The class has been taken over by a new professor. As such, it is being totally
restructured and the assignments are largely being changed now. However, when
I took the class with 250+ other students, plagiarism was rampant.

As far as I'm aware, the course staff has indeed contacted individual repo
owners on Github for take down.

------
jsaxton86
This seems reasonable to me. Pretty much every academic code of conduct
requires students not to publish solutions to homework problems. This doesn't
prevent the use of git, just git public repositories.

Rather than just issue DMCA takedown notices, it might be useful for the
University of Illinois to provide students with access to private git
repositories. Of course, I suspect many students have drank the "github is
your resume" kool-aid and would be less likely to use private repositories.

------
danielnaab
Sharing of previous semester code (or quizzes, exams, etc) should _enhance_
the learning process, not hinder it.

This is a bad and lazy policy for a school. Instructors should be creating
assignments that cover the same material but are sufficiently different from
one semester to the next that cheating isn't a problem.

When I was in school 15+ years ago, we had officially sanctioned ways of
sharing materials from previous semesters of coursework. Is that uncommon?

------
nadams
Disclaimer: I went through college and currently teach part time. I wish
something like github was around when I was in college - I only got into self-
hosted SVN repos near my senior years. As a professor - I believe in
transparency when it comes to my classes.

tl;dr; What should have happened is that UofI should have worked with github
to turn those repos into (free) private ones. That way the content is removed
from the public and search indexes and the students can still use/review the
material they created in the class later on if they want to.

I have only taught 3 classes/2 subjects - object oriented (heavy programming),
and operating systems (light usage). I run my own source code hosting service
and will pre-provision private repos for them (for free obviously). I also
encourage them to get private repos from github (you can get it for free if
you need it for a class) if they don't like mine (I am not one of those
teachers who force them to use their book or service - students are free to
use whatever resource they want....just maybe not CVS or RCS...).

I strongly recommend private because obviously I don't want other students to
copy their work (but I do encourage collaboration for homework). However, most
of my assignments are pretty open-ended to the point where I would notice
obvious plagiarism. A few students have created public git repos because they
aren't familiar with github or even git - which I am perfectly fine with. I
would rather change my assignments than force a student to take down their git
repo (which I should probably do anyways). The last thing that I would want is
for a student to have a negative association with using source code hosting
services like github.

Some comments suggest that the university may claim ownership over the code -
which may be BS depending on how the code was acquired. The university may
have paid some guy off the street to write this code and the university hired
a professor and said "you will use this code to teach your class". If this was
the case - then I could be ok with this takedown. If a professor wrote it in
their spare time for the class and the university is trying to claim ownership
- then I have a problem with it.

This does make me wonder - how many students requested private repos for their
classes and shoved the code there? They won't have their code taken down
obviously - so the only people who are punished are those trying to learn and
understand the class and git/github.

~~~
Aradalf
Also the ones who want their code in a public repo so that future employers
can review it.

------
Ledyard
The DMCA is only to get the repos down.

This is more of a service issue where the University probably doesn't provide
a standard git repo so students need to either set one up or have fun merging
by hand. Unfortunately they have chosen a public GitHub repo rather than a
private repo like BitBucket.

Really if the class they're in provided a git repo they wouldn't have this
issue.

------
spacemanmatt
Seems like a reasonable way to even the playing field between independent
students and members of academic and social fraternities, which traditionally
handed down homework and intelligence on professors that was extremely
valuable to a busy student.

------
punkcoder
So are they attempting to say that the work done by students as a form of
homework, is actually the property of the university?

~~~
clock86
No, often when assignments are given out you'll also give students large
chunks of code or libraries to modify or work with.

The DMCA says that is what the infringement is.

~~~
jabagawee
Would a diff/patch be DMCA-proof then? Or would it fall under derivative
works?

~~~
clock86
I'm guessing it is more likely that these repositories were searched for by
staff/professors than fully specific code was searched for.

I don't think you can claim that changing code absolves you of copyright
issues, it might make it harder to find though.

~~~
lmm
APIs shouldn't be copyrightable as they're necessary for interfacing. The
solution to a homework problem shouldn't be a derivative work of the problem,
and so it should be possible to distribute the solution in a way that doesn't
infringe on the university's copyright.

------
comboy
Seems a bit weird to me that university has copyright over homework done by
students (which is my understanding because otherwise this DMCA would be
baseless). It hasn't been the case at my university.

~~~
yoshuaw
Many universities have this policy, but given that students have to pay (!) to
enroll in a university it strikes me as odd that the university would then
presume to take control of all the work they produce.

~~~
bunderbunder
As a method of preventing plagiarism, it makes sense. Getting the copyright
for the code into the university's possession gives them legal standing to do
things like this.

Ideally, of course, there'd be a process for getting exemptions - I know I
would have been _irate_ if my alma mater had claimed ownership of the year's
worth of work I spent on my senior thesis project. But that's also code where
the risk of plagiarism is relatively low-impact, what with it being specific
to that particular project.

Answers to problem sets, though? Pfft, let them have it. I never had a reason
to look at any of it ever again, so the value of retaining ownership to me is
virtually nil. Whereas the value of having even a slight incremental
improvement in the protections universities use to help me not have to spend
quite so much time worrying about whether the kids I'm looking at hiring might
have cheated their way through college without ever picking up proper problem-
solving skills? Priceless.

~~~
dalke
"Getting the copyright for the code into the university's possession"

There is no copyright transfer agreement nor is this a work for hire. This
case at UIUC appears to be a copyright issue related to school provided
materials which were further modified by the students.

------
steven2012
What this is is an instance of an institution that doesn't want to create a
new syllabus every year. Students pay tens of thousands of dollars for a
modern education but the instructors simply rely on years old assignments year
after year. And somehow this are worried about ethics?

Is it really that hard or asking too much for this lazy department to tweak
the code so that it's different from prior years?

~~~
rhino369
Tweaking your assignments but keeping the main thrust is more efficient and
probably provides better experiences. The bugs get worked out, the professors
and instructors have worked through it.

The real issue is that students keep this stuff and pass it down year to year.

I remember taking ECE 451 at Illinois and someone had taken photographs of the
solutions that were posted on the wall for students to look it.

~~~
aet
There are way to identify weak students even when they google all the answers.
Base your grades on assignments, tests, projects, presentations, pop quiz,
etc.. you will see the pattern.

~~~
rhino369
Unless things have changed since graduated way back when, the homework /
machine problem sets were a fairly minor part of the grade.

Really only enough to fuck your spot on the curve if you got zeros on them.

Exams were like 80%+.

