2003-02-09

FingertipTV user paths 2


Modelling in a similar way to yesterday, thinking about it like this:

- there are a number of input patterns
- there are a number data cursors
- there are a number of output formats
- there is a history, that is a log of cursor positions and input

An input pattern uses the cursors and history to
- set the cursors to new positions
- send an output

So this has to be modelled. The problem is that for a properly
cooperative bot, history is important and the number of conversation
paths grows quickly. Hopefully it's possible to ignore the history and
just use the cursor positions to know what happened most recently.

(Incidentally, this is more the way the universe works. There is no
history. There's just a current state that encodes knowledge from
*before* -- no sense of how long something has been encoded is built
it.)

(Another incidentally. This is internal_state and psychological possible
worlds. Given the internal knowledge of what's actually happened so far,
and the set of possible outcomes a user might want, what to do is in the
intersection of those. Chuck's thesis, in other words.)

INPUT PATTERNS:
a. now
b. now [channel]
c. later
d. later [channel]
e. earlier
f. earlier [channel]
g. next
h. next [channel]
i. previous
j. previous [channel]
k. [time]
l. [time] [channel]
m. [channel]
n. [programme id from list]
o. help

CURSORS:
C. channel cursor (can be undefined for 'all')
T. time cursor (must always be set, initially to current time)
P. programme cursor (must always be set, initially to 0)
L. options list (not really a cursor, contains list of programmes)

OUTPUT FORMATS:
1. list of channel and programme names, one programme per channel
	- if C is undef, uses the whole channellist; or C
	- programmes showing at time T
	- steps next or previous according to P
	- hint message
2. details for a single programme
	- details for programme
	- hint message
3. medium details for a programme, followed by the name of another one
	- medium details for programme, with option to see more
	- name of another programme, with option to see more
	- hint message
4. an error message
	- hint message


LOGIC:

Functions:
later(T) means the next 30 minute increment
earlier(T) means the previous 30 minute increment

a.
C = undef
T = current time
P = 0
output = 1

b.
C = [channel]
T = current time
P = 0
output = 3
nb. It'd be good to do output 2 if previous command was b with same
channel

c.
there are two possible things that could be going on here
- the user wants to see later whatever they just saw (eg, they're
looking at bbc2 and are paging through it)
- the user wants to see later for all channels
so how to disambiguate?
nb. this needs to snap back to all channels somehow
C = C
if(P == 0) {
	T = later(T)
	P = 0
}
else {
	T = later( earliest start of programmes in L )
}
if(C == undef) {
	output = 1
}
else {
	output = 3
}

d.
should something different be shown if the [channel] == C already?
C = [channel]
if(P == 0) {
	T = later(T)
	P = 0
}
else {
	T = later( earliest start of programmes in L )
}
output = 3

...oh and, etc. It doesn't matter what the logic is exactly, just that
it can be done.


So here's how I'm conceiving of the system at the moment:

The data cursors represent coordinates in a map (with the difference
that it doesn't have to be a unique position; the internal cursor can be
smeared out over all possible channels, for example).

The user gives some input, which moves the internal cursors around.

The inputs are divided up so we can see how a user approaches a given
cursor position. This, coupled with their history and the cursor
position itself, tells us what kind of output would be useful.

Now I've hacked together a load of code to do this, and to be honest the
CUI itself is a bit shoddy (not to mention the quality of the code). To
see this, look in cvs at
/television/bot/Autobot/FingertipTV/Responder.pm on 2003-02-09
but what it demonstrates is:
- storing a history of cursor positions
- makes a move based on user input and the cursor history
- making output based mainly on the cursor, and a little on history

What would be really nice would be a way to generalise this, to encode
the map (somehow, even though it's not a discrete location type of map),
and then write the interface separately.

But for the moment, just play with the FingertipTV interface and make it
good.