For years, I’ve used the same late policy: work accepted up to a week late, 20% reduction in grade, no questions asked. And it’s been a pretty effective policy. I’ve been criticized for it being both too lenient (“They need to learn deadlines are real!”) and for it being too strict (“20% off even if it’s only a day late? That’s two letter grades!”). But generally it does what it’s intended to do: Be scary enough to discourage late assignments, but flexible enough to save the students who have genuine emergencies and can’t afford a zero but can afford a C. And, on my end, it reduced the need to track excuses and exceptions and to count how late things are, which reduced my load in grading.
But this semester, I changed it. Not because it wasn’t effective–it absolutely was. And not because I rethought the philosophy of such a late policy–I might, but not this time. I changed it because of an algorithm.
A little over a year ago, my university made a switch from the Blackboard LMS (learning management software) to the Canvas LMS. In general, I think this has been a positive move for the students: Canvas’s brighter, more minimalist design more closely reflected the ways that students generally are used to interacting with the web nowadays, where Blackboard sort of looked and felt like the forums I used to play on when I was a highschooler in 2004. Perhaps most importantly, the Canvas mobile apps are very well designed, and many of my students are now able to do their homework almost entirely on their mobile devices, making the online portions of my courses far more accessible, whereas Blackboard’s mobile app was pretty much garbage.
However, it’s taken me a year to get used to Canvas and figure out which dials to turn and switches to flip to get Canvas to do the things I want it to do. Blackboard was familiar, as I’d worked with it for years, and I knew how to implement my policies seamlessly using Blackboard’s algorithms.
My biggest fight with Canvas has generally been with the late policy. I always applied the late policy manually in Blackboard, simply relying on Blackboard’s notification that an assignment was late. But Canvas is eager to apply late policies on its own, and the defaults were getting me (and my students) into trouble. They’re still doing that.
The default gradebook that my institution’s version of Canvas (I am aware that different institutional iterations have different defaults depending on the package purchased from Instructure, the company that develops and sells Canvas) was doing something odd in the grade book. When a student didn’t submit an assignment, Canvas was not considering that assignment in grade totals at all. The effect was as though unsubmitted work was being counted as a 100%, and the result was that the students who had failed to submit work–often the students who struggle the most to understand the requirements of the course in the first place–were being led to believe when they checked their grades in Canvas that they were doing fine and nothing was wrong, when in reality they were failing because of unsubmitted work. This generally made more work for me than it should have, because as we all know the shock of finding out your grade is lower than you believed generally results in indignant emails to instructors, and probably rightly so. But this wasn’t my policies at work: this was the algorithm.
I found a way to solve this problem (apparently I needed to use the “new gradebook” option in course settings), but it resulted in the opposite problem. Students who submitted work late were now being led to believe that their late work was given a zero and their grades were lower than they actually were. Now, I consider this a net gain; I would rather reassure a student that their grade is better than they believe it to be than have to break the news that a student who believed they had an A was actually failing. So until I figure out a better solution, this is a state of grading I will tolerate and even endorse. And it’s pretty simple how the algorithm is doing this: when the deadline for an assignment passes, even by a second, it marks everything without a submission as a zero. The late work is then considered a “resubmission” and, until I get around to grading it and the higher grade will take over in the calculation, the zero stands as the official grade.
But what about my years-old late policy? Well, that’s where Canvas got a bit bossy, and ultimately won that battle. Canvas can and does apply a late policy automatically, but it assumes late policies come in a couple of specific varieties, and my 20% off no-questions-asked policy apparently isn’t one of them. It only offers hours and days as late policy intervals, not weeks as my policy might have been interpreted. (Side note: who bothers counting hours for a late policy!?) As you can see in the screenshot from my sandbox course, I attempted to implement the policy, but it didn’t really work out in field testing.
I was still tweaking a lot of things on Canvas at the beginning of the semester, and as my experiments with Canvas’s late policy algorithms got increasingly frustrating, I realized the easiest solution was actually to change my own policy rather than trying to force Canvas to do what I had been doing manually. After all, computers don’t think like humans.
After a serious discussion with my students in class, in which I explained how the algorithm works and what my philosophy on late policies was, and in which I listened carefully to their concerns about how changing a major syllabus policy after it had been initially declared in the syllabus might affect them, we decided to change the late policy. It’s now 4% reduction per day, so that a 5 day (one business week) delay results in the same 20% reduction. I don’t love it, but it’s familiar to the students (who have seen similar policies before) and matches the algorithm’s capabilities.
But, as we who analyze games seriously know very well, algorithms are themselves expressions of values, assumptions, and expectations–they are arguments. And, in effect, Canvas is making an argument about what late policies should be (apparently hourly!) with a frightening precision that I, as an absent-minded human, could never match.
As we set our policies as teachers, we find that our policies are as much influenced by the values and assumptions of the software developers about teaching and learning as they are about our own understanding of teaching and learning. In some ways, this makes our job easier–the computer can be both faster and more responsive in certain tasks than I can, which benefits both me and my students–but in other ways it erodes our autonomy and our ability to experiment with policies that might challenge the status quo when necessary, and thus entrenches traditional teaching practices that may not be best practices. This late policy is probably a minor matter, but it definitely illustrates how algorithms are affecting not only our daily lives, but how we teach at every level.