This chapter defines Jude, describes the reasons for its development, its current structure/design and its features.
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.
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.
This section gives a bird view of structure of Jude Applications. First of all, some important terms are defined:
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.
Most applications development methods are based on:
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.
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: