summary |
shortlog |
log |
commit | commitdiff |
tree
raw |
patch |
inline | side by side (from parent 1:
6aebbea)
I think the to_master counter got off from some point from its original
purpose, (and probably because I never documented it that well).
Here are my current thoughts and what should be implemented now:
A mnemon session consists of three phases, some of which may be entirely
empty, as follows:
1. The introduction phase
This phase is controlled by the to_introduce counter which is initially
set to 10. It is decremented every time an item is introduced from the
bin with score 0, or (if there is no bin with score 0), every time an
item is introduced from the bin with the lowest non-negative score of
any bin.
2. The mastering phase
This phase is controlled by the to_master counter which is initially
set to 10. It begins at the beginning of the session so can run
concurrently with the introduction phase. The to_master counter is
decremented every time an item with a positive (non-zero) score is
answered correctly. It is also incremented every time an item with
a positive (non-zero) score is answered incorrectly during the
introduction phase. If perfect mastery is demonstrated, the mastering
phase is likely to be complete simultaneous with the introduction
stage. If the user is really struggling with mastery, the mastering
phase will extend long after the introduction phase is over. But
since we never incremeent to_master after the introduction phase is
over, the user cannot build an infinite snowball of to_master items
and have to give up in despair.
3. The solidifying phase
This final phase continues after the mastering phase for as long as
any items with a negative score remain. The idea here is that we
want to quickly give the reinforcement from a missed item in the
current session. Also, there's a bit of a challenge to the user to
demonstrate good mastery of any non-negative items presented so that
the phase actually terminates. It's possible for this phase to extend
for an arbitrary amount of time, but not very likely, (since the
negative items are chosen preferentially and the user will continue
to see the correct answers to them over and over).
(time_limit == 0.0 || response_time < time_limit))
{
item->score++;
(time_limit == 0.0 || response_time < time_limit))
{
item->score++;
/* We reserve an item score of 0 for an item that has
* never been asked. */
if (item->score == 0) {
item->score = 1;
mnemon->unlearned--;
/* We reserve an item score of 0 for an item that has
* never been asked. */
if (item->score == 0) {
item->score = 1;
mnemon->unlearned--;
printf ("You got it!");
} else if (item->score < 0) {
printf ("Yes---just give me %d more.",
printf ("You got it!");
} else if (item->score < 0) {
printf ("Yes---just give me %d more.",
printf ("On your first try, no less!");
} else {
printf ("Masterful (%dx).", item->score);
printf ("On your first try, no less!");
} else {
printf ("Masterful (%dx).", item->score);
+ if (mnemon->to_master)
+ mnemon->to_master--;
}
} else {
if (! correct)
}
} else {
if (! correct)
printf (" Oops, you knew that, right? (%dx)\n ",
item->score);
mnemon->unlearned++;
printf (" Oops, you knew that, right? (%dx)\n ",
item->score);
mnemon->unlearned++;
- /* We add three here, (rather than just 2 to track the
- * change in the item's score below), as an extra
- * penalty. If the user is forgetting stuff learned
- * previously, then more time should be spent on mastering
- * than learning new items. */
- mnemon->to_master += item->score + 3;
+ /* We increase to_master here as an extra penalty. If the
+ * user is forgetting stuff learned previously, then more
+ * time should be spent on mastering than learning new
+ * items. Note that we only do this during the initial
+ * phase while new items are still being introduced. */
+ if (mnemon->to_introduce)
+ mnemon->to_master++;
/* We go to -2 to force a little extra reinforcement
* when re-learning an item, (otherwise, it will often
* get asked again immediately where it is easy to get
/* We go to -2 to force a little extra reinforcement
* when re-learning an item, (otherwise, it will often
* get asked again immediately where it is easy to get
item->score = -2;
} else {
item->score--;
item->score = -2;
} else {
item->score--;