1;;; -*- Mode:gate; Fonts:(CPTFONT CPTFONTB* 1MEDFNT) -*-*


=Node:2 Information retrieval *
=Text:


			**** Coming real soon now ! ***

=Node:2 Editing *
=Text:

  		**** Notes towards the real editing help node ****


	Editing in Gateway

		o Per node attribute lists

		o Adding attribute values

		o Adding nodes to the data net

		o Creating nodes from regions

		o Creating nodelists from node files

		o Creating documents from nodelists

		o Styles of editing

	Zmacs wysiwyg editing and formatting

		o Indenting regions - Meta-Control-\ -

			- alone

			- with a prefix

		o Font control - Control-X-Control-J



=Node:2 Document creation*
=Text:


			**** Coming real soon now ! ***



=Node: Gateway goals and design principles
=Nodelist:

2@Initial Goals
@Current Goals
@System Characteristics
@*    2Create And Modify Information Units (Nodes)
@*    2Retrieve And Display Nodes
@*    2Create And Modify Relations Among Nodes (Information Control Structures)
@*    2Retrieve And Display Information Control Structures
@*    2Execute Nodes
@Design Principles
@*    2Use Of The Node As A Functional Object
@*    2Separation Of Data And Information Control Structures
@*    2Separation Of Gateway Engine And Data Handler 
@*    2Separation Of Gateway Engine And Display Handler
@Target Users
@*    2End User
@*    2Application Designer
@*    2System Designer
@Conclusion*

=Node: Initial Goals
=Text:
	  
	  When we started the Gateway project a year ago, we intended to create an
	  integrated online documentation and help system which would contain
	  some writer's aids, such as annotation facilities.  In addition, we
	  knew that we wanted it to run as a major mode in ZMACS, the Lambda
	  editing system, because we wanted users to be able to edit programs
	  and access system documentation without having to leave the editing
	  environment.
	  
	  We also strongly believed that information units and the control
	  structures that organize them should be kept separated, because we
	  wanted to use the same pieces of information in a variety of
	  different ways.  For example, we wanted to be able to embed pieces of
	  the LISP Machine Manual into education tutorials without having multiple
	  copies of the source.
	  
	  What we found as we evolved our design, and started the first of what
	  seems like dozens of prototypes, was that these goals generalized, and
	  our application plans expanded, to encompass a range of possiblities far
	  beyond our original intent.


=Node: Current Goals
=Text:
	  
	  As a result, our current application goals include, in addition
	  to the original applications described above:
	       
	       o Student modeling in an interactive computer assisted
	         instruction project - GUIDE
	       
	       o General interface development
	       
	       o A writer's tool kit
	       
	       o A personal information management system - ROSE
	       
	  
	  To explain how we are able to use Gateway to attain these application
	  goals, I would like to briefly describe Gateway and the design principles
	  that lie behind it.


=Node:     2Create And Modify Information Units (Nodes)*
=Text:


	
	
	  Nodes are units of information which are composed of attributes
	  and their values.  Typical attributes include such things as
	     
	       o Text - what you normally see on the screen
	       
	       o Author name
	       
	       o Related information
	       
	       o Function to call upon access
	       
	       o Nodelist - list of pointers to other nodes
	       
	       o Pictures
		
	  Application systems built using Gateway may create nodes with
	  attributes specifically designed for that system. 


=Node:     2Retrieve And Display Nodes*
=Text:

	  
	  
	  Nodes can be retrieved in several ways:
	       
	       o By selecting an element of a menu-like list, called
	       a nodelist
	       
	       o By selecting a previously accessed node from one of
	       the various session history lists
	       
	       o By selecting a cross reference 
	       
	       o By choosing an entry in the online index
     
	  Once a node is selected, it is displayed according to the
	  display configuration currently active.  The configurations 
	  can vary greatly,  relecting the application and preferred working 
	  style of the user.


=Node:     2Create And Modify Relations Among Nodes (Information Control Structures)*
=Text:
	
	  Information control structures in Gateway can range in complexity
	  from unordered collections, to simple lists, to trees, to fully
	  general directed graphs. Cross references are examples of directed
	  graphs, while books can be simple lists or trees.  Control
	  structures are implemented through nodelists, cross references, and
	  indexes.  
	  
	  Nodelists are simply lists of pointers to nodes.  Since nodelists
	  are themselves a type of node, they can be pointed to by other
	  nodelists.  For example, the LISP Machine Manual is organized as a 
	  tree:  
	       
	       o The first nodelist is the chapter table of contents. 
	       
	       o Selection of an element of that nodelist, brings in the nodelist 
	         for the chapter. 
	       
	       o Selection of an element of the chapter nodelist brings in the 
	         requested data node. 
	  
	  Nodelists, indexes, and cross references all can be created and
	  modified, just as data nodes can.  One nice serendipity of
	  editing nodelists is a high level cut-and-paste method of
	  writing that allows the writer to redesign document structures simply
	  by rearranging pointers to the different components.
	  

=Node:     2Retrieve And Display Information Control Structures*
=Text:
     
	  Information control structures that are represented as nodelists are
	  currently displayed as selectable, menu-like lists.  We are working
	  on methods of graphically displaying those structures which can be
	  represented as two or three-dimensional directed graphs.  For
	  example, the tree structure of the LISP Machine Manual might look
	  like an organization chart, with the chapters as the first level, and
	  the lists of nodes in each chapter as the second level.

=Node:     2Execute Nodes*
=Text:
	
	  Because a node can contain pointers to executable functions, application
	  designers have the ability to drive devices such as music synthesizers,
	  high-powered graphics displays, spreadsheet applications, or interactive
	  tutoring systems.  For example, suppose you wanted to interactively teach
	  the canon form of music.  You might design a system that does the
	  following: 
	       
	       o Presents the written description of canon form in one pane
	       
	       o Calls a function that causes a music synthesizer to start playing
	         Pachabel's Canon
	       
	       o Displays the score, with the currently playing notes highlighted,
	         in another pane
	       
	       o Shows a graphical representation of the dynamics of the music in
	         yet another pane
	       


=Node:     2Use Of The Node As A Functional Object*
=Text:
	
	  One very important design principle in writing is that the
	  presentation medium affects the form.  For example, a marketing
	  brochure has a very different set of layout requirements than a
	  technical manual.  The brochure writer must be aware of the
	  page layout as a factor in deciding what words to use.  Similarly, the
	  online information designer must also take the nature of the computer 
	  as a presentation medium into account.
	  
	  The unique opportunity the computer provides for information designers is
	  clearly seen in such projects as Alan Borning's online encyclopedia.
	  There, an article on the physics of springs could do more than
	  include pictures of various spring deformations; it could execute an
	  interactive function that dynamically shows what happens under
	  different conditions.
	  
	  Gateway implements such a capability through the use of functional
	  nodes.  Such a node includes a pointer to a function that can be
	  executed when the node is accessed.  The decision as to whether or
	  not to execute the function is left up to the application designer.  
	  

=Node:     2Separation Of Data And Information Control Structures*
=Text:
     
	  The ability to separate data and information control structures is one of
	  the most valuable properties of the computer as electronic publishing
	  medium.  Immediate applications that spring to mind are: 
	       
	       o Interactive anthologies whose content is determined by user
	         choice
	       
	       o Single sourcing of technical information that is needed in a
	         variety of contexts
	       
	       o Linking of code, documentation, bug reports, and revision
	         histories into a general customer-service and bug-management
	         system  
     
	  These and many other applications are made possible
	  both by the fact that many different nodelists, serving many different
	  purposes, can access the same node, and by the variety of ways of linking
	  nodes together.


=Node:     2Separation Of Gateway Engine And Data Handler *
=Text:
	
	  The gateway engine is the set of core routines that allow the
	  user to decide what node is to be displayed next.  These routines
	  know nothing about the data handler that interfaces with the file
	  system.  They receive data in the form of property lists that are
	  then used to set up the node objects.
	  
	  This allows us to think in terms of Gateway applications that access
	  other data handlers, such as a spreadsheet living on an IBM PC, or a
	  database running on a VAX. Nodes obtained from these sources can be
	  combined into a heterogeneous information system that moves freely
	  among different machines and information structures.  For example, an
	  online encyclopedia article on electronic spreadsheets could include
	  functions that call a demo of Lotus 1-2-3, and an interactive
	  expert-system based tutorial on how to use Lotus.


=Node:     2Separation Of Gateway Engine And Display Handler*
=Text:
	
	  Just as the Gateway engine calls data handler interface routines to
	  obtain information nodes, it also calls display handler routines to         
	  display them. This means that Gateway nodes could be displayed on
	  character-oriented terminals attached to non-window oriented systems.  
	  
	  This allows us to think of distributed information net applications in
	  which users run Gateway on their small workstations, accessing large 
	  quantities of information stored on a variety of file servers.  
	  
=Node:     2End User*
=Text:
     
	  The end user uses the existing Gateway facilities as an editing and
	  information retrieval environment.  Since Gateway usage requires no
	  knowledge of programming or the Lambda programming utilities, these users
	  will frequently be information handlers who are not programmers.  For
	  example: 
	       
	       o Librarians managing an online data net
	       
	       o Programmers documenting system design in nodes that point to
	         the various pieces of code that implement them
	       
	       o System users who need information, perhaps including tutorials
	       
	       o Writers who want to manage review comments and revision
	         histories, as well as to extracting and change the structure of
	         documents currently being written
	       
	       o Managers tracking and reporting on project status


=Node:     2Application Designer*
=Text:
     
	  The application designer builds upon Gateway as a base, changing and adding
	  node attributes, and modifying existing information control structures
	  to meet the needs of a different domain.
	  
	  For example, GUIDE, LMI's interactive computer-aided instruction
	  project, converts the session history list, originally intended to aid
	  users in quickly accessing nodes already read in, into the backbone
	  of a student modeling system.


=Node:     2System Designer*
=Text:
     
	  Modifies or replaces the data handler and/or the display handler.
	  This will be possible both because the Gateway engine is separate from
	  the data handler and the display handler, and because Gateway will be
	  released in a COMMON LISP form designed to be portable to other
	  computers.


=Node: Current Applications
=Nodelist:

2@Online Documentation Production And Use
@GUIDE - The LMI Interactive Computer Aided Instruction System 
@ROSE - Rosemary's Own System Environment*

=Node: Online Documentation Production And Use
=Text:
     
	  This, the initial goal of the Gateway project, is still the most important
	  application area for both in-house users and for customers.  Gateway is the
	  Lambda's online documentation system.  All of the current LMI documentation
	  will be online and accessable through the global index.  In addition, a
	  major ongoing project is the development of a writer's tool kit to
	  facilitate the creation of new information nets and their incorporation
	  the existing datanet.  


=Node: GUIDE - The LMI Interactive Computer Aided Instruction System 
=Text:
     
	  GUIDE will be an ICAI system designed to aid student in learning a
	  complex set of skills (operating and programming the Lambda) in an
	  interactive and relatively unstructured environment.
	  
	  This application builds upon and modifies the Gateway facilities in the
	  following ways:
	       
	       o Student activity histories, which trace student interaction with
	         the system, will be a modification of the Gateway information
	         control structure, session history lists.
	       
	       o The student activity histories will provide the foundation for
	         the student model algorithms.
	       
	       o An Intelligent Selector will determine appropriate curricula
	         for the student, based on information from the student history
	         and student model.
	       
	       o The Browser, a dynamic indexer, will allow creation of
	         customized and multiple indexes, including indexes to curricula
	         subsets appropriate to a particular student
	       
	       o These tools will be built around an Interface Manager, which
	         will aid students in making appropriate choices, based on
	         algorithms of prerequisites and perceived student mastery of
	         material.
	  
	  These and other tools will optimize access to information for both
	  novice and expert user levels.



=Node: ROSE - Rosemary's Own System Environment
=Text:
	  
	  The ROSE personal information management project is intended to
	  manage a heterogeneous collection of information resources.
	  These resources include books, journals, files, and notes.  Much of
	  the work with these resources involves rapid cataloging of large
	  quantities of information, pattern seeking to find related groups of
	  information, and the retrieval of relevant data.
	  
	  To do this we are creating tools will:
	       
	       o Aid in quickly cataloguing literature for retrieval at some later
	         date
	       
	       o Reflect changing interests and retrieval terms by facilitating
	         the revision of older categories and the addition of new ones
	       
	       o Help uncover previously unsuspected relationships
	       
	       o Provide printed indexes, diagrams, books whose organization can
	         change easily and radically to reflect changing needs.
	       

=Node: CONCLUSION
=Text:
	  
	  We started out to provide an online documentation and help system.  In the
	  process of separating information units from the information control
	  structures which organize them, we created modular tools, tools that can be
	  mixed and matched as needed.
	  
	  Now, as we continue to expand these tools, we would like to invite
	  comments, suggestions, wild dreams, concerns - what ever you would like to
	  say.  



=Node:2 *Lambda commands reference
=Text:














			TO BE SUPPLIED


=Node:2 *Glossary
=Text:













			TO BE SUPPLIED