Joyce was a toolkit for building visual programing environments that allowed domain experts to create decision trees.

1. Joyce: An Object-Oriented Decision Tree Builder
by Bob Marcus
Knowledge Systems Laboratory
Boeing Advanced Technology Center for Computer Sciences
Boeing Computer Services
P.O. Box 24346
Seattle, Washington 98124 M/S7L-64
Abstract
Joyce is an object-oriented visual programming environment for nonprogrammers. It permits an
application developer to assemble a program by graphically choosing methods from a large library
and linking them together using predefined control structures. Joyce also provides the developer with
the ability to define data structures, interactive forms, and documentation without programming.
Introduction
The purpose of this paper is to describe a visual programming environment called Joyce that
allows application experts with limited computer experience to build and maintain programs. The
basic idea ofJoyce is to provide a large library of methods and data structures tailored to a specific
application. In addition, Joyce provides templates for simple control primitives and generic methods.
The application developer builds a program consisting of a directed network of nodes by assembling
predefined methods and linking them using the control primitives.
To build a specific implementation of Joyce, it is necessary for a programmer to learn enough
about the application domain to create the library of methods and data structures~ Once this is done,
it should be possible for a domain expert to create and test programs with minimal assistance from
the programmer. The traditional task of building an application program is thus divided into two
parts, developing the components for the domain and assembling the components into a program. The
Joyce system provides a large library of generic methods and tools for building domain components.
The philosophy behind Joyce is that the enhanced abilities of the next generation of workstations
and personal computers are making it possible for programmers to provide environments that will
allow nonprogrammers to construct and maintain programs in a wider range of domains than current
application generators. The key technologies are object-oriented programming, which allows the
construction and reuse of software libraries [Meyer] and visual programming, which allows the
linking of software modules into a program using graphical interfaces [Shu].
Overview
Joyce runs on top of the KEE programming environment developed by Intellicorp. Joyce consists
of five basic systems: Root, Methods-library, Node-templates, Domain Knowledge-base and Program.
The hierarchy is shown in figure 1.
Figure 1.
The basic systems can be further divided into subsystems. Each subsystem consists of objects in
an inheritance tree. The trees in any subsystem can be displayed graphically, with the objects
appearing as labeled nodes. In addition, the inheritance graph of any node across different
subsystems can be displayed. Every part of the Joyce system is contained in some object and can be
accessed by means ofa mouse and menus.
121

2. Programs are constructed in Joyce by sending BUILD messages to template nodes in the template
node system. This message runs a method that starts by popping up a form to gather information
about the new program node. After the form is filled out, the new node is created and linked into the
program.
The types of nodes that can be created are control nodes, data structure nodes and action nodes.
The control nodes can be various types of branches, menu selections, jumps, or subprogram procedure
calls. The data structures are object-oriented representations of the structures that must be
predefined before the program is run. Typically these would be the templates for instances of
particular data structures that are created at run time.
The most commmon type of node is an action node. This node is an object that will execute some
method as the program is running. There is a large number of domain-specific and generic methods
that can be selected graphically from the methods library without programming and linked to action
nodes. Some examples of generic action nodes are:
a. Network file input and output.
b. Distributed database commands.
c. Remote procedure calls.
d. Running remote interactive programs in windows.
e. Creating of data structure instances.
f. Local function calls.
g. Forms processing.
h. Access to a hypertext documentation program.
Once a program graph has been built, the program can be run by sending an ACTIVATE message
to a node. After the node has run its method, it sends an ACTIVATE message to its children. An
example of the inheritance structure of a program node is figure 2.
"Program" in
root system
Parent
program node
C> Template in
node-templates
Program-node
Figure 2.
With this structure, the BUILD and ACTIVATE method is inherited through the template node,
general program utilities are inherited through the Program node in the root system, and program
variables are inherited through the parent program node. The program nodes do not have any local
methods, and thus the program system does not have to be recompiled as nodes are added or deleted.
Some of the important flexibility features that Joyce provides for the nonprogrammer application
developer are:
a. Arguments of methods can be preassigned, retrieved from data structures or requested from the
user at run-time.
b. Forms can be constructed and used at run time to gather information from the user.
c. Nodes that are attached to the program graph are automatically linked into the program and can be
chosen by branch and menu selection nodes.
d. Trees or nodes can be copied, renamed, and added to a new location in the program.
e. Procedure trees can be built and called in a manner similar to procedures in conventional
programming.
122

3. Programming Utilities
The Joyce environment provides tools for the nonprogrammer application developer to test and
debug programs. These tools can be used to provide runtime monitoring and validation of the
program. Some of the tools provided are as follows:
a. Trees or individual nodes can be placed in debug mode, which triggers the printing of detailed
information about the methods being run.
b. Trees or individual nodes can be placed in trace mode, which prints out the names of nodes as they
are activated and places the names on a history stack.
c. It is possible to place stopping points in the program that permit reviewing of data and then
backtracking by menu selection to any node in the history stack and restarting the program.
d. Precondition and postcondition predicates can be attached to any node. These conditions will stop
the program and report an error ffthey are not satisfied.
e. There are utilities that parse the program graph and check for missing slots or values in program
nodes; for example, they check that every child of a conditional node has a predicate to test.
f. Comments attached to every program node can be viewed by sending a COMMENT message to a
node.
g. All of the local slots of a program node can be displayed and edited by means of a forms interface.
In general, all of the tools available in the Lisp and KEE environment can be customized to add
even more functionality to the application developer's environment if necessary.
Related Tools
Joyce was originally developed as an enhanced replacement to a commercial Fortran-based
decision tree application generator called DCLASS. DCLASS allows a nonprogrammer to build a
decision tree using either a batch file or a graphical interface called SPROUT. DCI.ASS has been used
to generate programs with extremely complicated tree logic.
In spite of the success of DCLASS-based applications, it was felt that DCLASS was limited in its
ability to explicitly represent the structure and underlying logic of complicated domains. Joyce was
built to combine a relatively simple control structure like that of DCLASS with the advanced
representation and reusability possible with object-oriented programming. Another advantage of
Joyce over DCLASS is that there is no need for global variables or keys to store values, since this
information can be saved and retrieved from slots in program nodes.
The physical objects in the application domain are divided into specialized subsystems. In
addition, there are subsystems for standard forms and manuals. Each subsystem can be displayed as
an inheritance tree of nodes. There are links between related nodes in different subsystems. These
linked nodes can be displayed together in a single window.
The output of the program generated by Joyce will include not only external files but also a
directed graph in an output subsystem, which can be displayed in a window and edited after the
program is completed.
Conclusion
Joyce is a visual, object-oriented programming environment for a domain expert with limited
programming skills. A programmer is required to add domain-specific methods and data structures to
the environment before application development begins. Joyce offers an alternative to the traditional
knowledge engineering and knowledge acquisition techniques of application development. It provides
a method for a programmer and a domain expert to divide the task of producing an application into
component building and component assembly. In the field of process planning, Joyce has the potential
of replacing earlier decision tree builders. There appear to be many do mains that can benefit from the
Joyce approach.
References
Meyer, B., Object-oriented Software Constructgon,Prentice-Hall, 1988.
Shu, N. C., Visual Programming, Nostrand, 1988.
123