Interface Definition Language

Parametric polymorphism has become a common feature of mainstream programming languages, but software component architectures have lagged behind and do not support it. We examine the problem of providing parametric polymorphism with components combined from different programming languages. We have investigated how to resolve different binding times and parametrization semantics in a range of representative languages and have identified a common ground that can be suitably mapped to different language bindings. We present a generic component architecture extension that provides support for parameterized components and that can be easily adapted to work on top of various software component architectures in use today (e.g., corba, dcom, jni). We have implemented and tested this architecture on top of corba. We also present Generic Interface Definition Language (gidl), an extension to corba-idl supporting generic types and we describe language bindings for C++, Java and Aldor. We explain our implementation of gidl, consisting of a gidl to idl compiler and tools for generating linkage code under the language bindings. We demonstrate how this architecture can be used to access C++'s stl and Aldor's BasicMath libraries in a multi-language environment and discuss our mappings in the context of automatic library interface generation.

The software components of embedded control systems get extremely complex as they are designed into distributed systems consisting of a large number of inexpensi ve microcontrollers interconnected by low-bandwidth real-time networks such as the controller area network (CAN). While recently emerging middleware technologies such as CORBA and DCOM address the complexity of distributed programming, they cannot be directly applied to distributed control system design due to their excessive resource demand and inadequate communication models. In this paper, we propose a CORBA-based middleware design for CANbased distributed embedded control systems. Our design goal is to minimize its resource need and make it support group communication without losing the IDL (interface definition language) level compliance to the OMG standards. To achieve this, we develop a transport protocol on the CAN and a group communication scheme based on the well-known publisher/subscriber model. The protocol effectively realizes subject-based addressing and supports anonymous publisher/subscriber communication. We also customize the method invocation and message passing protocol, referred to as the general inter-ORB protocol (GIOP), of CORBA so that CORBA method invocations are efficiently serviced on a low-bandwidth network such as the CAN. This customization includes packed data encoding and variable-length integer encoding for compact representation of IDL data types. We have implemented our CORBA-based middleware on the mArx real-time operating system we have developed at Seoul National University. Our experiments clearly demonstrate that it is feasible to use CORBA in developing distributed embedded control systems possessing severe resource limitations. Our design clearly demonstrates that it is feas ible to use a CORBA-based middleware in developing distributed embedded systems on real-time networks possessing severe resource limitations.

An interface definition language (IDL) is a nontraditional language for describing interfaces between software compo- nents. IDL compilers generate “stubs” that provide separate communicating processes with the abstraction of local object invocation or procedure call. High-quality stub generation is essential for applications to benefit from component-based designs, whether the components reside on a single computer or on multiple networked hosts. Typical IDL compilers, however, do little code optimization, incorrectly assuming that interprocess communication is always the primary bottleneck. More generally, typical IDL compilers are “rigid” and limited to supporting only a single IDL, a fixed mapping onto a target language, and a narrow range of data encodings and transport mechanisms.
Flick, our new IDL compiler, is based on the insight that IDLs are true languages amenable to modern compilation techniques. Flick exploits concepts from traditional programming language compilers to bring both flexibility and optimization to the domain of IDL compilation. Through the use of carefully chosen intermediate representations, Flick supports multiple IDLs, diverse data encodings, multiple transport mechanisms, and applies numerous optimizations to all of the code it generates. Our experiments show that Flick-generated stubs marshal data between 2 and 17 times faster than stubs produced by traditional IDL compilers, and on today’s generic operating systems, increase end-to-end throughput by factors between 1.2 and 3.7.

This paper describes current work aimed at helping scientists gain confidence in software built from emerging component technologies through the automated enforcement of interface contracts. These contracts consist of assertions required to hold before and after interface methods are executed. Runtime contract enforcement is a well-known technique for enhancing testing and debugging, but is typically considered too expensive for deployment. Prior work investigated strategies intended to retain an application's high performance while enforcing contracts during plug-and-play component deployment. The associated studies involved single-component implementations in C and C++.

The generic software interface simulator framework for Atacama Large Millimeter Array (ALMA) Common Software (ACS) provides ALMA developers with an easy means to create and configure the behaviour of interfaces that have been defined using Common Object Request Broker Architecture (CORBA) Interface Definition Language (IDL). ACS consists of a set of application frameworks built on top of CORBA and provides the glue which binds other ALMA software subsystems together [7]. In short, ACS provides an implementation of the component-container design pattern via CORBA. Using the simulation framework, one can choose to predefine the behaviour of a simulated component by embedding simple Python commands within a section of the XML-based ACS configuration database (CDB). The option to configure simulated components' behaviour at run-time is also a possibility using a provided graphical user interface (GUI) or application programming interface (API) executed within the context of an interactive Python session. Additionally, if the means above have not been utilized to setup the components' behaviour the framework will dynamically provide an implementation of the entire component with a randomized behaviour. This framework is especially useful to ALMA developers for two reasons. On one side it allows developers to test their own component, which is dependent upon other types of components that have been defined via IDL interfaces, but not yet implemented. On the other side this tool has proven itself to be quite valuable because it allows developers to connect clients such as graphical user interfaces to (simulated) components encapsulating hardware devices. Not only can the physical hardware devices be absent in this type of scenario, but the software representing the hardware need not be available either. The end result here is that clients and components can be developed and tested in parallel completely independent of each other. This paper discusses the design, implementation, and current usage of the simulator framework within ALMA software as well as future improvements to be made.

The Object Management Group (OMG*) is adopting a set of standards for distributed computing, including multiple programming language bindings to the Interface Definition Language (OMG IDL). This paper explains the need for an OMG IDL mapping to Common Lisp, and shows some examples of such a binding and its implementation, based upon the authors' work on integrating Common Lisp applications using OMG-compliant object request brokers.

Composition of Web Services (WSs) is anticipated as the future standard way to dynamically build distributed applications, and hence their verification and validation is attracting great attention. The standardization of BPEL as a composition language and of WSDL as a WS interface definition language has led researchers to investigate verification and validation techniques mainly focusing on the sequence of events in the composition, while minor attention has been paid to the validation of the data flow exchange. In this chapter we study the potential of using data flow modelling for testing composite WSs. After an exhaustive exploration of the issues on testing based on data-related models, we schematically settle future research issues on the perspectives opened by data flow-based validation and present examples for some of them, illustrated on the case study of a composite WS that we have developed, the Virtual Scientific Book Store.

The Common Component Architecture (CCA) provides a means for software developers to manage the complexity of large-scale scientific simulations and to move toward a plug-and-play environment for high-performance computing. In the scientific computing context, component models also promote collaboration using independently developed software, thereby allowing particular individuals or groups to focus on the aspects of greatest interest to them. The CCA supports parallel and distributed computing as well as local high-performance connections between components in a language-independent manner. The design places minimal requirements on components and thus facilitates the integration of existing code into the CCA environment. The CCA model imposes minimal overhead to minimize the impact on application performance. The focus on high performance distinguishes the CCA from most other component models. The CCA is being applied within an increasing range of disciplines, including combustion research, global climate simulation, and computational chemistry.

The decision to use Digital Imaging and Communications in Medicine (DICOM), Health Level 7 (HL7), a common object broker such as the Common Object Request Brokering Architecture (CORBA) or ActiveX (Microsoft Corp, Redmond, WA) or any other protocol for the transfer of DICOM data depends on the requirements of a particular implementation. The selection of protocol is independent of the information model. Our goal as message standards developers is to design a data interchange infrastructure that will faithfully convey the computer-based patient record and make it available to authorized health care providers when and where it is needed for patient care. DICOM accurately and expressively represents the clinically significant properties of images and the semantics of imagerelated information. The DICOM data model is small and well-defined. The model can be expressed in Standard Generalized Markup Language (SGML) or Object Management Group Interface Definition Language or other common syntax--and can be implemented using any reliable communications protocol. Therefore our opinion is that the DICOM semantic data model should serve as the basis for a Iogically equivalent set of specifications in HL7, CORBA, Ac-tiveX, and SGML for the interchange of biomedical images and image-related information.

We attack the problem of user fatigue in using an interactive genetic algorithm to evolve user interfaces in the XUL interface definition language. The interactive genetic algorithm combines computable user interface design metrics with subjective user input to guide evolution. Individuals in our population represent interface specifications and we compute an individual's fitness from a weighted combination of user input

Data collections are distributed at many different sites and stored in numerous different database management systems. The industry standard CORBA can help to alleviate the technical problems of distribution and diverging data formats. In a CORBA environment, data structures can be represented using the Interface Definition Language IDL. Manually coding a server, which implements the IDL through calls to the underlying database, is tedious. On the other hand, it is in general impossible to automatically generate the CORBA server because the IDL is not only determined by the schema of the database but also by other factors such as performance requirements. We therefore have developed a method for the semi-automatic generation of CORBA wrappers for relational databases. A declarative language is presented, which is used to describe the mapping between relations and IDL constructs. Using a set of such mapping rules, a CORBA server is generated together with the IDL. Additionally, the server is equipped with a query language based on the IDL. We have implemented a prototype of the system.

Mobile Agents is a new paradigm for distributed computing where security is very essential to the acceptance of this paradigm in a large scale distributed environment. In this paper, we propose protection mechanisms for mobile agents. In these mechanisms, the authentication of mobile agents and the access control to the system resources are controlled by the mobile-agents platform. Each agent defines its own access control policy with regard to other agents using an Interface Definition Language (IDL), thus enforcing modularity and easing programming task. An evaluation of these mechanisms has been conducted. The measurements give the overhead involved by the proposed protection mechanisms to the performance of mobile agents. An important advantage of our protection mechanisms are transparency to agents and the portability of nonsecure applications onto a secure environment. A mobile agent system and the protection mechanisms have been implemented. Our experiments have shown the feasibility and the advantages of our mechanisms.

In this paper we propose two sets of metrics to measure complexity and criticality of large software systems designed and integrated using the principles of Component Based Software Engineering (CBSE). From the Component Interface Definition Language (CIDL) specification [32], we ...

This paper describes work in progress to develop a standard for interoperability among high-performance scientific components. This research stems from growing recognition that the scientific community needs to better manage the complexity of multidisciplinary simulations and better address scalable performance issues on parallel and distributed architectures. Driving forces are the need for fast connections among components that perform numerically intensive work and for parallel collective interactions among components that use multiple processes or threads. This paper focuses on the areas we believe are most crucial in this context, namely, an interface definition language that supports scientific abstractions for specifying component interfaces and a ports connection model for specifying component interactions.

In this paper we examine formally the idea that the architecture of a system can be modelled by the structure of its interface expressed in terms of the interfaces for its components. Thus, System Interface Architecture = Structured set of Sub-system Interfaces:

Remote Procedure Call (RPC) is a commonly used mech-anism for clienthewer applications. RPC implements a tightly synchronized clienthewer interaction that is analo-gous to the well understood procedure call in regular non-distributed applications. The ...

The Common Object Request Broker Architecture (CORBA) is the most successful representative of an object-based distributed computing architecture. Although CORBA simplifies the implementation of complex, distributed systems significantly, the support of techniques for reliable, fault-tolerant software, such as group communication protocols or replication is very limited in the state-of-the-art CORBA or even fault-tolerant CORBA. Any fault tolerance extension for CORBA components needs to trade off data abstraction and encapsulation against implementation specific knowledge about a component's internal timing behavior, resource usage and interaction patterns. These non-functional aspects of a component are crucial for the predictable behavior of fault-tolerance mechanisms. However, in contrast to CORBA's interface definition language (IDL), which describes a component's functional interface, there is no general means to describe a component's non-functional properties. We present here a generic framework, which makes existing CORBA components faulttolerant. In adherence with a given, programmer-specified fault model, our framework uses design-time and configuration-time information for automatic distributed, replicated instantiation of components. Furthermore, we propose usage of aspect-oriented programming (AOP) techniques to describe fault-tolerance as a non-functional component property. We describe the automatic generation of replicated CORBA services based on aspect information and demonstrate service configuration through a graphical user-interface.

CORBA is a standard proposed by the Object Management Group (OMG) that promotes interoperability between distributed object systems. Following the standardization of this object-oriented middleware, the OMG has specified a set of Common Object Services (COS) that are meant to serve as the building blocks of distributed CORBA applications. The COSes are specified using CORBA Interface Definition Language (IDL), that describes the syntactic aspects of services supported by remote objects. However, CORBA-IDL does not support specification of the behaviour of objects in an abstract and formal way, and behavioural specification is mostly provided in plain English. To overcome this problem, we have proposed a formal description technique (Cooperative Objects) based on high-level Petri nets, and developed a software support environment. The goal of this paper is to demonstrate that our approach is suited to the formal specification of typical CORBA COS, and presents a Cooperative Object model of the CORBA event service, a COS that provides asynchronous, one-to-many communication between objects. The advantages of dealing with a tool-supported, executable formal notation are detailed, as weil as the results that can be obtained through Petri net analysis techniques.

CORBA is a standard proposed by the Object Management Group (OMG) that promotes interoperability between distributed object systems. Following the standardization of this object-oriented middleware, the OMG has specified a set of Common Object Services (COS) that are meant to serve as the building blocks of distributed CORBA applications. The COSes are specified using CORBA Interface Definition Language (IDL), that describes the syntactic aspects of services supported by remote objects. However, CORBA-IDL does not support specification of the behaviour of objects in an abstract and formal way, and behavioural specification is mostly provided in plain English. To overcome this problem, we have proposed a formal description technique (Cooperative Objects) based on high-level Petri nets, and developed a software support environment. The goal of this paper is to demonstrate that our approach is suited to the formal specification of typical CORBA COS, and presents a Cooperative Object model of the CORBA event service, a COS that provides asynchronous, one-to-many communication between objects. The advantages of dealing with a tool-supported, executable formal notation are detailed, as weil as the results that can be obtained through Petri net analysis techniques.

The decision to use Digital Imaging and Communications in Medicine (DICOM), Health Level 7 (HL7), a common object broker such as the Common Object Request Brokering Architecture (CORBA) or ActiveX (Microsoft Corp, Redmond, WA) or any other protocol for the transfer of DICOM data depends on the requirements of a particular implementation. The selection of protocol is independent of the information model. Our goal as message standards developers is to design a data interchange infrastructure that will faithfully convey the computer-based patient record and make it available to authorized health care providers when and where it is needed for patient care. DICOM accurately and expressively represents the clinically significant properties of images and the semantics of imagerelated information. The DICOM data model is small and well-defined. The model can be expressed in Standard Generalized Markup Language (SGML) or Object Management Group Interface Definition Language or other common syntax--and can be implemented using any reliable communications protocol. Therefore our opinion is that the DICOM semantic data model should serve as the basis for a Iogically equivalent set of specifications in HL7, CORBA, Ac-tiveX, and SGML for the interchange of biomedical images and image-related information.

Traditional IDLs were defined for describing the services that objects offer, but not those services they require from other objects, nor the relative order in which they expect their methods to be called. Some of the existing proposals try to add protocol information to object interfaces, but most of them fail to do so in a modular way. In this paper we propose an extension of the CORBA IDL that uses a sugared subset of the polyadic π-calculus for describing object service protocols, based on the concept of roles. Roles allow the modular specification of the observable behavior of CORBA objects, reducing the complexity of the compatibility tests. Our main aim is the automated checking of protocol interoperability between CORBA objects in open component-based environments, using similar techniques to those used in software architecture description and analysis. In addition, our proposal permits the study of substitutability between CORBA objets, as well as the realization of dynamic compatibility tests during their run-time execution.

CORBA is a standard proposed by the Object Management Group (OMG) that promotes interoperability between distributed object systems. Following the standardization of this object-oriented middleware, the OMG has specified a set of Common Object Services (COS) that are meant to serve as the building blocks of distributed CORBA applications. The COSes are specified using CORBA Interface Definition Language (IDL), that describes the syntactic aspects of services supported by remote objects. However, CORBA-IDL does not support specification of the behaviour of objects in an abstract and formal way, and behavioural specification is mostly provided in plain English. To overcome this problem, we have proposed a formal description technique (Cooperative Objects) based on high-level Petri nets, and developed a software support environment. The goal of this paper is to demonstrate that our approach is suited to the formal specification of typical CORBA COS, and presents a Cooperative Object model of the CORBA event service, a COS that provides asynchronous, one-to-many communication between objects. The advantages of dealing with a tool-supported, executable formal notation are detailed, as weil as the results that can be obtained through Petri net analysis techniques.

important that the application software in ubicomp environments is trustworthy. In order to have trustworthy application software in ubicomp environments, situation-awareness (SAW) in the application software is needed for enforcing flexible security policies and detecting violations of security policies. In this paper, an approach is presented to providing development and runtime support for incorporating SAW in trustworthy ubicomp application software. The development support is to provide SAW requirement specification and automated code generation for achieving SAW in trustworthy ubicomp application software, and the runtime support is for context acquisition, situation analysis, and situation-aware communication. To realize our approach, the improved Reconfigurable Context-Sensitive Middleware (RCSM) is developed for providing the above development and runtime support.

Traditional IDLs were defined for describing the services that objects offer, but not those services they require from other objects, nor the relative order in which they expect their methods to be called. Some of the existing proposals try to add protocol information to object interfaces, but most of them fail to do so in a modular way. In this paper we propose an extension of the CORBA IDL that uses a sugared subset of the polyadic π-calculus for describing object service protocols, based on the concept of roles. Roles allow the modular specification of the observable behavior of CORBA objects, reducing the complexity of the compatibility tests. Our main aim is the automated checking of protocol interoperability between CORBA objects in open component-based environments, using similar techniques to those used in software architecture description and analysis. In addition, our proposal permits the study of substitutability between CORBA objets, as well as the realization of dynamic compatibility tests during their run-time execution.

If formal techniques are to be more widely accepted then they should evolve as current software engineering approaches evolve. Current techniques in the development of distributed systems use interface definition languages (IDLs) as a basis for the underlying communication and also as an abstraction tool. Object-oriented technologies [6] and the idea of engineering software through frameworks are also widely accepted approaches in developing software. In this paper we show how the formal specification language SDL and associated tool support have been applied in the TOSCA 1 project to engineer telecommunication services using these current techniques.

In object-oriented frameworks, the interactions between objects are often complex and difficult to understand. In this paper, "interaction protocols" are introduced as a means to describe object interactions. The interface definition language "IPDL", an extension of OMG's IDL, is introduced for specifying object interactions. Besides making object- oriented system descriptions more readable by explicitly representing inter-object behaviour, interaction protocols can

This paper describes work in progress to develop a standard for interoperability among high-performance scientific components. This research stems from growing recognition that the scientific community needs to better manage the complexity of multidisciplinary simulations and better address scalable performance issues on parallel and distributed architectures. Driving forces are the need for fast connections among components that perform numerically intensive work and for parallel collective interactions among components that use multiple processes or threads. This paper focuses on the areas we believe are most crucial in this context, namely, an interface definition language that supports scientific abstractions for specifying component interfaces and a ports connection model for specifying component interactions.