This chapter contains a brief comparison between Jude and other well known technologies. It is written under the assumption that the reader knows the cited technologies. It does not take in consideration all the benefits and disadvantages of a given technology but it speaks only of aspects related to similar Jude features.
Entities and relationships in the E-R diagram correspond to types and relations in SimpleLogic. The semantic of an E-R diagram correspond to SimpleLogic relation declaration (except relationship cardinality that is difficult to express in SimpleLogic). For example this E-R diagram:
correspond to this SimpleLogic source code:
declare relation type is_subtype_of type;
declare relation person has_age number at_date date;
The UML static structure diagram notation is an high level graphical representation of an object-oriented program structure/design. [Blaha 1998]suggests to use UML diagrams in order to represent the structure of a database. On the contrary SimpleLogic is a textual representation of the structure of a knowledge-base. In many cases the two formats have the same semantics. For example the two important relations of SimpleLogic is_subtype_of and is_a correspond to UML class inheritance notation and class instance notation. Relation declaration in SimpleLogic corresponds to UML associations between class. A SimpleLogic fact corresponds to a UML links between objects.
UML uses attributes that are just special cases of binary associations. An attribute can be mapped easily into a object-oriented program defining it as an attribute/field of a class. It permits designing of more compact UML class diagrams than relation notation of SimpleLogic. SimpleLogic prefers to keep the language simple and it uses only relations.
UML standard uses role-names instead of association names, because a role-name can be easily referenced when traversing an object model and in particular they can be easily used as name for class attributes. On the contrary SimpleLogic uses only relation names because they translate easily the formal specification into natural language.
Object Constraint Language (OCL) permits designers to add constraint to a UML class structure diagram. OCL is not meant to be an executable language, but it is meant as a language able to express pre/post conditions about methods of a class, and class invariants. In order to obtain an executable program you must implement effectively the methods using another language. This approach resemble the Eiffel Design by Contract approach where contracts are used to improve design, documentation and testing. On the contrary in SimpleLogic the specification is meant to be also the real executable program.
XML is a method for putting structured data in a text file. It derives from SGML that is a standard for specification of structured documents. XML syntax is good at specification of facts. SimpleLogic derives from Datalog and Prolog like languages that are used in the field of data manipulation and artificial intelligence. On the contrary of XML, it uses a uniform syntax for facts, rules and queries specification.
XML has an HTML-like syntax, while SimpleLogic an English-like syntax.
XML stores info on tags and attributes, instead SimpleLogic uses relations. The first map easily to an object-oriented structure, the latter permits writing of English-like sentences.
Document Type Definition in XML corresponds to type definition and relation declaration in SimpleLogic.
The major benefit of XML is its acceptance as standard and the born of standard document type definition for the most common file types. This permit an exchange of data between different applications. In order to follow the standard of the moment and increase interoperability with other applications an automatic conversion from SimpleLogic to XML and vice-versa should be implemented in the future.
RDF is a language based on XML that specifies informations (metadata) about resources (in particular WEB resources). Also SimpleLogic can be used to describe external resources, but Jude environment is focused on the creation of documents where all theirs content is described using SimpleLogic, not only metadata.
The base element of the RDF model is the triple : a resource (the subject) is linked to another resource (the object) through an arc labeled with a third resource (the predicate). For example the RDF triple (obj_1,''Massimo'',name) corresponds to SimpleLogic fact: obj_1 has_name ``Massimo''. RDF approach maps easily properties to object attributes. On the contrary SimpleLogic approach is more readable and deals also with relations having cardinality greater than two.
SimpleLogic uses the same language for facts, rules and queries while RDF permits only fact specification. In particular RDF has not a well specified logic semantics and it does not allow intensional rules specification.
As in the case of XML, RDF probably will produce many standard classification schemas for documents. These standards should be followed also from Jude.