blog/content/posts/2022-07-24-mastery-based-learning.md

+++ title = "Mastery-Based Learning" date = 2022-07-24 tags = ["education"] +++

A thought I've been brewing probably since undergrad is the idea of mastery-based education for skill-based practices. Directly inspired by the language learning apps, I wonder whether we can enhance a traditional spaced repetition system with a topic graph, where mastery can "spill" throughout the graph to better model learning. Since I'm never going to have time to actually build such a system, I thought I'd just jot these ideas down.

Knowledge Graph

The first piece of this setup would require having an extensive knowledge graph. Think Wikipedia, where it has a lot of related topics, but rather than just being linked in an ad-hoc manner, each link has one or more of the following specific purposes:

• Dependency. The linked topic needs some percentage of mastery in order to best experience the current topic.

• Spill. Not really sure what a good term for this would be, but basically mastery of the current topic would result in some percentage of "spilled" mastery gain for the linked topic.

The dependency aspect allows people to work backwards, starting from what they don't know and being able to query what the required context is. They can build themselves a learning plan based on a topological sorting of those topics and tackle them individually.

The spill aspect allows people to "skip" learning things they already know, for a faster onboarding experience. For example, since "the quadratic formula" requires someone to know "algebra", then if someone masters the quadratic formula before algebra, it should boost the mastery of algebra too.

Mastery Level

I think the current way tests are handled are not only stressful, but a horrible way to measure mastery. Rather than promoting long-term learning, it encourages the cram-and-forget workflow. I think what the language learning apps taught us is not only is it good to repeat things when we get it wrong, it's also good to repeat things when we get it right.

The vision would be something like this:

1. First, the student learns some material. They take a short quiz immediately, and their mastery is boosted by a small percentage depending on their score, maybe up to 30%.

2. Then, the student goes off and learns some related material. After a length of time has passed, they are quizzed on the first topic again. By this time, their mastery score should fall a bit simply on the basis of "forgetfulness over time".

3. At the end of the semester, if they have reached required thresholds of mastery in each required topic, they will pass the class.

Not only does this simplify final grading, it also removes the whole concept of stress in the middle, since doing badly on one exam doesn't hurt your grade permanently. On top of that, doing well on a single exam doesn't guarantee that you know it, and the system models that by not giving you full mastery after a single test.

But this doesn't necessarily mean that the student must re-take tests on things they already know. The great thing about the whole "spill" system is that if they learn topic A first, then topic B that depends on topic A, then topic B can indirectly keep topic A's mastery afloat.

Implementation Challenges

Implementation is the toughest part. There's a couple technical hurdles I would like to complete before attempting such a system, which are:

• A bunch of interactive widgets for allowing users to play around with the material directly. This is more applicable in math and science curriculums.

• Quiz generation software. There's probably good off-the-shelf components already, I haven't looked.

Another problem is that I never want to think about dealing with cheating. If this idea were to be neatly packaged up and deployed into schools, you bet the first problem teachers are going to have is with cheating. While there are some stopgaps such as auto-generated quizzes and personalized curriculums, there's never a guaranteed solution. Instead, fostering a healthy learning attitude among students is the best way for these systems to be effective.

My final disclaimer is that I'm not an educator. I've TA'd for a functional programming course in undergrad and helped many peers learn programming concepts from time to time. Watching people learn is a very interesting process, and while I don't have time to conduct studies on how this process works, there's general patterns I picked up on while following this train of thought.