IDL is a schema definition language. Schema modifications are defined in IDL, requiring ad-hoc offline transformations of the database, in general. A simple class of transformations can be handled by IDL->ASCII and ASCII->IDL translators (i.e., integer format changes, list->array, attribute addition).
[conversation with Ellen Borison of Persistent Data Systems]
ADDITIONAL REFERENCES: John R. Nestor. "IDL: The Language and Its Implementation". Prentice Hall. Englewood Cliffs, NJ., 1989.
> Kala Kala Technical Brief
Kala(tm) is a Persistent Data Server managing distributed, shared, arbitrarily complex and evolving persistent data. Kala is highly efficient and secure. Kala manages the visibility of persistent data elements to its clients, thus supporting any types of transactions, versions, access control, security, configurations. Kala does not restrict you to any particular model. Kala provides the mechanism, but imposes no policy. Usable as either a link library communicating to a server or as a standalone, Kala is compact and simple.
Kala is used for applications such as: kernel of DBMS products, substrate for extended file systems, implementation of language persistence, data manager for groupware applications as well as applications which deal with large, complex, and changing volumes of data (text databases, financial distributed transaction systems). Our current customers use Kala in applications ranging from CASE repositories to CAD systems, from document management for financial institutions to OODBMS platforms, from real-time applications to database research. Kala is a component of broad reuse.
The simplest persistent data storage available to you is the file system on your disk drive. File systems have some attractive characteristics; their performance is good, they can hold any data, they're easy to use, and, of course, the price is right. Conversely, files are unreliable. They provide no mechanism for in maintaining data consistency and only primitive data sharing facilities. Few file systems offer version control and all require that you transform data between "internal" and "external" forms all the time.
Unlike a file system, a true database management system provides mechanisms for sharing data and for ensuring the integrity of the data. It supports transactions and version control, although the specifics of these functions may not be exactly what your application needs. Finally, a database system is scalable, and much more robust than a file when your hardware or software fails.
The downside to a database system is that, compared to a file system, it is slower by an order of magnitude or more. Also, a database system generally confines you to dealing only with the kind of data that it can handle. In addition, a database is usually very complicated, difficult to learn and use, and expensive, both in terms of your cost of operation and in the amount of system resources they consume.
Whether you choose a file system or a database manager, then, you have to sacrifice either economy or performance. Is there a happy medium? Something with the speed and flexibility of files, the reliability, shareability and robustness of databases, and at a cost that won't break your wallet or the available hardware? Sure there is! Kala is a first in a new breed of products, persistent data servers, aimed squarely at the yawning gap between DBMSs and file systems.
Kala is *not* a DBMS. Instead, you use Kala whenever the few canned combinations of DBMS features do not meet the needs of your application. A DBMS product constrains you to accept *its* choice of an end-user graphical interface, a query language binding, a specific high level data or object model, a particular transaction model, a single versioning scheme, etc. This either compromises your application's functionality, or forces your to spend substantial development effort and money to bridge the impedance mismatch to the application. Instead, Kala allows *you* to develop no more and no less than the functionality you need. You build your domain specific functionality our of a small set of primitives with very little code. Your gains in productivity, efficiency, and flexibility are substantial.
To sustain this level of flexibility and reuse, Kala manages any data that you can represent in machine memory out of bits and references. Examples include records, dynamically linked graphs and lists, executable code, and object encapsulations.
Kala can handle data as small as one bit, and as large as the virtual memory and more, while being totally unaware of the data's semantics. Its stores and retrieves data efficiently, and compactly over a distributed and dynamically reconfigurable set of Stores. Upon retrieval, Kala dynamically relocates embedded references to retain the original topological structure of the data, thus preserving referential integrity. Kala also supports active data, physical store management, and automatic archiving.
Kala repackages the fundamentals and universals of data management in one reusable data server, separating them from the application domain specific models and policies. Kala defines a low level interoperabi- lity point for the data storage domain, just as X does for the display domain and Postscript does for the printing domain.
Kala has matured through four successive versions to its present industrial strength implementation and stable API. Kala is lean, compact, and portable. Kala is a high performance, low overhead system. We call it a Reduced Instruction Set Engine (RISE). Unlike large, complex, and typically bulky DBMS products, Kala is small, simple, and suitable for managing anywhere from a single diskette to terabytes of distributed data.
* For those who need functionality traditionally associated with databases, but cannot tolerate the overhead and complications DBMS products introduce, Kala offers a flexible, compact, performant, elegant, and simple alternative.
* For those whose application domain requires data models where the mapping to those offered by today's DBMS products is cumbersome, introduces development and execution overhead, and is not portable across multiple linguistic and environmental platforms, Kala offers a data model independent interface against any data model expressible in terms of bits and pointers can be easily built.
* For those who need DBMS functionality or qualities that no single DBMS product now has, Kala offers the opportunity to build that functionality now with little effort out of a simple set of primitives, and not wait for one vendor or another to deliver it later.
* For those who have determined that the only viable option for their application's persistent data needs is the file system, and have resined to the idea that they will have to build everything else they need from scratch, Kala offers an off-the-shelf implementation without loss of any of files' advantages.
* For those who need performance, size, portability, storage compactness, and industrial strength that no single DBMS product can now satisfy, Kala offers all of the above now.
* For those who realize that while object-level interoperability is a strong desideratum, the likelihood of a single, universal such model in the foreseeable future is quite low, Kala offers a solid, long term alternative. Data store interoperability that brings us beyond file systems is the best practical bet. Kala is the basis for data store interoperability now.
* Finally, for all of you who are concerned about the economics of software, and take the view that there are many elements that could contribute negatively to the soundness of your business, such as operational costs, software maintenance costs, software licensing costs, software development and learning costs, etc., you will find Kala an economically sound, sensible, and practical product.
- The execution architecture is that of multiple (communicating) servers and multiple clients. Kala can also be configured in a standalone (single process) mode. Kala's IPC is built for maximum performance, portable to any given datagram protocol.
- The managed data elements are made out of uninterpreted bits and references. Data elements (named `monads') are universally uniquely identified. Bits are stored with no overhead. References, represented in memory as native machine pointers, are stored very compactly, introducing an average of 2.5 bytes overhead.
- Kala is a fully recoverable system, short of media damage. Recovery from hardware failures can be supported by the layer beneath Kala.
- The Kala primitives support arbitrary transaction models, including classic short transactions, long (persistent) transactions, nested transactions, shared transactions, pessimistic and optimistic policies, etc. Concurrency control is achieved through two locking mechanisms (short-term and long-term (persistent, shared) locking), with full support for atomicity of operations and two-phase commit.
- The Kala primitives support arbitrary versioning models, allowing versions to co-exist in split/rejoined networks, various version organization strategies (single-thread, tree, DAG, etc.). Kala primitives provide mechanisms for arbitrary access and update triggers, such as notifications, security checks upon access/update, etc. __ with no limitations on what the trigger code does. Kala provides protection measures against virus and other intruding executions.
- The Kala primitives support a wide range of access control, security and protection models, including revocable access rights, access control without the overhead of ACL management, arbitrary access validation routines, etc. Kala does not introduce any more security holes than the operating environment already has.
- Kala has primitives for physical store allocation and de-allocation management, for a wide spectrum of store administrative tasks, as well as licensing administration. The latter includes application- sensitive time-limited client-connect-based licensing, as well as metered (connect/load/store) usage. Kala can be set up to do automatic archiving and backup of its physical store.
- Kala provides a wide spectrum of licensing schemes, usable by platforms and applications built upon Kala to their customer base. Kala provides renewable licenses, perpetual licenses, full protection against duplication without hardware (hostid) support, metered (pay-by-use) usage, etc.
- And more ... not fitting on this page-long Technical Brief.
o Kala is available now on Sun platforms (SunOS / 68K & SPARC), as well as on 80x86/MS-DOS (both Microsoft and Borland compilers & runtimes supported) platforms. If you are interested in a port to your favorite platform, call us to discuss our Development and Porting Partnership Programme.
o Kala's interface is ANSI C, also callable from C++. If you are interested in an interface or a binding to your favorite programming language, please call us to discuss out Development Partnership Programme.
o For pricing and other information, please contact us by phone, fax or via e-mail at Info@Kala.com
_ _ ____ _ ____ tm ____________________________________ \\ / | \ \ | \ \\\\ \\ /__ \ __ \ \ \ __ \ \\\\ \\ \ \ \ \ \ \ \\\\ \\ \ \ \ \ \ \ \\\\ No more than you need !!! \\' \' \' \' '____' \' \' \\\\ No less than you want !!! ........................................................................ Penobscot Development Corporation email: Info@Kala.com One Kendall Square Building 200 Suite 2200 Cambridge MA 02139-1564 USA voice +1-617-267-KALA fax +1-617-859-9597 tech support +1-201-539-7739 ...............(5252) fax +1-617-577-1209.............................
+---------------------------------------------------------------+ | Copyright (c) 1992-93, Penobscot Development Corporation. | | Kala is a Trademark of Penobscot Development Corporation. | +---------------------------------------------------------------+
On Schema Evolution (from original survey):
Kala manages an untyped persistent store, implementing the semantics of robust, distributed, secure, changing, and shareable persistent data. Layers built upon the Kala platform can implement the semantics of objects with the same properties.
As it operates below the schema layer, Kala does not address schema evolution directly. However, It supports the building of schema'ed layers above it and below the application, and those layers can provide for schema evolution conveniently using Kala primitives. This parts-box approach requires extra work on the part of the developer compared to out-of-the-box solutions, but provides power and flexibility sufficient for relatively low cost solutions in difficult environments (e.g. graph-structured data, dynamic classing) where no out-of-the-box solution is available.
Contacts: Sergiu Simmel email@example.com Ivan Godard firstname.lastname@example.org general information email@example.com subscription to moderated newsletter firstname.lastname@example.org
REFERENCES: Segui S. Simmel and Ivan Godard. "The Kala Basket: A Semantic Primitive Unifying Object Transactions, Access Control, Versions, annd Configurations
This document was translated by ms2html v1.8 on 01.06.95.