From 73795a28906023f8e17367ad81cb805b95d8d84b Mon Sep 17 00:00:00 2001 From: Carl Worth Date: Tue, 7 Apr 2009 17:03:35 -0700 Subject: [PATCH] Tweak the implementation of to_master 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). --- mnemon.c | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/mnemon.c b/mnemon.c index c334f22..69ac5b1 100644 --- a/mnemon.c +++ b/mnemon.c @@ -1116,13 +1116,11 @@ mnemon_handle_response (mnemon_t *mnemon, (time_limit == 0.0 || response_time < time_limit)) { item->score++; - mnemon->to_master--; /* We reserve an item score of 0 for an item that has * never been asked. */ if (item->score == 0) { item->score = 1; mnemon->unlearned--; - mnemon->to_master--; printf ("You got it!"); } else if (item->score < 0) { printf ("Yes---just give me %d more.", @@ -1131,6 +1129,8 @@ mnemon_handle_response (mnemon_t *mnemon, printf ("On your first try, no less!"); } else { printf ("Masterful (%dx).", item->score); + if (mnemon->to_master) + mnemon->to_master--; } } else { if (! correct) @@ -1146,12 +1146,13 @@ mnemon_handle_response (mnemon_t *mnemon, 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 @@ -1159,7 +1160,6 @@ mnemon_handle_response (mnemon_t *mnemon, item->score = -2; } else { item->score--; - mnemon->to_master++; } } -- 2.43.0