next up previous contents
Next: A Simple Case Study Up: Java Uniform Document Environment Previous: Contents   Contents



This chapter defines Jude, describes the reasons for its development, its current structure/design and its features.

Definition of Jude

Jude is a rapid application development tool of data-management applications easy to maintain for developers and easy to use for end users. Jude is based on a knowledge-base with an object-oriented structure on the server side and a compound-document, agent-based user interface on the client side.

Rationale for Development of Jude

Relational Database Management Systems (RDBMS) are systems that manage a database in which the data resides in tables with a specific number of columns and an arbitrary number of rows. RDBMs benefit from a sound theory and from SQL, a standard language used to manage data in a declarative, high-level fashion way. However SQL is not sufficient to write complete applications, so RDMBSs are used together with other programming languages. This causes some problems because ``the declarative RDBMS paradigm awkwardly integrates with most programming languages, which tend to be imperative''[Blaha 1998]. RDBMSs support relations between objects, but does not support generalization / specialization relationships between types, used today in a lot of modeling methodologies. The user of RDBMS cannot define new data types and for some applications the allowed data are not sufficient. RDBMSs have a good support for short transactions but lack support for long transactions. ``A long transaction is a series of DBMS commands that extend over a long period- hours, day, weeks, or even months . A long transaction contrasts with the short transaction supported by conventional DBMSs, which ordinarily resolves within a few seconds. Long transaction arises in cooperative design, in which someone is responsible for a portion of a project and must perform extensive work before sharing the results.''[Blaha 1998] RDBMSs lack a support for change notification, that is the notification of object changes to registered components in a timely manner.

Object Oriented Database Management Systems (OO-DBMS) manage objects created by an object-oriented programming language. They are characterized from fast access to data and transparent integration with the hosted language. An OO-DBMS supports generalization / specialization and ``user-definable data types, and associations. Some OO-DBMS also support advance capabilities, such as schema evolution, version management, long transactions, and change notifications.''[Blaha 1998] Contrary to RDBMSs, OO-DBMSs are based on an incomplete theory. The development of an application using OO-DBMS encourages procedural coding over declarative coding and this tends to produce code hard to maintain because there are many relationships between different parts of the program.

Jude tries to join all good features of RDBMSs and OO-DBMSs in order to provide a better application development environment.

However lots of information of an enterprise is stored in forms of e-mail messages, documents, spreadsheets, HTML pages and others unstructured or semi-structured data formats. In order to support these informations Jude can manage files produced from others applications adding meta-information to them. In this case Jude plays the role of document-management tool. Jude permits also direct management (view, edit and retrieve) of contents with complex data formats. In this case Jude plays the role of an office automation suite.

Jude aims to be a comprehensive and smart solution for development of workgroup, data management applications and office automation suites.

Structure of Jude Applications

This section gives a bird view of structure of Jude Applications. First of all, some important terms are defined:

a language with an English-like syntax, a first order predicate logic semantic and an object-oriented structure.
an abstract, simplified view of the world we wish to represent.
a database management system that derives new facts from other base and derived facts applying rules
a database management system that monitors situations of interest, and when they occur, triggers an appropriate response in a timely manner.
a software component able to perceive its environment and react to it
a document that contains elements from a variety of computer applications.
A Jude Application consists of:

  1. a knowledge-base specified using the SimpleLogic language and compiled into the XSB-Prolog language;
  2. the XSB deductive-database management system running on the server side, see section [*] for more details;
  3. an Active Database running on the server side able to advise agents when changes occur in the knowledge-base ;
  4. an agent based framework running on the client-side;
  5. a compound-document user interface based on different viewers and editors for each type defined in the knowledge-base; note that viewers and editors are special case of agents;
  6. a synchronization manager that permits to synchronize two different versions of the same object after the termination of a long transaction;
This figure shows an example of a Jude Application work session:


The user-A through an editor modifies some facts about a certain object. Then the editor commits a transaction on the knowledge-base. The server database updates the base facts and the derived facts. Then it prepares a notification message containing all base and derived facts changed during the transaction. The message is sent to the query cache on client-A and client-B. Then the query cache notifies all interested agents of the changes in the knowledge-base.

The communication between agents is accomplished by active database and agents have not to interact directly together. This simplifies implementation of agents and overall systems.

Development of Jude Applications

Most applications development methods are based on:

  1. analysis: specify what needs to be done, understand the problem requirements throughly and devise a conceptualization of the real world;
  2. design: devise the system architecture for solving the application problem;
  3. implementation: produce the effective code;
The development of a program using Jude is focused on knowledge-base specification, that is a task of analysis phase rather than design or implementation phase. This figure shows a simplified view of Jude knowledge-base development:


The developer collaborates with an user expert of problem domain and try to specify a knowledge-base. The user is involved in the development process because ``effective models can only be built by those that really understand the domain. Expert knowledge is central to a good analysis model.''[Fowler 1997] The usage of an understable language as SimpleLogic permits users to specify (or at least check) the knowledge-base. The knowledge-base is compiled from SimpleLogic compiler that produces a Prolog knowledge-base that is read from XSB deductive database. The user can assert new base facts and the developer can test if inference rules are working in the expected way.

After knowledge-base specification you obtain a running application. A further step could be the implementation of viewers and editors for specific types. However in Jude there are already standard viewers and editors that are good in many different cases.

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.

Features of Jude Applications

In the last sections we have examined Jude from the point of view of a developer. In this section we change perspective and we consider how a Jude Application appears to end users.

Every Jude Application offers the service of:

a system that captures knowledge for a particular domain and use automatic reasoning tools to manage it.
any software product that enables groups of people to collaborate with each other. It allows users to access and share with other users a knowledge base and a repository of documents.
a work-group system focused on document management, for example viewing, editing, retrieving, accessing control, version management etc. It must provide a means for users to access the documents with good control over who has rights to do what.
a Document-Management-System.
any software product that takes in consideration the problem of users coordination, that happens when users work together by participating in structured or semi-structured processes. The workflow is ``the automation of a business process, in whole or part, during which documents, information or tasks are passed from one participant to another for action, according to a set of procedural rules.''[wfmc 1999]
a work environment where applications can inter-operate easily and the user can focus on the content. In compound-document environments ``applications inter-operate in a seamless fashion by using a single shared user interface. It frees the user to view one's work in a document-centric fashion, instead of as a set of applications between which one must move.''[Rush 1994] This type of environment is ideal for a collaboration product because permits a better sharing of documents contrary to the application-centric environment.
a user interface paradigm that display data as information chunks connected by links which offer the user different pathways.
a suite of programs able to execute a variety of office operations, such as word processing, accounting, and e-mail.
Note: up to date Jude Applications can not be classified as groupware-systems. A groupware-system is any software product that enables users to quickly and easily communicate with each other. Examples of groupware/communication products are: e-mail, chat-programs, electronic white-boards, Electronic Meeting System (EMS) , Group Decision Support System (GDSS), video conferencing etc.

next up previous contents
Next: A Simple Case Study Up: Java Uniform Document Environment Previous: Contents   Contents
Massimo Zaniboni 2001-03-10