In summarizing the work set forth in this thesis, it is useful to analyze the original stated aim for the present research. As presented at the beginning of Chapter 1, the goal of this research was to evaluate Java as a suitable programming language for the Internet by using it to implement a concept mapping system able to support distributed user environments on the Internet and the World Wide Web.
To achieve such goal, the Java programming language was thoroughly analyzed and used to develop a concept mapping system that can work as a standalone application or as an applet inside Web browsers. These programs, which are named jKSImapper and jKSImapplet respectively, are designed to perform as elicitation agents that interact with server processes. These server processes will perform as centralized coordinators and data repositories. In this context, the Web acts as a hypermedia integrator, and the Internet as the transport medium.
On the other hand, requirements for a multi-user system were defined according to the Computer Supported Collaborative Work interaction modes for a community of users working on a common project. Such requirements represented guidelines for the development of multi-user systems on distributed environments, such as the Internet and the Web.
To evaluate the Java concept mapping tool in a range of practical applications.
The sixth objective, to evaluate jKSImapper and jKSImapplet in a range of practical applications, was met through the many examples displayed on this research, which are mentioned as follows:
This section will propose viable extensions to the Java systems presented on this thesis. It is important to bear in mind that, since these systems provide a generic solution for concept mapping elicitation on the Internet and the Web, the suggestions made on following sections are exclusive to the perspective of the author, and they do not represent limitations on the application of the systems to other domains.
As explained below, two different extensions are proposed: one, to support graphical elicitation of conceptual graphs; and, second, to integrate jKSImapper as a component for the Habanero Environment, which is a Java groupware system developed by the National Center of Supercomputing Applications (NCSA).
Conceptual graphs can be denoted using three different representation types. Such representations will be described and illustrated using the sentence "Dickson went to Calgary by plane" (Lukose, 1996):
Figure 39. Example of a Conceptual Graph as a Diagram.
[GO] --> (AGENT) -> [PERSON: Dickson]
-> (INSTRUMENT) -> [PLANE]
-> (DESTINATION) -> [CITY: Calgary]
<- (PAST)
|
Figure 41. Example of a Conceptual Graph as a First-order logical formula.
Another example of the application of jKSImapper and jKSImapplet is found on current collaboration efforts undertaken between the Knowledge Science Institute and the Department of Mathematics, Statistics and Computer Science at the University of New England, Australia. Such efforts may result on the unification of systems into a distributed environment for the elicitation of centralized knowledge bases. In this context, jKSImapper and jKSImapplet will act as client elicitation agents to create and edit knowledge structures maintained by an Extendible Graph Processor system (Garner, Tsui, Lui, Lukose and Koh, 1992) performing as a server process. Future developments may also extend the functionality of these systems to allow the translation of conceptual graphs into alternate forms of knowledge representation.
Habanero is defined a client/server system composed of a server process coordinating client systems, each supporting a collection of Java applications. Client applications currently shipped with Habanero include multi-user versions of a whiteboard program, a text editor, and an audio chat for voice communication. To support such systems, Habanero implements networking and synchronization mechanisms that allow to share state, data and events generated by users manipulating client software systems.
To maintain a consistent state among client applications, Habanero implements mechanisms that allow clients to route user events to a server, which will broadcast such events to all the participants on a session. Since such runtime structure is similar to the one implemented on jKSImapper, it is feasible to adapt and extend the present system to operate as a Habanero client application. This circumstance will help to increase the awareness of concept maps as collaborative tools, and will allow jKSImapper to be under the scrutiny of different communities of users, some of which might find it suitable for extension on their particular domains.
The following sections have been included as a critique of the limits, weaknesses and imperfections detected on the implementations described on this work. Proposed enhancements will be addressed under three different sections: Human-Computer interfaces, Multi-user issues, and Miscellaneous improvements.
One method to discover the strengths and weakness of a user interface, is to count the number of keystrokes and mental operations (decisions) required for the tasks the user intends to achieve. This will enable estimation of task times and identify tasks that take too many steps.
Figure 42. Font style modification using menu commands.
Figure 43. jKSImapper Toolbar.
Functions provided by the toolbar may allow the creation and modification of objects. This dual functionality will be defined by the existence (or the absence) of selected elements on an elicitation.
If multiple objects are selected, the toolbar will reflect the common denominator values for attributes of those objects. In the case of the example shown on Figure 43, a rectangular node labeled "PERSON: Tom" is selected. As a result, the node's characteristics are reflected on the toolbar's controls, which can be used to modify the attributes of the node. In this case, buttons located at the top of the toolbar can be used to change the shape of the node to ellipse or rounded rectangle. In the case of this example, the remaining buttons are shaded since they do not reflect options applicable to the selected object. Additional controls included on the toolbar are: a color palette that works in conjunction of a list box to modify color attributes on the targeted object; an input line for editing the label of the object; and a pair of list boxes that are used to select the selected element's font attributes and their values, respectively.
The toolbar can be used to create new elements if no objects are found to be selected. In this case, new objects will have their attributes initialized to the values provided by the controls in the toolbar. This technique can speed the creation of multiple objects using non-default values.
However, the toolbar approach is not suggested as the ultimate solution for human-computer interaction, and it certainly contains weaknesses. One of such limitations is found on the creation of new elements while existing objects are selected. This circumstance represents a problem, since the toolbar presented does not accommodate (yet) the functionality to switch states from modification of selected items to creation of new items.
Additional enhancements to the user interface can be achieved by implementing pop-up menus and in-place edition of labels. These techniques can make explicit the operations available for an object (in the case of pop-ups) and substantially simplify the modification of objects' attributes. The implementation of these approaches is not defined in this thesis, and they are left for future development.
There are features that can be used to provide awareness on multi-user environments. For example, there are mechanisms to identify the members collaborating on a multi-user session. However, techniques vary from displaying a list box listing the names of the participants, to the implementation of individual cursors for each participant and global viewers displaying the location of each participant under the entire domain of the session. The suitability of such techniques depends on the context on which the target application will be used.
In general, groupware techniques allow participants to be aware of the presence of other participants (e.g., by using global viewers displaying each member's cursor); they allow participants to be aware of the operations performed by each collaborator (e.g., using authorship and concurrency control); and may allow communication between members of the session (e.g., by using text areas for message exchange, or using voice transmission processes). However, as desirable as these functions may be, the implementation of some of them may require high bandwidth network connections. In the case of jKSImapper and jKSImapplet, such networking power may not be available, since these applications were designed to work on the Internet, which is a networking environment that does not make any assumptions with regard to speed and reliability.
The identification of participants and concurrency control are issues that need to be implemented on jKSImapper. Identification of users can be achieved by maintaining a list of members joining the server. This information can be made available to all the clients for display (e.g., using a list form). On the other hand, concurrency control can be achieved by using centralized locks for displayed objects. Such locks can be maintained by the server, and will be represented on client systems by using visual feedback (e.g., using colors or patterns to indicate granted locks).
In the case of jKSImapper and jKSImapplet, the model described above was supported. Thus, methods were implemented to allow the painting of the graphs maintained by the system, and to allow the updating of such graphs in response to user events.
However, from these methods, the updating mechanism is not implemented efficiently in the systems presented, since they just trigger the painting of all the displayed objects after the execution of each command generated. This deficiency is evident as the complexity of a concept mapping elicitation grows. For example, in a concept map composed of one hundred objects, the movement of one of those elements will require the painting of the remaining ninety-nine objects, regardless of whether such movement affects or not their visual representation.
A solution to this problem can be found by implementing a technique called paint clipping. This technique is based on the delimitation of display areas affected by executed commands, and restricting the updating only to those objects displayed within such affected areas. In practice, the algorithms implementing this technique will impose greater processing loads to small concept maps, if compared with the current implemented algorithm; however, this technique will increase the painting speed as the number of elements on the elicitation increase.
In the case of the concept mapping systems described on this thesis, the implementation of a copy and paste mechanism may allow one to copy selected objects to a buffer, from where they can be retrieved by the same or by a different elicitation session, to duplicate concept map segments, or to copy concept map segments between sessions, respectively.
Buffers can be implemented global to the operating system or local to the application. The first case is supported by most operating systems, which provide a buffer that is shared by all the applications been executed. On the other hand, local buffers are implemented for exclusive use of an application. Due to the portability characteristics of Java, it is not clear at this point whether access to system buffers will be supported or not. This circumstance will lead to the need of implementing local buffers for the concept mapping systems described on this work.
To accomplish such task, the presented research introduced, during early stages, the notion of concept maps, followed by an overview of the Internet and the World Wide Web. The Web was described as a hypermedia environment capable of presenting Internet resources under a multimedia interface. From such resources, executable code was identified as the most versatile resource available, due to its ability to provide complex services as a response to users' interaction.
At this point, leading techniques that provide downloadable executable code on the Web were identified and analyzed based on their capabilities to support portability, security and functionality issues. Techniques evaluated were Java and ActiveX.
This evaluation was followed by a description of the characteristics found in the Java programming language, including an overview of the networking features that have positioned Java as a suitable programming language for the Internet and the World Wide Web. This discussion was followed by a comparison between Java and C++ at the language level.
The leading step towards production is based on a thorough understanding of the tools to use. In the case of this research, its first part was devoted to understand the features of the tool, which is the Java programming language, and the context of its use, which is the Internet and the World Wide Web. Once these topics were covered, the production of the system was started. As stated in the aim of this work, a concept mapping tool was to be implemented to support multi-user concept mapping collaboration on the Internet and the Web.
The process of producing such tool required the study of previous concept mapping developments as a guidance to the definition of the requirements for the system. Such requirements were defined based on levels used for the analysis of concept maps (abstract, visual and discourse perspectives), and on the functionality that the system has to provide to support multi-user environments (based on the CSCW interaction modes). The definition of the requirements for the tool was followed by an overview of the functionality implemented on the systems developed, which were named jKSImapper and jKSImapplet. These systems perform as Java concept mapping tools for the Internet and the Web, respectively.
The last part of this research was devoted to describe in detail the jCMap class hierarchy, the runtime system architecture for the systems implemented, and the lessons learned while porting C++ code to Java. Class hierarchies are structures composed of defined entities ordered to reflect the specialization of state and behavior. In the case of the this research, jCMap was presented as a class hierarchy composed of more than 60 classes designed to support jKSImapper and jKSImapplet. The operations implemented on these classes were described according to the areas on which they perform (which are Behavioural Graphic, Visual Graphic, User Interface, Command Handling, Networking and Server, and File Storage).
However, class libraries are not a suitable reflection of the relationships existing among objects at runtime. Thus, a description was required of how the objects collaborate to provide the functionality expected for the systems implemented. Such relationships between components in a program define the runtime system architecture for the system. In the case of this research, three architectures were presented; one for jKSImapper, one for jKSImapplet, and a third one for the server process.
This discussion was followed by a description of the lessons learned while porting C++ code to Java, and a section describing areas of future development.
Overall, this thesis has presented a usable implementation of a client/server concept mapping tool developed using the Java programming language. This tool can perform as a standalone application or as an applet embedded on Netscape browsers. Such developments, which are named jKSImapper and jKSImapplet, have been demonstrated to support the elicitation of concept maps on single and multi-user collaborative environments under the Internet and the World Wide Web.
© Roberto A. Flores June, 1997