Projects

Below is a list of projects related to TTM that have come to our attention.  See also Implementers' Reflections for further information from the authors of some of these projects.

Contents: Rel  relational.js EE/IBL  Andl  Sira_Prise  Muldis Rosetta   RAQUEL   Duro   Alf   D4   D  CsiDB    MighTyD    Web Relational Blocks   Dee  Erki Eessaar's Ph.D.  TclRAL   Ingres D     Re

Rel

An implementation of Tutorial D, pretty much "by the book", developed by Dave Voorhis. Rel is a continuous work-in-progress; for the current limitations, please see http://dbappbuilder.sourceforge.net/Rel.html#Limitations .  Hugh Darwen had no difficulty in installing Rel and getting it running on Windows XP Pro and Windows Vista (now Windows 10), in spite of having to install Java first. Rel was used by students at Warwick University, UK on Hugh Darwen's course on relational theory http://www.dcs.warwick.ac.uk/~hugh/ (discontinued in 2012) and on Dave Voorhis's "Multi-User Database Systems" course at the University of Derby, UK.


relational.js

relational.js is an experimental logic-programming package by Erik Olson based on the relational model that implements the definitional algebra A.This package conforms to a subset of the RM Prescriptions and RM Proscriptions defined in TTM for a relational language D. An approach is offered distinct from the proposals of Darwen and Date in TTM in that a Horn-clause theorem-proving system is provided for computing relations with definite cardinalities as results of queries of relations with indefinite cardinalities. 


EE/IBL

EE (Executable English) is a user-friendly language implemented for shared use by non-programmers in the IBL (Internet Business Logic) web site since 2005.  

EE provides 1st order predicate logic with recursion and negation.  It provides for the definition of relations/tables and all the operations required of the Relational Model published by E.F. Codd in 1970.  Data may be directly included in the tables, or alternatively IBL may access and update data through a networked SQL interface.  EE is free of the logical problems of SQL. 

EE/IBL provides for non-programmers to implement an application complete with data storage and access.  The user sees a menu of questions written using the most appropriate vocabulary for the application within a highly flexible syntax unconstrained by reserved words.  The user can type in a free English question, which the system will match to known sentences.  Or, the user chooses which question to ask, specifying particular parameters if appropriate.  IBL searches the rules and tables to determine whether 0, 1 or many answers can be found, showing the table of results to the user.  The user can ask for an explanation of any answer (or failure to find one).  IBL then shows  a hypertexted English explanation leading to that conclusion.  As the rules are all written by the application implementer in the  non-programmer-friendly syntax, this explanation is expressed entirely in terms designed to be easy for the user to understand.

Note that though the language is known as Executable English, words of any other language supported by a generally available alphabet can be used.  The only restriction on this is a very limited number of words such as “not” or “url” and then only in some specific syntactic constructs.  These words therefore are not reserved in that they can be used elsewhere in ordinary EE sentences without restriction.

Constraints on data can be expressed using the full power of EE’s 1st order predicate logic.  A constraint may be associated with addition of a row to a particular table or invoked as appropriate by the user.  A constraint may include recursion, negation, and reference to the rows of any available tables.  To avoid logical inconsistency (e.g. Russell’s Paradox) negation is excluded within a recursive loop.  As presently implemented in IBL, there is no provision for these constraints to be reserved to a central authority, as opposed to being open to change by the implementer of the application.  Providing for limiting authority to define or change DDL as in a typical DBMS, is work in progress.

The design and an earlier implementation of EE predated TTM, therefore it was not developed with TTM in mind.  Consequently EE may not observe the RM Prescriptions to the letter.  In particular, EE does not “name” things in the conventional sense, and this includes types and attributes.  EE does however support defining both the standard types of TTM and user-defined types.  It also avoids the relevant problems of SQL that TTM addresses.

See the web site www.reengineeringllc.com/index.html for further information and to use EE/IBL on the demo ID.  The demo ID provides many example apps, and you can use it to write and run your own examples.  Questions may be directed to the author of EE/IBL, Adrian Walker, via that web site or to Martin King through the TTM discussion group.

Andl

Andl (A New Database Language) does what SQL does, but it is not SQL. Andl has been developed as a fully featured database programming language following the principles set out by Date and Darwen in The Third Manifesto. It includes a full implementation of the Relational Model published by E.F. Codd in 1970, an advanced extensible type system, database updates and other SQL-like capabilities in a novel and highly expressive syntax.

The intended role of Andl is to be the implementation language for the data model of an application. It is already possible to code the business model of an application in SQL dialects such as SQL/PSM (SQL Standard and IBM DB2), PL/SQL (Oracle) or Transact-SQL (Microsoft) but SQL has its share of problems (see here) and few people make this choice. Andl aims to provide a language free of these problems that works on all these platforms.

The intended role for Andl is as follows. An application developer takes a set of business requirements that comprise a data model, a set of operations on that model, and a set of requirements for users to interact with the model. The data model is implemented in the form of tables in a relational database management system, and the user interface and related business requirements are implemented using some chosen front end technology: web, desktop or mobile as needed. The operations on the data model are implemented in Andl, which also provides the means by which the user interface queries and updates the data in the model.

The effect is that the ‘object relational mismatch’ disappears, and there is no longer any need for an ‘object relational mapper’. No objects are needed between the data model and the user interface, just simple data values as individual items, rows or tables.

There is still a role for a general purpose programming language like C# or Java, acting as glue to join various parts together and also in implementing various parts of the type system that Andl depends on. There is still a role for a front end technology based on languages such as HTML and JavaScript since Andl does not offer a user interface. But for the heart of the business application, for operations on the data and for implementing the rules, there is Andl.

See the web site http://www.andl.org for further information and downloads, why we need it, problems with SQL and a TTM paraphrase to read further, or contact the author David Bennett as david at the same domain.


SIRA_PRISE

SIRA_PRISE is an effort started by Erwin Smout to build a usable TRDBMS.

The following characteristics distinguish SIRA_PRISE from most of the other TTM projects mentioned on this page :

• The engine is stand-alone and needs no other external software than a Java VM to run in.

• It deliberately does not try to create a full-blown D as its language. This makes SIRA_PRISE (and its DML language) behave more like a "traditional" data sublanguage than like a D.

The following features are considered the most important by the author (and are also what makes SIRA_PRISE noteworthy in his opinion):

• Efficient enforcement of data integrity constraints of arbitrary complexity.

• Support for multiple assignment, albeit not exactly and entirely the TTM kind.

• Support for Temporal data through support for interval types.

• Support for plug-in types and operators (User-Defined types and operators using a user-provided Java implementation).

• Clean separation between the logical design and the physical design of a database.

The following features are on the author's wish-list but not yet implemented :

• Support for Specialization by constraint

• Support for distributed databases

• Support for TTM-style UDTs (i.e. without requiring a user-provided java implementation)

Muldis Rosetta

Currently in the pre-alpha implementation phase, Muldis Rosetta is a rigorously defined attempt to completely and uncompromisingly implement all of TTM and its related articles, and to provide an effective solution for cross-DBMS portability; its core is an API definition, that interchangeable back-ends implement. It is being written in correspondingly pure Perl 6 and Perl 5 versions, and for the former it might become the very first native database solution. Muldis Rosetta is implemented as a virtual machine, and has its own new "D" language named "Muldis D". Muldis D is syntactically simpler than the average general purpose language and is partly intended for use as an intermediate language over which other D languages or API wrappers can be implemented. It takes the Perl 6 language as one of its main influences. Muldis Rosetta is a free/liberated and open source project, which is intended to become industrial strength, and be commercially supported.

Raquel Database System Open Source Project

A prototype of a DBMS that executes statements in the RAQUEL notation has been published on the Internet. RAQUEL is designed to qualify as a valid D and express the relational model defined in The Third Manifesto. RAQUEL has been developed at Northumbria University to reflect the concepts of the relational model in a way that maximises their functionality and minimises their complexity. Information about the Raquel Database System is available from http://computing.unn.ac.uk/raquelDBsystem/.

As a DBMS needs a ‘driver application’ to supply it with statements to execute and to receive the consequences of their execution, a prototype GUI Frontend has also been published that is designed to help create statements in RAQUEL and receive error messages and query results.

The prototype is the start of an Open Source project to evolve the DBMS into a commercial product. The prototype software runs on Linux. The source code of both the DBMS and the GUI can be downloaded from SourceForge at http://sourceforge.net/projects/raqueldbsystem/files/ .

The DBMS prototype implements Project and Restrict operators, and a range of related Natural Join and Generalised Join operators; plus assignments for Retrieving query data, Inserting and Deleting relvalues, and creating Real (or Base) relvars; the scalar types implemented are the Truth, Number and Text types. As a prototype, the DBMS is still too limited to be of real practical use. Its biggest limitation is that the ability to create/remove relvars can only be done by manipulating the storage of the relevant Meta DB relvars. Implementing create/remove assignments is the next priority.

DuroDBMS (formerly known as Duro)


A project by René Hartmann, whose original aim was to create a relational database library based on TTM , written in C. DuroDBMS  consists mainly of a database library (implemented on top of Berkeley DB) and a Tutorial D interpreter. It is aimed at TTM-compliance, featuring nested transactions, a relational algebra, user-defined types and declarative integrity.

Release 0.26 of DuroDBMS (available June, 2015) includes a new subproject, Dreisam.  This is an MVC web application framework based on DuroDBMS. Although still in early stage, with Dreisam it is already possible to write web applications using Tutorial D. The project home page is http://sourceforge.net/projects/dreisam/.

Release 0.20 of DuroDBMS (available January, 2014) supports system keys and transition constraints.

Release 0.17 (available March, 2013) added several improvements over previous versions. For example, it is now possible to implement user-defined types with more than one possrep using the Tutorial D interpreter. The interpreter tutorial contains an implementation of the POINT type from TTM as an example.

Alf

https://github.com/blambeau/alf
(source code)

http://rubydoc.info/github/blambeau/alf/master/frames
(documentation)

Alf is a pragmatic tool that, among other things, provides the relational algebra in a shell. It provides a (straightforward but useful) implementation of almost all Tutorial D relational algebra operators. Each of them comes as single shell command taking relation operands from SQL tables, CSV files or other Alf commands.

Alf also provides a functional domain specific language (DSL) for evaluating relational queries directly in Ruby, the programming language in which it is implemented.

Under the covers, Alf aims at bringing together the agile, pragmatic and test-driven oriented programming of the Ruby world and the sound and powerful approach to relational theory offered by TTM and related research. In that respect, Alf also aims at becoming an educational and research tool.


D4

The first known attempt at a commercial implementation of TTM. Syntax similar to Tutorial D. Alas, Alphora eventually found it necessary to add "support" for SQL-style nulls, finding a conflict here between TTM and their primary design goal of automating application development. Nevertheless, D4 conforms in many other respects and its authors say that TTM "ideas ... have helped us achieve a level of automation that we never dreamed possible when we first set out to build the product." An early version included type inheritance with specialization by constraint, but this eventually had to be withdrawn.


D ("D flat")

Final year project by UMIST student Peter Nicol.  Nice name!

Opus

Link no longer available (01 June 2007) Solo effort by David Cauz, in the syntactic style of C, claiming conformance to much of TTM. Work in progress.


CsiDB

email: Dan Muller

CsiDb is a C++ library developed internally by an international corporation, and used in a general bookkeeping and accounting application. The application is complex and database-intensive, accommodating a wide array of bookkeeping practices. CsiDb is an ongoing attempt to simplify interaction between the application and the database by providing a native C++ interface to a back-end DBMS. The interface allows users to easily build relational query expressions which are eventually translated into SQL. The interface is modelled closely on the semantics of Tutorial D and the other concepts in The Third Manifesto. The library has been under sporadic development since 1999, by a single developer. As of mid-2004, it provides a robust and fairly complete query capability, but only rudimentary functionality for database updates. It has been successfully used to simplify and speed up significant portions of the application, replacing or supplementing an in-house object/database mapping layer.

MighTyD

A final year project by undergraduate students at the University of Warwick, UK, 2005-6. MighTyD (get it?) is a prototype implementation of Tutorial D with some of the extensions proposed for temporal database support proposed by Date, Darwen, and Lorentzos in Temporal Data and The Relational Model.

Supports scalar operators involving intervals and relational operators PACK, UNPACK, and most of the U_ operators. Intended for teaching purposes and for further extension by anybody who might be so inclined.

The project was highly acclaimed by the assessors at Warwick University. The team: Rachel Bowers, Adrian Hudnott, Sergey Petrov, Tom Pick, Issam Souilah. Hugh Darwen was their appointed "customer".

Web Relational Blocks

Relational Blocks is a visual language for constructing enterprise applications (an enterprise application is one whose GUI drives transactional access to database tables with non-trivial business logic). WebRB is an implementation of the Relational Blocks language as a software-service that runs in a standard browser. Although WebRB is not a DBMS nor does it directly expose a database language, it is influenced by TTM in two ways. First, relations are the only data-type which flows between components of the system (relvars, widgets, and algebra blocks), although of course strings, integers, doubles, etc. are supported as attribute types. Second, WebRB uses relational algebra (specifically the relational algebra, named A, that is given in Databases, Types and the Relational Model, Third Edition, Appendix A) rather than SQL. These characteristics enable the visual language to suffice without developers adding any imperative code.

Dee

An implementation of a D as an extension to Python. It is built on the relational algebra operators and aims to meet all of The Third Manifesto's RM and OO requirements. From the developers of ThinkSQL.

Relational and Object-Relational Database Management Systems as Platforms for Managing Software Engineering Artifacts

A Ph.D. thesis by Erki Eessaar, Tallinn University of Technology. "The main areas of this study are relational and object-relational data models and their suitability in the systems that help to manage software engineering artifacts." Much of the thesis is devoted to a comparative study of SQL's versus The Third Manifesto's "object-relational" data models.

TclRAL

TclRAL is an implementation of the relational algebra concepts in TTM as an extension of the Tcl language. It does not attempt to mimic the syntax of Tutorial D, but does implement a complete set of relational operations in a manner that is adapted to the Tcl programming environment.


Ingres Project D

Ingres home page
E-mail: adrianh who is at
http://www.dcs.warwick.ac.uk/

Unfortunately work on ths project was abandoned in 2011.  Its original aims are given below for interest's sake only.

Ingres Project D is a project to add support for the Tutorial D language to Ingres Database server. Ingres Database server already has two data definition and manipulation languages, SQL and QUEL, where the latter originates from the tuple relational calculus. Project D will enable database development using a fully compliant D development environment consisting of Ingres Database server and a superset of Tutorial D, with supporting tools. It and will succeed where QUEL succumbed to SQL, and in doing so rejuvenate the original Ingres vision of a high performance relational DBMS and at the same time augment it to include the more recent work of Date and Darwen. It will deliver an industrial strength DBMS that will eventually implement everything in The Third Manifesto and Temporal Data and the Relational Model.

Ingres D is being constructed as a collaboration between Ingres Corporation, Adrian Hudnott, who is a PhD student at the University of Warwick in the UK, and Kai-Uwe Sattler's research group at Technische Universität Ilmenau in Germany. Original research is being carried out to support development of the following features for Project D.

• Enforcement of complex data integrity constraints with only a very low impact on performance for most constraints

• Materialized views/virtual relvars

• Semantic optimization of relational expressions

• Efficient multiple simultaneous assignment

• Temporal database optimization

• Specialization by Constraint

• Unrestricted updates to virtual relvars (where possible)

• Self-organizing physical storage structures ("autonomous DBMS")

re: Relational Etudes

re is an implementation of the Relational Model by Eugim B. Migue. Specifically, it tries to implement the ideas presented in Date and Darwen's book, titled Databases, Types and the Relational Model (The Third Manifesto) and is based quite closely on Tutorial D.

re is implemented using PHP; thus, re can also be called as a "PHP API", or a "PHP Framework"/"PHP Library". But whatever fashionable name re might be generalised to, it must be understood that re's basis is a rigorous scientific theory. PHP was chosen as the implementing language for a variety of reasons. First, PHP is popular enough. For this reason, this project hopes that a useful and foundational theory can be used (even if not to its full potential) and appreciated by a wider audience. Another is that PHP has certain features which allow for a more "straightforward approach" on some implementation-related considerations.