next up previous contents
Next: Lessons Learned Up: Java Uniform Document Environment Previous: Comparisons   Contents


Jude is a rapid application development tool that permits developers to formalize a problem and then obtain a full featured and usable data management, workgroup application that can be further customized implementing specific agents.

The knowledge-base is specified using a declarative and understable language. This permits expert users of a particular domain to collaborate with knowledge engineerings during development process. The knowledge-base is a formal description of the problem and is enough understable to be a source of documentation of the conceptualized domain. The object-oriented structure permits reusing of already specified types.

Agents are a way to separate the logic of the application, represented from the knowledge-base on the server, from user facilities, represented from agents running on the client side, as suggested by all design guidelines.

From a developer point of view agents divide a system into a collection of cooperating and loosely coupled components. This increases re-usability and decrease errors, contrary to a big chunk of tightly coupled code. The difficult task of agents interaction is accomplished by Change-manager. It informs agents of knowledge-base changes involved from other agents.Thanks to it agents does not need to interact each other but they must only deal with knowledge-base changes.

From a user point of view agents are services to use. Every different user functionality of an application can be managed from a particular Jude-Agent. They could behave like secretary remembering appointment to user, suggesting important things to him etc. In particular they are used in Jude to view and edit the content of knowledge-base.

Jude supplies default agents, especially related to user interface, that are useful in a lots of different application domains.

Jude is a rapid application development tool not based on automatic generation of code but on the reuse of knowledge-bases, thanks to their object-oriented structures, and on the reuse of user interface elements, thanks to object-oriented, compound-document framework. The high-level and declarative language used in knowledge-base specifications reduces the effort contrary to usage of low-level and imperative languages.

Although Jude structure is simple, it has required a lot of work. As noted from [Fowler 1997]:

``The simplest model is not necessarily the first one you think of. Finding a simple solution takes a lot of time and effort, which can be frustrating. People often react to a simple model by saying ``Oh yes, that's obvious'' and thinking ``So why did it takes so long time to come up with it?'' But simple models are always worth the effort. Not only do they make things easier to build, but more importantly they make them easier to maintain and extend in the future. ``

next up previous contents
Next: Lessons Learned Up: Java Uniform Document Environment Previous: Comparisons   Contents
Massimo Zaniboni 2001-03-10