On Dec 6, 4:17 am, Peter Bienstman <[EMAIL PROTECTED]> wrote:
> (I wrote this code a while ago, so it took me some time to reconstruct my line
> of reasoning at the time.)
>
> You are right that there is an extra limit imposed on the size of the queue,
> e.g. by making sure that you don't focus on more than 10 lapsed cards at the
> same time. There is also a limit of 10 on the unlearned cards as you have
> noticed.
>
> I'd like to keep the first limit as it is, as you will get through your lapsed
> cards eventually, and they have priority over other cards anyway.
>
> About the second limit: if I remove it, it's possible to have an arbitrary
> large number of cards in your hand at one time, and I'm not sure if that's a
> good idea. Making it configurable through the GUI is not an option as it's way
> too complicated to explain. Remains the option of having it configurable
> through the text config file (also not my favourite), or changing the number
> of
> 10 to something like 2*max_grade_0_cards.
>
> I haven't decided yet which option is best, and I'm open to any feedback on
> the issue.
I definitely see the difficulty here. I'm getting to a point where I'm
beginning to have a good feel for the behavior I want, and I'd kind of
like to have some buttons and sliders that gave me finer control over
the behavior of the program. That said, I think you're quite right to
not want to add them to Mnemosyne. It would be hard to explain, and
they wouldn't have been useful to me when I _started_ using the
program. I would just have gotten myself in trouble with them, in all
likelihood. It is clear to me that the Mnemosyne algorithm isn't
optimal for me for some of what I'm doing, but that's no meant as a
criticism of the algorithm- I'm just not sure that there is one
algorithm that's optimal for every user for every task. And my needs
may be somewhat idiosyncratic- it could be argued, with some justice,
that I am simply trying to learn too much at once. I have some reasons
for that though- a thorough explanation of the reasons would probably
not be interesting to anyone not studying Japanese, as they're related
to the idiosyncracies of the written language, which is very
idiosyncratic. At any rate, I'm pretty certain I could devise an
algorithm that would work better for me, for this one type of item,
but that's not to say that that algorithm would be better than (or as
good as) the current algorithm in the general case.
I understand what you're saying about letting the hand grow
arbitrarily large, and I agree that that's not a great idea. And I
think you're right that it's not an easy thing to resolve without
making the algorithm quite a bit more complex. But I am a bit uneasy
about how Mnemosyne handles it. As a programmer I'm always suspicious
of code that tries to achieve aims in a roundabout way, and I think
this check involving the hierarchy lapsed>seen> unseen is overly
arbitrary, and leads to surprising results. In particular, it seems as
if it makes the "number of grade 0 cards to hold" option less useful,
and very hard to understand. That this is so might not be at all
obvious unless you are adding large numbers of cards at a time, but it
is quite obvious if you are, for exactly the reasons Kevin mentioned-
I wouldn't have been able to understand what was going on without
taking a look at the code. Of course one of the advantages of having a
simple algorithm is that it's not too hard to do that, but that
requires that you be able to read code, which is not true of everyone.
I'm not sure what the best answer to this would be, but I do think
that having a setting that simply limited the size of your hand, but
kept it constant without making a distinction between grade 0 and
grade 1 cards or seen/unseen cards would be more intuitive than, and
preferable to the way it works now. It would have some drawbacks,
but... I think it would be at least more easily understood than the
current system, and it wouldn't have the drawback of making you retire
cards before you want to in order to get your hand up to the size you
want it at. I can think of other solutions that I think I would
prefer, personally, but they would complicate the interface (or the
algorithm) which you seem (quite rightly, I think) to want to avoid.
Anyway, I'll give it some more thought and see if I can think of
something better than that that would also be consistent with your
goals re: the interface/complexity of algorithm.
Thanks
Duncan
--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups
"mnemosyne-proj-users" group.
To post to this group, send email to [email protected]
To unsubscribe from this group, send email to [EMAIL PROTECTED]
For more options, visit this group at
http://groups.google.com/group/mnemosyne-proj-users?hl=en
-~----------~----~----~----~------~----~------~--~---