On the Design of the Object-Oriented Language Sina

This thesis is concerned with the development of software tools to design distributed information systems. These systems are inherently more complex to build than centralized systems. The complexity of distributed information system design is heightened by the lack of tools that assist in the construction and programming of distributed systems and applications. The software tools presented here have been devised in the context of the design of the object-oriented language Sina. The Sina language includes a number of interesting and novel features which aim at providing high-level tools for the design of distributed systems. The novel material of this thesis is presented in four pieces. 1) The first novel feature is a data abstraction mechanism based on interface predicates. By means of a simple interface predicate construct, one can implement various forms of abstractions without selecting one among them as a language feature. Interface predicates are also useful to deduce the subtype relations among types. Besides, this data abstraction model provides a stronger data encapsulation than conventional object-oriented languages. 2) The second novel material is the concurrent programming and synchronization model of Sina. The primary advantage of this model is that it permits implementations of objects with different policies for synchronization. In implementing systems with nested resource structures, constructs of Sina alleviate the difficulties that arise in using monitor-based solutions. In comparison to other object-oriented languages, Sina supports both inter-object and intra-object concurrency since Sina objects can encapsulate a shared resource as well as its related synchronization mechanisms together in the same module. 3) The third novel material is a new abstraction technique called abstract communication types. Abstract communication types can be useful in abstracting patterns of messages and large scale synchronization among objects. By means of very primitive constructs one can implement and abstract well-known language mechanisms as a type module which are traditionally adopted in languages as primitive features. These types can be easily integrated with other object-oriented disciplines such as inheritance. 4) Finally, a new concept called atomic delegations is presented. Atomic delegations are more powerful than transactions because they support the construction of open-ended systems and systematic reuse of atomic code. Atomic delegations are also uniformly integrated with other object-oriented techniques like inheritance. The versatility of these novel features are illustrated by using a number of examples; all these examples have been programmed and tested using our implementation on a workstation.