KnowOS
Knowledge Operating System (KnowOS) is a project for a dynamic system with persistent objects.It is written on Common Lisp by Mike Travers, JP Massar, and Jeff Shrager as an underlying framework tool for BioLingua.
See ILC 2005 Paper.
Good intentions, but they repeat the usual bullshits about RDBMSs that come from OO-DBMS proponents; citing from ILC 2005 Paper:
RDBMSs can cope with hierarchies and networks (graphs) better, in a more dynamic way, because they are not limited by a static representation of these structures as a web of pointers§.
The main difference is this: a RDBMS manages graphs in a declarative way, with relational algebra or calculi which are Collection-Oriented (aka data parallel or set-oriented); hierarchical and network DBMSs manage it procedurally§§ iterating node by node, instead. Also the integrity of such graphs are mantained declaratively by RDBMSs by integrity constraints (again, to express these constraints you have all the power of relational algebra/calculi at your disposal).
Now, the evidence:
-- MaD70
An Oracle instance is a virtual machine that allows users to interact with tables and relations as if these were persistent basic elements, and provides many of the above-described services to application programs that operate on tables and relations.
Tables are a 2D representation of relations, so speaking about tables and relations is nonsense. Probably, they are speaking about realations (tables) and relationships (one-to-one [1:1], many-to-one [M:1] and many-to-many [M:M]), represented in the database by foreign key-primary key referential integrity constraints.
[..] and so that it becomes part of the persistent storage space – the files or tables. We feel that this is needlessly myopic; If one wants to work with complex, structured knowledge, one should not have to create it from flat representations [..]
Again, tables are a 2D representation of relations; a relation is a variable which can assume as value sets of points in a n-dimensional discrete space (where n is the number of relation attributes), aka sets of tuples. What does it mean for a n-dimensional discrete space to be flat??
Whereas classical operating systems provide these services for simple data objects (files or tables), a KnowOS provides them for networks of complex objects.
.. and ..
Threading is the way that pointers are maintained between complex objects that have their own first-class status;
They miss completely the fact that the relational data model (rdm) was invented to overcame the deficiencies of hierarchical and network DBMSs (re-proposed in "modern" form as XML-DBMSs and OO-DBMSs).
Citing again from ILC 2005 Paper:
If one wants to work with complex, structured knowledge, one should not have to create it from flat representations [..]. Instead, complex objects should constitute the basic persistent storage entities that are the domain of the operating system.
rdm has no problems in representing, managing and assuring the integrity of such complex structures; on the contrary, it was invented exactly to overcame the deficiencies of hierarchical and network DBMSs (although SQL DBMSs, violating rdm theory, cause some problems in supporting graphs, above all admitting duplicates).
relations = files and tuples = records ARE NONSENSE.
Here program graphs (for program analysis) are represented as relations at the logical level and as (RO)BDDs at the physical (implementation) level:
In developing our approach, it soon became apparent that a simple strategy of providing a Java wrapper to interface with a BDD library was not a good solution, for many reasons. First, we found that the interface provided by the existing BDD libraries is very low level, and as we attempted to express several complex interrelated analyses, understanding and maintaining our code became difficult. Moreover, programming at such a low level was error prone, and errors in our code led to either the BDD library aborting, or worse, to incorrect results. Shortcomings of procedural programming. The implicit nature of the BDD representation made these errors difficult to track down. Furthermore, we found that it is quite difficult to match the memory management in Java with the reference-counter-based schemes employed in the BDD packages. Finally, we found that tuning a BDD-based algorithm requires profiling information about the size and shape of the underlying BDDs at each program step. We had previously developed some ad-hoc methods for visualizing this information, but a more automated approach was needed.
Our solution, and the topic of this paper, was the development of: (1) Jedd, a language extension to Java, which provides a high-level way of programming BDD-based algorithms based on relations and operations on relations; Advantages of declarative programming. (2) an associated translator which automatically translates Jedd to Java code that efficiently interacts with back-end solvers; and (3) run-time support for memory management, debugging and profiling of BDD operations.
.. and this example paper Cloning Based Context Sensitive Pointer Alias Analysis Using Binary Decision Diagrams (.PDF) by John Whaley: this paper shows that pointer analysis, and many other queries and algorithms, can be described succinctly and declaratively using Datalog, a logic programming language. Again, advantages of declarative programming.
Abstract. In this paper we present a storage method for sets of first order logic terms in a relational database using function symbols based indexing method of Discrimination trees. This is an alternative method to a published one, based on attribute indexing. This storage enables effective implementation of several retrieval operations: unification, generalization, instantation and variation of a given query term in the language of first order predicate calculus. In our solution each term has unique occurrence in the database. This is very useful when we need to store a large set of terms that have identical many subterms.