Applying a Domain Specific Language Approach to Component Oriented Programming Object-Oriented Technology: ECOOP’98 Workshop Reader
edited by: Serge Demeyer, Jan Bosch
A number of methods have been suggested to deal with component specification (e.g. Buichi and Sekerinski [ 1 ]), re-use (e.g Lalanda [ 2 ]) and fault-management (e.g Baggiolini and Harms [ 3 ]). At Durham we propose the use of a Domain Oriented method in order to specify the semantic and syntactic properties of components, to provide a framework in which to re-use and re-configure the components and to provide additional optimisation and fault-tolerant behaviour. We are currently developing a prototype Domain Specific Language (DSL) which describes a “model” domain of cost-accounting. In order to implement this prototype we are using Java, CORBA and JESS (Java Expert System Shell [ 4 ]) and a distributed component model. Different categories of component types (e.g. persistent components) are being identified and guidelines for their use documented. By developing many little languages (as per Deursen and Klint [ 5 ]) it is claimed that the maintenance effort will be reduced. After the implementation and evaluation of this “toy domain”, we propose to apply these techniques to an industrial software system by working closely with a large telecommunications company. This paper identifies a number of issues which the authors feel are important for Component Oriented Programming to succeed. Then we define DSL’ s and outline how and why we are using them, first in general terms and then in terms of the issues outlined earlier. In order to promote component re-use we are advocating automating some methods of error detection which will be encoded into the DSL. This will enable a current configuration of components to detect certain error conditions and, with the help of extra domain knowledge and the underlying system architecture, attempt to remedy the situation. This is followed by a brief overview of the supporting architecture which has been developed to allow the mapping of DSL constructs to component code and to automatically insert test code where applicable. This architecture is currently being implemented in Java and CORBA at the University of Durham. We have also included an outline of the “toy domain” DSL language. Although this architecture addresses many important aspects of re-use, it is acknowledged that it is still based on the assumption of “as is” re-use or human intervention at times of component development. However it is argued that for this approach these are not unreasonable assumptions.