How do students submit their assignments?


(Dhowe) #1

I think I am probably missing something obvious, but once students are done with their assignments, how do they submit a PR to the instructor, or otherwise submit it for grading?

So far I’ve used classroom to create an assignment (with private repos for each student), then distributed the link to students. Each student in the class has accepted their assignment, then made edits to the template I provided them as starter code. They have then committed their changes. All good.

Now, however, when they select ‘pull request’ they get an empty ‘compare changes’ window. If they first create a new branch from master , then select ‘pull request’, they get a message saying that master and their branch are the identical. Is there no way to submit a PR back to the instructor, as one would to an upstream after a fork?

Can someone advise on the simplest assignment submission workflow for new (non-technical) students working with private repos?



Aside: I've since figured out that if I create the starter-repo with an additional branch (called, for example, "reference", then they can work on "master" and then, by switching base and compare branches in the compare window, submit a pull-request comparing "master" and "reference", but it still requires the student to merge their own 2 branches, none of which is intuitive at all

Further, it still doesn’t allow a student to mark an assignment once-and-for-all as ‘finished’, or to allow the instructor to view the full assignment in the PR, or to allow the instructor to close assignments after a deadline (issues mentioned elsewhere here)…


(Dhowe) #2

Hello, anyone home (60 views and not one response) ?


(Alex Reinhart) #3

I’m not sure I understand the issue here. If the students create a new branch before they write their own code, then create a pull request from that branch, all of their code should appear in the PR. They won’t have to merge anything manually, since they (or the instructor) can close and merge the pull request automatically from the web interface. We use a PR label to indicate that the instructor approved of the code, rather than closing it because the student needs to resubmit.

The typical stumbling block in my course is that students forget to open a new branch before starting each assignment, and end up stuck.


(Dhowe) #4

Correct me if I’m wrong, but only the code since the last PR appears in the PR. So if they forget to do something, and end up submitting multiple PRs, each will have only part of the work.

And yes, students always forget to create a new branch (which should be expected, since there is no intuitive reason to do so when working alone on an assignment). I’ve suggested elsewhere that the system prompt students, upon acceptance of an assignment, to create a new branch (it might also block them from working directly on master)…


(Alex Reinhart) #5

Only if each PR is merged despite being incomplete. I believe that if a PR is closed not not merged, subsequent PRs from the same branch will include all the commits from that branch which are not on master.

Alternately, students can push new commits on the branch and they will be visible as part of an already open PR for that branch, so if they forget something and commit it after they had already opened a PR, they can just commit and push it.

There’s a lot of cognitive overhead for the students here, I agree. The branching, pushing, and PR workflow took a few weeks for our students this semester to get the hang of. I ended up creating a detailed checklist of steps to submit homework assignments, which I think helps a bit. I kind of wish for a workflow based on patches instead of commits representing snapshots – instead of reviewing a branch, we could review the patches comprising a new assignment. Alas.


(Dhowe) #6

Yes, well the common case for us is that students do a PR and immediately merge it, then realize at some time later that they have left something out, so they then do another PR, which then only contains the updates, not the original work.

But practically speaking, good teaching is about incremental increases in complexity, and the clone/branch/commit/pull-request/merge workflow is simply too complicated a first step, for non-technical creatives. Period. If we want to support these people (creative coders in the humanities, digital artists and writers, designers, sound-artists, etc.), we absolutely need a simpler workflow to ease them into using these tools. Without this, I can’t see continuing further down this path…


(Geoff Schmit) #7

I use GitHub classroom in conjunction with my LMS (Canvas). I used to have students branch my repository and create a pull request when they were done with the unit. This worked, but many students found the workflow challenging.

With the advent of GitHub classroom, I simply have students submit a link to their repository when they are done with the unit to an assignment on my LMS. This submission is how they signal that they are done and I can score their lab. I click on the submitted link, open their repository in my GitHub Desktop application and read and run their code. It has been working well for both my students and me so far this year.

geoff


(Dhowe) #8

Interesting, do they simply commit to their master branches? Also, what keeps them from continuing to work past the deadline, before the instructor has graded ?


(Geoff Schmit) #9

Yes, they only commit to their master branches. Students learning to sync and commit and avoid merge conflicts between school and home is sufficient for their first introduction to SCM. In the follow up course with more group work and longer-term projects, I’ll introduce branches and pull requests.

If they work past a deadline, and I don’t want them to do so, I can look at their commit history.


(Juan Julián Merelo Guervós) #10

What I usually do is to make them edit a “submissions page” in their fork and submit a pull request, like here: https://github.com/JJ/IV-2015-16/blob/master/practicas/1.md That way things are kept in their own repo, where they can work, but I get alerted of submissions. With the new “code review” features it’s even better, because you can comment and make them change things if needed.


(Philipschielke) #11

What I’ve done so far, is have students clone my repository, make their changes, commit and push their changes back up. Then I can clone their repository and check the code. However, this isn’t a great model for doing collaborative work, and I don’t have that workflow straight in my head. I appreciate pointers.


(Jaime Chavarriaga) #12

Using Github Classroom

  • You create the assignment using the Github Classroom
  • The students “accept” the assignment, and Github creates a (private) fork for each student.
  • The students do the assignment and push to their own repository
  • You must review the work of the students getting the code from each repository

In the Github Education, you may find tools to clone (download) the repositories in bulk. I think you may try Classrom Desktop.


(Rob Muhlestein) #13

Good clarification. It is really important to note, however, that the student repo is not a fork.

Also the easiest way to review is from the Classroom page itself because it lists all the students with a link to their individual “assignment” repos, which we use as workbooks to go with a textbook repo.


(Peter Hanley) #14

Hi, I work in the Academic Apps group (we manage the web apps like Bb Learn, etc) at a university and was looking for the LTI setup instructions for Classroom, and I think I’ve realized that there aren’t any because Classroom doesn’t have LTI support…

So no one has to go look it up, LTI = Learning Tools Interoperability, it’s basically OAuth2 for LMS platforms to communicate with gradable external tools without having to code platform specific integrations - in short, LTI makes any gradable web tool integrated with Blackboard Learn, Instructure Canvas, Sakai, Moodle, etc.

If enabled, the workflow @gcschmit describes above would be automated to a larger degree - based on some unfinished LTI hacking I’ve done, it could look like this:

  1. Instructor pastes an LTI-invitation link into their blackboard/canvas/etc (LMS) class
  2. Instructor follows the link and selects/creates the github classroom assignment
  3. Student follows the link and classroom receives info that links back to the LMS (student identifier, course identifier, assignment identifier) - as a bonus github would automatically receive all the information needed for the student to create an account, so it would be much like logging in to another webapp via github (or facebook, etc.), i.e. a frictionless account creation
  4. Student does the assignment
  5. If there is a way for instructors to grade assignments (I couldn’t find one), the grade could be passed back to the LMS (a feature I can assure you that instructors love)

So what would be the best way to encourage LTI support from github’s side? Our school has very heavy LMS usage (usually above 90% of undergrad courses use it (~4,900 this semester), to the point where a lot of our support in the Fall is explaining to students that a course doesn’t’ necessarily have to use blackboard, we don’t actually require it of instructors), and so any tool that we suggest usually has some form of LTI support, mainly because of how much it automates in terms of assessment.


(Dhowe) #16

Any reply to the question above, concerning how students can mark their work as done, and instructors can make sure they don’t work past the deadline (if that is not allowed) ?


(Amelia Garripoli) #17

I see the thread has gone quiet; I’m looking into GitHub Classroom for winter term use, after 2+ years with Canvas.

I was using Canvas and GitHub in Fall 2016, and to prevent students working on code past the due date (or rather, in support of it, as it was a term-long project), I had student supply me with the commit SHA they wanted me to look at in the submission they made on Canvas. If we had gotten into tags, I would have had them push specific tag values for each drop point into their codeline and wiki to mark the points.

That way, I always graded just up to that submit point, and they could work on the next week’s submission right away without waiting for my feedback on the last one.


(Dhowe) #18

I wouldn’t recommend it. Its a nice idea, but the system is simply NOT ready for production use. Besides numerous missing features which should be core functionalities (assignment submission and collection, deadline enforcement, an intuitive/well-documented workflow for students), there are critical/show-stopping bugs which remain open. See the following (non-exhaustive) list:


(Samuel Lijin) #19

I have to agree with the above (to a certain extent): Classroom is not really a production-ready product. It does exactly one thing: automates creation of a clone of a given repo with specific permissions, and even this it only does with a 99% reliability rate.

That being said, I have found GitHub itself an absolutely fantastic tool for the class I TA for. It is infinitely easier to help them troubleshoot their code (since I can have them push to their repo and then pull down their changes), I can provide feedback for assignment submissions by commenting on GitHub commits, etc. Git and GH are infinitely better code management tools than literally any alternative and even if Classroom completely broke tomorrow we’d continue using it for assignments.

=====

To answer OP’s question:

Right now, I have a tool that I run that takes the latest commit on master prior to the submission deadline, and sort-of replays it on top of the code they were provided, which gives me a complete GitHub diff in a commit containing only the student’s work. This lets me comment on the commit to provide feedback and also grade their assignments (deductions have to be applied and managed manually, unfortunately, but I’d have to do that even without GH).

I also put together a Python script a few months ago which allows one to configure protected branch permissions. Unfortunately the GH API for this is still in preview, but I’ve tested it and it seems to work fine.


(Andreas Mueller) #20

I’m very surprised by the fact that there is no way to end an assignment or enforce a deadline.
So Github Classroom is really just a way for people to fork a repo - but with the downside that they don’t own it and can’t run their own free services on it.

Going with a fork->PR workflow would allow students to send a PR at the deadline, then the TAs could merge the PRs and that would be the submission. But with the Github Classroom system, you need to check all the diffs. But you can always change the timestamps, so the only way to ensure that students actually comply with the deadline is to pull all their repositories at the deadline.