INSTRUCTIONS FOR A TYPICAL INTERACTION (For the FIT framework) A developer may create a fully-functional intelligent training system using only domain-specific knowledge and task modeling. After creating the basic task model, additional information is required by FIT, such as specification of display features and basic action interpretation logic (high-level). Once these are in place, FIT will automatically provide appropriate GUI elements and handle input processing as well as communication among the modules and the task model. (For the GPS example) java -jar FIT.jar gps NewRoute To start, load gps.xml and choose a task to start, such as NewRoute. At each step of the interaction, the system will monitor user input and determine if the actions taken support the current goal. If not, the user may be guided towards the proper interaction. Users may also explicitly ask what is to be done next, and also inquire into the reasoning behind certain actions. Once a task is fully completed, the user will have learned not only how to complete the training task, but also why each individual step was a necessary contribution to the overall goal. WHAT WORKED I was successful in creating a system wherein the domain-specific and domain-indepedent portions are almost entirely independent, allowing for development of an intelligent training system by a non-programmer. Further, the full system very strongly follows a Model-View-Controller architecture, so that changes to the domain knowledge, modifications to the GUI elements and additions to the central logic can all be done independently of each other. Thus, the framework is easily extensible and very flexible, allowing further development projects to extend its feature set and improve its core capabilities. In addition to providing an extensible framework, I have also shown a sample implementation of a training system developed in FIT. The sample GPS domain exemplifies the capability of the FIT framework for hosting a training system where both the domain model and the system operation as a whole are guided by the task model. The example system shows clearly how a user with little to no programming knowledge could create a robust task model in the FIT framework and let the other system components handle GUI generation and execution flow. The end result is a fully-functional intelligent training system built upon a platform which is itself considerably easier to learn than a full-fledged programming language. WHAT DIDN'T WORK When I started this project, my initial aim was to develop a fully collaborative agent-based intelligent system for aiding in the use of a GPS device. Users would be able to operate the device fully independently, but also could request information on what to do next or why certain tasks were required for completing a goal. Further, the system could be customized based on a user's level of expertise, perhaps with some amount of system learning in place to dynamically adapt the system's level of automation. As the project progressed, I decided to explore the idea of using the task model for more than just its basic functions and instead tying in more full system control. This would allow me to create a system where the task modeler could guide the full system operation, making the code base more of a framework for non-programmers to build upon. However, I found that when trying to make program operation tightly coupled with the task model, I could no longer have a fully collaborative system. By their very nature, the two ideas contend in a push-pull manner: collaboration requires that a user be unrestricted by the agent and the task model, while coupling program operation with the model disallows deviation from said model. Thus, the system became focused on intelligent training, wherein the user is guided along a specific set of steps in order to learn a particular task, which works much better with the task-model-driven architecture. One aspect of the framework which remains incomplete is the ability to interact directly with the Javascript environment of the task engine. A potential solution is partially in place, but requires additional work and will certainly add more complexity. The basic idea is that a task can have a certain property which makes a reference to some element of the Javascript environment (e.g. a function call), and the agent can use the eval function to access whatever it is that is referenced. Fully communicating data between the agent and the JS environment, and determining or specifying how to handle the given data are problems left for future development. FUTURE DIRECTIONS Much can be done to improve the framework and make it both more functional and easier for developers to use. For the GUI, additional menus and forms can be developed for use by system developers. In addition, better communication of the existing GUI elements and their required parameters should be available so developers can more easily create the GUI property definitions needed to make their system work. Additionally, speech output would be a fairly simple yet potentially valuable addition. For the agent, more complex handling logic and additional features are certainly possible and could greatly aid the usability of FIT as a framework and allow for richer end-systems. One example is given above, in that allowing for usage of the task engine Javascript environment would allow for a much deeper representation of domain entities and knowledge. Overall, the framework would benefit greatly from expanded documentation and possibly tutorials. A key goal of the system is to allow development of intelligent training systems for those with strong domain knowledge but little programming knowledge, with the idea being that learning to use FIT will be easier than learning to program a GUI and logic center in a language such as Java. To that end, improved documentation of the usage of FIT, the available features and parameters used to access them would contribute greatly.