Here's the algorithm which I wrote to make sure we don't need to
store extra information in the Mastermind's user task model to
generate GOMS rep. I don't want to proceed for the backward algorithm
unless this is proven correct.
Please let me know if I have ignored something. I sent a message to
Dave to verify some basic information, but I can't give this algorithm
to him yet 'til he understands our task model better. I'll do so at
the PI workshop...(too long to type. :-)
Warning: To prove the graphical output, it's better to draw the tree out
graphically. Have fun!!!
--Noi
=========================================================================
This is the algorithm to expand a Mastermind task tree into a GOMS tree.
It should work roughly but still needs to be tested.
(The algorithm for the other way around hasn't been worked out. Once
I work that one out, we can prove that we don't need to store extra nodes
to support GOMS.)
The algorithm only works with SEQUENTIAL and ONE_OF. For other connections
the designer will have to fix scenarios to be SEQUENTIAL before
we can generate anything further.
============================================================================
Rules of the Game:
An SR node always descents from an AG node.
M nodes always descent from an SR node.
Operators descent from an M node.
Operators can descent directly from an AG node. (Is this a valid combination??)
A single M node can descent from an AG.
Return to AG is also a node.
===========================================================================
Algorithm to generate a GOMS tree:
Starting from the top of a tree....
1. Display the task as an AG node; use the goal of the task as the AG.goal
2. If the connection is SEQUENTIAL,
2.1 Draw the extension to the next level down
2.2 For each subtask:
2.2.1 if it's terminal, display it as an O node and the label is the task's label
2.2.2 if it's not a terminal node,
recurse from 1.
(2.3 display a node say "return to AG" ???)
3. If the connection is ONE_OF,
3.1 Display an SR node; draw the extension to the next level
3.2 For each subtask:
3.2.1 Display an M node; use the subtask's label as the M's label
3.2.2 If the subtask is terminal, display an O node below the M and use
the task label as the O's label.
3.2.3 If the subtask is not terminal, check what it's connection is.
3.2.3.1 If it is SEQUENTIAL,
repeat step 2.
3.2.3.2 If it is ONE_OF,
recurse from step 1.
Note: I'll be more than comfortable to get rid of return to AG nodes for both
the graphical & print out version.
===========================================================================
This is the algorithm to generate textual GOMS representation:
(Don't worry right now about the words which are generated. Just pay
attention to the hierarchy.)
Starting from the top of the tree .....
1. Print "AG "; print the goal of the task
2. If the connection is SEQUENTIAL,
2.1 Print "Operators = "
2.2 For each subtask:
2.2.1 if it's terminal, print its label; CR
2.2.2 if it's not a terminal node,
recurse from 1.
(2.3 Print "return to AG")
3. If the connection is ONE_OF,
3.1 Print "Selection Rules = "
3.2 For each subtask:
3.2.1 Print the selection rule which refers to the subtask's label
(something like "if (blah blah) then do Method xxx")
Print "Method XXX: "
3.2.2 If the subtask is terminal, print "Operator = "; CR; and the task label.
3.2.3 If the subtask is not terminal, check what it's connection is.
3.2.3.1 If it is SEQUENTIAL,
repeat step 2.
3.2.3.2 If it is ONE_OF,
recurse from step 1.
(3.3 Print "return to AG") // This might not be needed.
=====================================================
For a tree which is
| = ONE_OF; and & = SEQUENTIAL
1 = ( 2 | 3 | 4 )
2 = ( 5 & 6 )
4 = ( 7 | 8 | 9 )
7 = ( 10 & 11 )
8 = ( 12 & 13 )
3, 9, 5, 6, 10, 11, 12 and 13 are terminal
Here's the graphical output: (You have to draw the picture to get this.)
AG(1) = ( SR(1) )
SR(1) = ( M(2) | M(3) | M(4) )
M(2) = ( O(5) & O(6) & RT(2) )
M(3) = ( O(3) & RT(3) )
M(4) = ( AG(4) )
AG(4) = ( SR(4) )
SR(4) = ( M(7) | M(8) | M(9) )
M(7) = ( O(10) & O(11) & RT(7) )
M(8) = ( O(12) & O(13) & RT(8) )
M(9) = ( O(9) & RT(9) )
Of course here all Os are terminal. The numbers in parenthese
mean that's the task number where they get the information from.
(RT(xx) = Return to AG xx)
Here's the print out:
AG: 1.goal
Selection Rules =
if (rule for 2) do Method 2
Method 2: Operators =
5
6
Return to AG 2.goal
if (rule for 3) do Method 3
Method 3: Operator =
3
Return to AG 3.goal
if (rule for 4) do Method 4
Method 4: AG: 4.goal
Selection Rules =
if (rule for 7) do Method 7
Method 7: Operators =
10
11
Return to AG 7.goal
if (rule for 8) do Method 8
Method 8: Operators =
12
13
Return to AG 8.goal
if (rule for 9) do Method 9
Method 9: Operator =
9
Return to AG 9.goal
Return to AG 4.goal
Return to AG 1.goal
===============================================================================