Most current user interface specification languages and toolkits are based on serial, discrete, token exchange paradigms which, in general, perform an acceptable job of describing and implementing traditional WIMP (Window, Icon, Menu, Pointer) interfaces. These tools, however, are ill-suited to address the needs of emerging non-WIMP interaction styles such as virtual environments. These emerging interaction styles commonly rely upon: full duplex, asynchronous, interrelated dialogues; a blend of continuous and discrete inputs and responses; and, implicit commands and probabilistic input events. Additionally, some forms of non-WIMP interactions must also contend with real time processing constraints and deadline-based computations.
The SHADOW System is a specification paradigm (and a set of development tools which support this paradigm) which provides a framework of techniques and abstractions which directly address the issues raised above. The system has been demonstrated to allow both the behavior and semantic meaning of all interface elements to be clearly defined in a re-usable fashion while also providing support for software engineering practices such as modular design, complexity management, extensibility and traceability. Additionally, the system addresses issue of performance, portability, and maintainability; providing mechanisms which allow run time performance criteria and deadline contingency plans to be specified in a manner which is easily discernible and platform independent.
The SHADOW System addresses these concerns by providing a graphical specification language consisting of a data flow graph and an augmented transition network. This language is highly declarative in nature, supports loosely coupled, modular design and relies upon a run time engine to resolve constraints and to manage conceptually parallel tasks within uniprocessing environments (unfortunately it doesn't do much at all about resolving run-on sentences in the middle of a paragraph but I told people this would be on line by noon and its already ten past...) The SHADOW System run time engine provides the infrastructure which allows the interface designer to address conceptual and semantic issues of design without becoming entangled in the details of the implementation. The engine is responsible for internal task management, event propagation, and constraint binding. Additionally, the engine provides facilities which automatically adjust processing loads to meet designer specified performance criteria should CPU processing time consumption become a problem.
Currently the SHADOW System consists of a graphical specification language (SHADOW-Talk) which is manually converted into a textual language (SHADOW-Script). In text form the specification can be compiled using the SHADOW System compiler in conjunction with a C++ compiler (usually either g++ or Silicon Graphic's CC compiler). These objects are then linked with the SHADOW run time engine (and any user specified libraries) to create a stand-alone application. Several examples are available on-line to Tufts students at Allegro and Mondrian.
The size, diversity and complexity of this effort means that there is always work to be done (either expanding the system or testing it). If you're a Tufts EECS major looking for a senior project, Master's work, or a class programming project you might want to click here.