objects modelling  the points raised here are based on experience with rad [os86], an experimental relational database system which allows the definition of arbitrary abstract data types and arbitrary operations, for domains. the comments below fall into two categories: the appropriateness of the data model and the level at which programming is done.  data model: for the applications motivating the object-oriented database discussion, one could enhance a programming language environment rich in abstract data type support, like smalltalk, with the required database functionality as in gemstone [co84], or one could enhance a database system by adding object semantics. rad is about the simplest possible approach in the latter category. there are a great many applications for which commercial database systems do not have enough domain types, where the rad approach seems to be adequate. however, there are other applications where the rad approach is too simple. these applications have highly nested structures in which the root object consists of an aggregation of other objects, which are aggregations of other objects, etc. the choices in rad, or any system based closely on the relational model are: (1) defining an abstract data type domain for the whole structure, (2) flattening the whole structure into first normal form relations with fairly atomic domains, or (3) some compromise between 1 and 2.  rad has two general classes of objects, domains and relations, each with very different operations. choice 1 above means that the components of a complex object can never be accessed by the relational algebra operators. one must also avoid the temptation to re- implement a relational query language on a single domain. choice 2 is also not a good idea. the data for a single object will be scattered so far and wide that an inordinate amount of work will be needed to retrieve it, update it, etc.  with the third choice, somewhere between the two extremes, the point of compromise will be very difficult to decide on and one will still suffer from the drawbacks of the two extreme solutions.  the problem here is not so much with the extensible database approach but with extending a relational database. the relational model is too simple to capture the structure of the complex objects at an appropriate level. an extensible database system whose underlying data model is semantically richer than the bare bones relational model, like smith and smith's [sm77a, sm77b] or sam* [su86], would do a much better job.  object modelling usually requires some form of inheritance or isa hierarchies. systems which support inheritance do so by defining it with respect to classes of objects. relational database systems only allow one to define relation instances, not relation classes. thus the relational model cannot properly handle inheritance.  current semantic data models make a sharp distinction between the structured objects they allow and atomic objects (in relational terms, between relations and domains) in the operations allowed on objects from these two broad classes. we are currently investigating an object oriented data model in which this distinction is not so sharp.  programming level: with rad, the assumption is that new domain types are designed and implemented by application programmers. the end users of the object oriented databases are engineers, librarians, office workers --- professionals in their own field but not professional programmers. in rad, complex operations must be written by experienced programmers, not end users. if the objects in the application are indeed the complex, highly nested ones mentioned above, it may be very difficult to anticipate all the operations a user will want to perform on them. users seem to be able to express their own queries in sql or other database query languages. the challenge now is to devise a way for them to easily express complex operations on complex objects. this comment is also valid for gemstone. smalltalk programmers are rare enough, but users capable of adding their own smalltalk methods are even rarer.  this type of comment also applies to the mechanism provided for defining new object types. in contrast to the operations, the structure of the complex types can probably be determined in advance. thus defining the structure of a type is not likely to be a task for a user, but one which can be done in advance by the application programmer. this application programmer should not, however, have to be an implementor of the database management system in question. rad has been successful in showing how a domain type can be introduced without the programmer actually knowing how the dbms is implemented.  sylvia osborn