Trane is an automated learning system for the acquisition of complex and highly hierarchical skills. It is based on the principles of spaced repetition, mastery learning, and chunking.
Given a set of exercises which have been bundled into lessons and further bundled in courses, as well as the dependency relationships between those lessons and courses, Trane selects exercises to present to the user. It makes sure that exercises from a course or lesson are not presented to the user until the exercises in their dependencies have been sufficiently mastered. It also makes sure to keep the balance of exercises so that the difficulty of the exercises lies slightly outside the user's current mastery.
You can think of this process as progressing through the skill tree of a character in a video game, but applied to arbitrary skills, which are defined in plain-text files which define the exercises, their bundling into lessons and courses, and the dependency relationships between them.
Trane is named after John Coltrane, whose nickname Trane was often used in wordplay with the word train (as in the vehicle) to describe the overwhelming power of his playing. It is used here as a play on its homophone (as in "training a new skill").
Trane was conceived after my frustration learning jazz improvisation and music in general (another reason for its name). While I practiced most days, I didn't feel I was making a lot of progress. While I made progress in whatever I practiced at the time, other skills and previously learned songs were in a constant process of being unlearned and forgotten.
I wanted a system that would keep track of all the skill and exercises I needed to practice, letting me know when my skills were deteriorating, and asking me to practice them. I also wanted to move on to practice the next set of skills once my current skills were sufficiently mastered.
Initially, I tried to use Anki to help me with these tasks, but quickly found limitations (See Q&A section below).
Spaced repetition is a long-established way to efficiently memorize new information and to transfer that information to long-term memory. Trane applies spaced repetition to exercises that require memorization (e.g. recalling the notes in the chord A7) and to those which require mastery of an action (e.g. playing a section of a song). How well spaced repetition works for the second type of question is still unknown, but for exercises that require the simple repetition of the same task until it is mastered (which covers most of musical training) it should work well.
The space repetition algorithm is fairly simple and relies on computing a score for a given exercise based on previous trials rather than computing the optimal time at which the exercise needs to be presented again. This will most likely result in exercises being presented more often than they would in other spaced repetition software. Trane is not focused on memorization but on the repetition of individual skills until they are mastered, so I do not believe this to be a problem.
There might be a major revamp of the algorithm once I get enough feedback, both from my own experience and others'. Until now, I suspect that a majority of learning gains will come about from selecting exercises based on an average of their previous scores.
These two concepts are highly related. Mastery learning states that students must achieve a level of mastery in a skill before moving on to learning the skills which depend on the current skill (in Trane these skills are called the dependents of a unit). Chunking consists of breaking up a complex skill into smaller components that can be practiced independently.
Trane applies mastery learning by preventing the user from moving on to the dependents of a unit until the material in the unit is sufficiently mastered. Otherwise, a user might be presented with material that lies too outside their current abilities and become frustrated. If a user's performance on a previously mastered unit degrades, Trane will make the user practice the material until it is mastered again.
Trane applies chunking by allowing users to define lessons and courses with arbitrary dependency relationships. For example, learning to improvise over chord progressions might be broken into units to learn the notes in each chord, learn the fingerings of each chord, or improvise over single chords. The user can then define a unit to learn chord progressions and declare each of the other lessons as a dependency.
A common theme in the spaced repetition literature is that users should create their own flashcards to better help them memorize their material. While that advice might be useful for spaced repetition for the sole purpose of memorization, it is not so useful when creating material for Trane.
Given that Trane requires knowing the dependencies among lessons and courses to be effective, beginners will be at a disadvantage because they will most likely not be aware of those relationships. Defining all the materials in a plain-text format lets users freely and easily share their courses and lessons. It also allows the creators of that material to generate the necessary files programmatically and to extend Trane to support new types of exercises.
Trane comes with utilities for the purpose of facilitating the creation of new courses. For example, it provides a course builder that follows the circle of fifths and creates a lesson based on the key and the note that came before in the circle. For example, one can use this builder to generate a course on the major scale that begins by teaching the C Major scale, followed by the F Major and G Major scale (the scales with one flat and sharp respectively) and so on.
This section defines basic concepts used in Trane, both for using it and for creating new material.
When presented an exercise, a user performs it and assigns it a score signifying their mastery of the task. The scores range from one to five, with one meaning the skill is just being introduced (e.g. reading a section of a music score and figuring out the notes and movements required to play it) and five meaning complete mastery of the material (e.g. effortlessly playing the section and improvising on it).
There are three types of units in Trane:
A Trane library is a set of courses stored under the same directory. Trane stores its configuration
under a directory called .trane in that directory. Users might want to have multiple separate
libraries if they are learning separate skills (e.g. music and chess), and they want to keep their
practice separate.
Units are defined in JSON files called manifests, which are serialized versions of structs defined in the data module. The ID, name, description, locations of any external files (e.g. the files storing the front and back of a flashcard), etc., are defined in those files.
Each Trane library has a blacklist. A unit in a blacklist can be any exercise, lesson, or course. If a unit is in the blacklist, Trane will not show any exercises from it. If a lesson or course depend on a blacklisted unit, the scheduling algorithm will act as if the blacklisted unit has been mastered.
A unit should be added to the blacklist if the user already has mastered the material (e.g. an accomplished musician will want to skip the course teaching the notes in the major scale) or if they have no interest in learning the material (e.g. someone interested in learning the guitar might want to skip units which are focused on another instrument).
In its normal mode of operation, Trane looks for exercises in the entire library. There are times when users might want to focus on a smaller section. Filters provide users with the ability to select specific exercises. There are three types of filters.
Trane is in an early state and subject to change. However, I do not expect a lot of changes to happen in the core scheduling logic. The only state stored by Trane depends on the ID of a unit, so as long as that is not changed, updating the files is the only thing needed to make Trane pick up updated versions.
At the moment, there is only a command line interface for using Trane. The code is in the trane-cli repository.
Eventually. I am not too familiar with front-end or GUI development, so it could take a while. However, the command-line version should be enough to get going for now. The main thing to be gained from a graphic interface is to allow external resources (e.g. images or a score from soundslice.com) to be embedded into the application.
Originally, I tried to use Anki for practicing music but quickly found some limitations. First, Anki and similar software are optimized for memorization, not for practicing the same skill until it is mastered. Most importantly, defining arbitrary dependencies between subsets of flashcards and having the algorithm use those dependencies to select the flashcards to present is not supported.
The solution given by Anki is to create multiple decks. However, asking users to manually decide which deck to practice and which decks should be practiced once the current one is sufficiently mastered sort of defeats the purpose of using an automated system in the first place.