[homePage] - [docum] - [source] - [testing] - [experience]

Background and practical experience

(1) The background

Jiri Soukup, the prime author of this Source Forge project, worked for many years on CAD software for silicon chips (VLSI). CAD programs are notorious for complex internal data structures, and Jiri learned hard way how important it is to manage them safely. Already in 1988, he began to use what we call today the model driven architecture. His effort lead to an innovative library of persistent data structures called Data Object Library (DOL).

Note that, back in those days, C++ was only starting and had neither multiple inheritance nor templates, Java was not invented yet, and it was three years before the Booch's book was published.

DOL is interesting because since as early as 1989 it used two concepts which are popular today: The model driven architecture, and representing relations among classes in terms of associations -- as in UML diagrams. When you use DOL, your describe all relations among classes in a small block of code which is like a database schema. It automatically and tranparently inserts all the data structures into your source. DOL has no graphical display but by looking at the schema you can instantly see the interaction among classes.

Note the difference between associations and containers. Container are usually used as members of some classes, while associations is not a part of any class. Containers are inside a class, associations control the classes from the outside. You can see this on the typical example of hierarchical relation between the Department and its Employees: 

// ------ style commonly used today --------
    class Employee {
        Department *myDept;
        ...
    };
    class Department {
        Collection employees; // container is a class member
        ...
    };

    // example of use
    Employee *e; Department *d;
    d->employees.add(e);
    e->myDept=d; // two statements are needed
    
    // ------ using an association --------
    OneToMany employees; 
    class Employee { ... };
    class Department { ... }; // required members automat. inserted

    // example of use
    Employee *e; Department *d;
    employees.add(d,e); // both operations in one statement

IMPORTANT: Associations are not replacing or eliminating existing containers, they only expand them into another dimension. For data structures that can be implemented as a single container, the corresponding association can be just a wrapper which provides a new interface.

(2) The practical experience

Since this Source Forge project is based on the same idea as DOL is, the practical experience with DOL tells us what we can expect from this project. However, when making this projection, we must consider the following differences: (1) In-code modelling generates UML diagrams, while DOL does not. (2) DOL provides persistent associations, while associations in this project are not persistent.

DOL was purchased by over 500 companies and was successfully used in a variety of applications on four continents. There was not a single user who would report that his/her productivity and code quality did not improve.

Examples of applications:

  • State of art CAD system for large silicon chips.
  • CASE tool which supported UML before Rational Rose did.
  • Compiler for a special simulation hardware.
  • An interactive graphics program for public school education.
  • On-line processing of the stock exchange data received via satellite link from all around the world.
  • Web browser.
  • Core of a telephone switch.
  • Multi-layer network management for a leading telecommunication company.
The general feedback was that the man/hours for both design and maintaince of the software were cut to less than half. For projects that needed persistent data the benefits were even higher, but those results do not apply to in-code modelling which is not persistent.

Reported reasons for the productivity increase:

  • The software can rapidly evolve even when changes of the data organization are required. If you remove, add, or change any data structures, the compiler tells you where to modify the code that uses it.
  • The integrity of data is guaranteed and pointer errors are practically eliminated -- in a more thorough way than what Java does today.
  • The block of code describing the associations (the schema) serves the same purpose as the UML diagram - it gives you the view of the relations among classes.