@device[postscript]

@heading[Context]

@begin[enumerate]
Introduction:  What do we mean by context?  Cite literature on situated 
action.

Methodology issues:
@begin[enumerate]
Observation in the field

Experimental studies

Software development

Theory building
@end[enumerate]

Previous work:  
@begin[enumerate]
Doctoral dissertation #1

Interactive Trouble-shooting simulator

Editor Tutor experiment:  oops:

Lens results:  multiple rulesets

Pygmalion design
@end[enumerate]

@begin[multiple]
Proposed study:  Can we explicitly accomodate user context as a way 
of changing the user's interaction with the software?  Can we 
use "ability to incorporate user context" as a variable in evaluating 
software systems?  Look at the tailorability literature?  Any likelyhood 
of an effect?   In some sense, I take this as an assumption -- but 
how can we explicitly test it?  It seems clear that users go out of 
their way to build context into their software environments:  how 
can we help them do it explicitly.  Is there an operational definition, 
and a set of corresponding measures, for "user context"?  (HAH!)
Lens study and editor tutor studies provide a start.  What else is 
in the literature?  This also relates to my old educational stuff:  
the idea that some kinds of information are provided, sucessfully, 
without any knowledge of the users activity, while others only make 
sense in particular contexts.  This is the link between Skinner/Shoenfeld's
programmed instruction and Papert's logo -- what is the relationship 
between the material and what's happening to the user.  The intelligent 
tutoring literature is about trying to predict or detect user states -- 
but usually in a pretty limited way.

If successful, this gives a strong basis for why iterative design, 
with real users in real settings is so important -- it tells you 
what the user's context is.  A key issue is:  can you get users to 
put information about their current context into the system without 
having to explicitly verbalize it?  Again, editor tutor and lens 
multiple rulesets both provide a way of doing it.  Is there something 
more systematic? Can we encourage it?  Take advantage of other things 
happening in the system?  Other people?
@end[multiple]

Conclusions:  What about co-adaptive systems, which explicitly capture 
user context in various ways and use that information to modify the 
software?  Also, capture changes in the organization -- the data feeds 
back.  Is it chaotic and therefore unpredictable?  Is it good?  Does 
it happen anyway?  How can we come to understand it?  It's a different 
way of looking a computer networks -- not as immitations of existing 
kinds of communication but as evolving ways of creating new kinds of 
activities and communication.  To empower, to teach, to react to change, 
to innovate.

@end[enumerate]

