The data model of ConceptBase is O-Telos, a language derived from Telos, which itself was developed by John Mylopoulos, Alex Borgida, Sol Greenspan, Manolis Koubarakis, and others in the 2nd half of the 1980's.
This text is aimed at potential users of ConceptBase and intends to answer the following questions:
The object store (Rainer Gallersdörfer, Thomas List) of ConceptBase is an abstract data type that represents so-called P-tuples, the one and only base relation of ConceptBase. Each P-tuple object stores redundantly links to objects that are connected by any relationship to it. As a consequence, an object frame with all its attributes and all objects that refer to this object can be fetched in constant time. The object store follows a main memory approach, i.e. all objects are cached into the main memory of the computer.
The query and rule processor (Martin Staudt, Rene Soiron) provides the functionality of DATALOG with negation, i.e. recursive deductive rules with stratification on negated predicates. Evaluation is done using the Magic Cache method (Manfred Jeusfeld). Queries are treated as classes (query classes), whose instances are the answer to the query. Semantic query optimization and join-ordering optimization are used to further improve the performance of query evaluation. The answer presentation can be configured by so-called answer formats (Hua Wang, Hans Nissen).
The integrity checker (Manfred Jeusfeld, Eva Krüger) maintains the consistency of the database by evaluating triggers generated from declarative logical integrity formulas. The method originates from the simplification idea by Nicolas and Blaustein. The trigger code base is maintained whenever a deductive rule or integrity constraint is changed. The triggers are activated by insert and delete events in the object store.
Finally, the meta modeling approach (Matthias Jarke, Thomas Rose, Manfred Jeusfeld, Hans Nissen and others) is used to adapt ConceptBase to various application domains. Meta classes as well as meta meta classes can be defined to provide generic concepts of the application domain. The syntax and the semantics of the generic concepts is defined by meta-level rules and integrity constraints (Rene Soiron).
The connectivity (Martin Staudt, Christoph Quix, Christoph Radig, Manfred Jeusfeld) of ConceptBase relies on Internet protocols. The server accepts TELL and ASK messages. Clients connect via a library or simply via the HTTP protocol. Clients also can be notified by the server via a view maintenance paradigm. The user interface is used to be based on Tcl/Tk (Michael Gebhardt, Ralf Stössel) with the notable exception of the graph browser (Stefan Eherer, Markus Baumeister, Michael Gebhardt). The current standard user interface is written in Java (Michael Gebhardt, Rainer Langohr, Achim Schlosser, Rainer Hermanns, and others).
The view component (Christoph Quix) extends the capabilities of query classes by nesting and additional attribute categories. Views can automatically be maintained. Functional programming (Manfred Jeusfeld) is an extension for the definition of functions that compute numeric or non-numeric values by analyzing the database.
ConceptBase also provides object base modules (Hans Nissen, Lutz Bauer), a facility to organize portions of the database that can only refer to objects within a module (plus its supermodules), and to objects imported from other modules. Furthermore, it includes active rules (Hans Nissen, Farshad Lashgari; extended later by Manfred Jeusfeld) as a facility to trigger internal or external processes whenever a certain update event happens.
Until version 3.0 ConceptBase was a full temporal database system (Thomas Wenig) using Allen's interval algebra to reason on validty of statements. Any object in the database had a validity time (a symbolic name for the time it should be regarded as valid in the world), and a belief time (denoting the time when the object is visible to the query processor). Since ConceptBase has a sophisticated deductive component, we discovered too many undesired interactions between the temporal algebra and deductive rules, esp. those defining the semantics of inheritance. Thus, we dropped the validity time but kept the belief time.
Another historic component worth mentioning is the view subsumption tester (Kai von Thadden). It computes containment relations between view/query definitions. Due to inherent undecidability, the method is incomplete. However it is complete for decidable subclasses that have been investigated in description logics (KL-One-like languages) and conjunctive queries.
Object-oriented (or post-relational) database systems are strong in integrating operations ("methods") into the database. ConceptBase has no general methods except integrity constraints, deductive rules, and active rules. It does have a programming interface but this cannot be compared to what one gets from post-relational database systems.
ConceptBase currently has only primitive provisions for multi-user support, and recovery. Thus, if you need a system which is strong in these points then you probably need a commercial database system.
ConceptBase has a strongly developed logical component for expressing queries, rules, and constraints. This component is integrated into the object-oriented data model derived from Telos. If your application is not requiring abstraction principles such as classification, specialization and attribution, you might be better off with a state-of-the-art deductive system such as XSB.
This feature is accompanied by a query facility which has the expressive power of deductive databases and which is seamlessly integrated into the frame language [JEUS92].
Consequently, ConceptBase is strong in applications where concepts (classes, objects, situations, entities etc.) have to be modelled and manipulated. The user interface supports this by textual and graphical browsers and editors. The graphical editor can be adapted to the application by assigning graphical representations to the concepts (e.g., each instance of class RelationShip is displayed as a romboid).
The object model, O-Telos, already contains the well-known knowledge representation paradigms for specialization, aggregation, and classification. The designer can augment them by user-defined deductive rules (e.g., closing certain attributes transitively) and integrity constraints (e.g., forbidding certain attributes to be cyclic). The ability of ConceptBase to accept deductive rules and integrity constraints at any (meta) class level is unique. It basically allows you to represent heterogeneous (data) modeling languages within the same sound formalism. We call this the meta modeling capability of ConceptBase.
In the Canadian network of Excellence, ConceptBase was chosen to implement a more sophisticated software repository [RJM92] which supports versioning and configuration of software items (specifications, designs, implemenations, documents etc.).
Another area of application is representation, maintenance, and discussion of process knowledge [RL93]. There, ConceptBase serves as a tool for capturing and reasoning with such knowledge. The goal of the system is to help software engineers in rapidly constructing prototypes of proposed software systems.
ConceptBase is also used for teaching, e.g. at the Aalborg University in Denmark, University of Lausanne, University of Hamburg, and University of Muenster. Furthermore, it is curently used in several ESPRIT and national projects for applications like semantic query optimization (project COMPULOG), industrial quality management (project WIBQUS), retrieval of reusable software components (project KORSO), hypermedia authoring systems (project MULTIWORKS), and requirements engineering and process modelling (project NATURE).
A couple of Web applications with ConceptBase came up in the late 1990's. The HTML form language provides entry a collection of labelled fields which nicely corresponds to the frame representation of objects in ConceptBase.
[JARK93] M. Jarke (ed.,1993). Database application engineering with DAIDA. Springer-Verlag, 1993.
[RJM92] T. Rose, M. Jarke, J. Mylopoulos (1992). Organizing software repositories - modeling requirements and implementation experiences. Proc. 16th Intl. Computer Software & Applications Conf., Chicago, Ill., Sept. 23-25, 1992.
[RL93] B. Ramesh, Luqi (1993). Process knowledge based rapid prototyping for requirements engineering. Proc. IEEE Intl. Symp. Requirements Engineering (RE'93), San Diego, Ca., Jan. 4-6, 1993.
[NIX94] B.A. Nixon (1994): Representing and using performance requirements during the development of information systems. Proc. 4th Intl. Conf. EDBT'94, LNCS, 779, Springer-Verlag, 1994.
[GHS94] S. Gastinger, R. Hennicker, R. Stabl (1994): Reusing software components with polymorphic signatures. Technical report (KORSO project), LMU Muenchen, Institut Informatik, D-80802 Muenchen, Germany, 1994.
More references are
here.
© ConceptBase Team 2008. Please do not mirror this document or its parts without prior permission by us. Thank you! Last update: $Author: jeusfeld $, $Date: 2008/06/03 18:16:56 $