The Development of          
                  List-Learning Strategies    
                  in a HyperBook Setting      
                                              
                                                 by John Collett


   <> 34 <%> 34 <%> 34 <%> 34 <%> 34 <%> 34 <%> 34 <%> 34 <%> 34 <%> 34 <>


     Background  


    In MD32 I described how an AlfaScan scanner was used to store copies of
    student ID photos, and three sample photos were shown on an
    accompanying pic.  Since then I have processed well over 100 ID photos,
    and have already learned the name/photo links for nearly all of them -
    a massive improvement on my usually dismal performance in this respect.

    As I tried to learn the sets of names and faces, I developed a program
    to help me, all the time trying to keep an open and flexible mind on
    what ideally I would like the program to do for me, and on how it might
    possibly make my learning task easier.  I have reached the stage
    where, unless I resort to brain-transplant, hypnosis, crystal-ball
    gazing, or some other form of mysticism, I am unlikely to be able to
    improve on the present arrangement, and in this article I intend to
    describe the current form of the list-learning tool as I have developed
    it.

     A Pattern to Imitate  

    For many years one of the main vocabulary learning and revision tools
    available to students of French at the University of Waikato has been a
    program called Lexis.  In each unit, items are selected at random from
    a stored set, correctly answered items are flagged not to appear again,
    and the program continues until a correct answer has been given for
    every item.  The details need not concern us here, but a prompting
    option allows learners to move gradually from revision of known items,
    through reminders of forgotten items, to a learning of new items.
    Unless they use Ctrl/C to escape, every learner emerges with a score of
    100%.

    The history of this program and student attitudes to it are such that I
    considered the cyclic handling of items to be a good pattern to follow
    in my own photo/name learning task.  In my self-testing phase, photos
    appear in a random order until all of them have had their 'Okay' flag
    set to positive, or I can use a 'Quit' option at any time.

     Page 1 of the HyperBook program  

    A HyperBook unit is a set of 'pages'. Only page 1 in the photo/name
    unit is a working area, the remaining pages being used simply as a
    store for the copies of the ID photos which are to be studied and
    identified.  They are arranged in three rows per page, six photos
    per row.

    ---------------------    On Page 1 the list of names is a key item.
   | Adam Adamant      | |   It is on the left of the screen, and occupies
   | Betty Boxer       | |   the full height.  As is the case with all
   | Charlie Chan      | |   HyperBook 'Lists', its items can have
   . .                   .   particular actions set, they can be in
   . .                   .   significantly different colours, and so on.
   |                   | |
   |                   |_|   Only if a class of students is 25 or
   |                   |_|   less can all the names be seen at once.
   |                   | |   Otherwise the list's scrolling gadgets
    ---------------------    need to be used.

    Stage 1 : From names to photos  

    This is the first approach to the learning task.  If any name in the
    list is clicked, a copy of the relevant photo is fetched from one of
    the following pages and displayed right of centre on page 1.

    Fred Bloggs?  What does he look like?  Click on the name.  Ah, yes,
    that one.
    Mary Utterthwaite?  I think she's the long-haired blonde who wears a
    monocle.  Click to check.

    I haven't got round to making this Stage 1 more interesting, nor am
    I likely to.  I prefer to move on fairly quickly to Stage 2, which I
    find effective, and adequate.

    Stage 2 : From photos to names  

    This stage is carried out in the sort of cyclic loop used in the
    Lexis program mentioned above. The loop iterates until all items in
    the list are flagged as 'Okay'.

    The following Buttons are set up across the lower part of the screen,
    to the right of the list of names.

             ----------------------------------------------------
            |               Start                                |
            |                                                    |
            |   /\          Show     Hint     Okay       Quit    |
            |                                                    |
            |   \/               ... correct out of ...          |
            -----------------------------------------------------

    Once the Start button is clicked, a macro starts to run, and I remain
    within that macro until all items are done or the Quit button is
    clicked.  All other functions are suspended while the macro is
    running, which means that the scroll buttons built into the list do
    not respond.  Their place is taken by the two pseudo scroll-gadgets
    marked /\ and \/.

    The rest of this description is best carried out in terms of the
    contents of the macro in question.

    1  How many items to work through?    num = NumElements('List1'())

    2  I could mark them all as 'not-done', in which case flag. = 0
    would be equivalent to saying do f = 1 to num ; flag.f = 0 ; end
    But there are a few that I am certain I already know, and which I
    wish to be excluded.  I mark such items in the list by changing
    their colour, and these are now flagged as 'already used', with
    'num' gradually being reduced to a lower value called 'items'.
        li = 'List1'() ; items = num
        do f = 1 to num
          if GetItemColor(li || '/' || f) = 1 then flag.f = 0
            else do ; flag.f = 1 ; items = items - 1 ; end
          end

    3  Other initialisations : nomore = 0 ; quit = 0
                               times = 0  ; listmove = 0

    If I need to scroll the list, then that is all I want to happen.  I
    do not want the main 'do' loop to iterate and fetch another photo.
    Setting 'listmove' to 1 in such cases prevents this.

    4  If an earlier run did not finish cleanly (these things happen),
    there may be a photo already in place on the screen.  If so, delete
    it.
        obj = GetObjectAt(310,45)
        if obj ~= '' then call HML_Delete(obj)

    5  Start the loop.  Stay in it until all items are done or 'Quit' is
    selected  ( | means 'OR' )    do until quit | nomore

    6  Display progress
        coo = " correct out of "
        o = ReplaceText('Note4'(),times || coo ||items,0,-1)

    7  Select an unused item
        if listmove = 0 then
          do until flag.chosen = 0 ; chosen = Rand(1,num) ; end
          else listmove = 0

    8  Get that name from the list
        name = GetItemText('List1'() || '/' || chosen)

    9  Find an object (photo) of that name obj = SearchName(':',name)
   10  Put a copy in the bin               new = Clone(obj,'0:')
   11  Give in the required position       call SetPosition(new,300,40)
   12  Place it on Page 1                  this = Relocate(new,':')

    The use in step 10 of the bin as a temporary holding area prevents
    unwanted flickering on the screen as step 11 is carried out.

   13  The program waits for a mouse click :
        row = GetClickRow('Click') ; col = GetColumn()
        obj = GetObjectAt(col,row)

   14  Checks that what I click on is a 'Note'.  A further check against
    user error is in the 'otherwise nop' below.
        if GetType(obj) = 'Note' then str = ReadNoteText(obj,0,-1)

   15 Decisions, decisions ....
        select

   15a   If I just don't know, I click on 'Show'.  The student's name is
    displayed centre-screen in a string gadget, and remains there until
    I click on its 'Okay' button.
          when index(str,'Show') then call inform(Name)

    A lazy alternative, not requiring an acknowledging button-click,
    would be to display the name briefly in the title bar.
          when index(str,'Show') then call BeginPrompt(Name)

   15b   Sometimes I nearly know, I can almost remember, I just need a
    hint, and I have found it very helpful to have a student's initials
    appear briefly in the title bar.
         when index(str,'Hint') then do
           a = substr(name,1,2) ; b = substr(name,index(name," "),3)
           call BeginPrompt(a || b)
           end

   15c   If I think I know the name, no actual answer has to be
    supplied.   I simply click the 'Okay' button.  Confirmation appears
    in the title bar.  (If you're not going to be honest with yourself,
    why bother to use the program?)
         when index(str,'OK') then do
          call BeginPrompt(name) ; flag.chosen = 1 ; times = times + 1
          end

   15d   when index(str,'Quit') then quit = 1

   15e   Another form of help is to glance down the list of names. If
    the part I need is not in view, I can click an up or down scrolling
    gadget. 'Listmove' is temporarily set to 1 to prevent another photo
    being fetched.  This patch would need a bit more work if the list
    contained more than 50 items.
        when index(str,'/\') ~= 0 then do
           call ListScroll('List1'() || '/1') ; listmove = 1
           end
        when index(str,'\/') ~= 0 then do
           call ListScroll('List1'() || '/25') ; listmove = 1
           end
        otherwise nop
        end

   16   To exit if all items are done
        nomore = (times = items)

   17   Keep it tidy. Delete each photo before the next is fetched.
        call pause(10) ; call HML_Delete(this)
         end

   18   Final display of performance details.  If I did not chose 'Quit',
    then by now 'times' should equal 'items'.
        o = ReplaceText('Note4'(),times || coo || items,0,-1)


      Conclusion  

    The learning of lists for their own sake is no longer regarded as an
    effective educational method for general consumption, but the odd
    occasion arises, and I speak from experience, when you do need to
    have a set of items in memory, ready for use at any time. (The
    multiplication tables have stood the test of time, but I don't know
    whether they are still drilled and chanted as they were when I
    learned them.)

    The above discussion has been in terms of learning name and photo
    links.  In fact, any list-learning task could be handled in this way.
    For example, the 'List' might contain a set of foreign-language
    vocabulary items you need to learn: English equivalents, irregular
    past participles, forms of the future tense, and so on.  Or chemical
    or mathematical formulae, events and dates, authors and titles.

    Are you into computing?  You might want to learn a set of editing
    shortcuts, or the 137 functions in the HyperBook Macro Language.

    Is music your thing?  You may be looking for a way to remember the
    sharps and flats required for each key signature, or to learn
    fingerings for chords.  For the latter, a list of chord names G, Gm7,
    and so on, and a set of HyperBook 'Drawings' to show the fingerings
    might be useful. Like this:
                                      ===========
                                      | | | | | *
                                      | | | | * |
                                      | | | | | *
                                      | | * * * *
                                      | | | | | |

    In the case I have described, the partner to each item was a named
    picture.  For less complicated applications such as vocabulary
    learning, they could simply be held in another matching list, in
    which case some of the procedures and certain other details such as
    the form of the 'Hint' option would probably need modification.

    Hamilton, New Zealand : May, 1993 

                       ---------------------------

   <> 34 <%> 34 <%> 34 <%> 34 <%> 34 <%> 34 <%> 34 <%> 34 <%> 34 <%> 34 <>