Interface Definition Language

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.

Context-sensitivity is an important expected capability in applications in ubiquitous computing (ubicomp) environments. These applications need to use different contextual information from the user, host device, on board sensors, network, and the ambient environments to systematically adapt their actions. In addition, some context-sensitive applications may use speci®c contextual conditions to trigger impromptu and possibly short-lived interactions with applications in other devices. This property, referred to as context-sensitive or context-aware communications, allows applications to form short-range mobile ad hoc networks consisting of mobile and stationary devices, sensors, and other computing resources. Real-time applications, especially those having reactive behavior, running on embedded devices and requiring context-sensitive communications support, pose new challenges related to systematic representation of speci®c contexts, associations of contexts with real-time actions, timely context data collection and propagation, and transparent context-sensitive connection establishment. An object-based middleware can be effective to meet these challenges if such a middleware can provide a well-de®ned development framework as well as lightweight runtime services. In this paper, an adaptive and object-based middleware, called recon®gurable context-sensitive middleware (RCSM) is presented to facilitate context-sensitive communications in ubicomp environments. To facilitates contextsensitive communications, RCSM provides a context-aware interface de®nition language for specifying contextsensitive interfaces of real-time objects, an object container framework for generating interfaces-speci®c context-analyzers, and a context-sensitive object request broker for context-sensitive object discovery and impromptu connection management. RCSM is adaptive in the sense that depending on the context-sensitive behavior of the applications, it adapts its object discovery and connection management mechanisms. -sensitive object discovery, adaptive middleware, mobile ad hoc networks, object-based middleware, context-sensitive object request broker the following characteristics Oxygen, 2000;): * Context sensitivity: Applications use various data about the surrounding environment and the available resources to adapt their behavior and interactions. * Context-sensitive interactions: Applications software in different devices exchange data with each other through communication channels that are instantaneously established, short lived, and terminated due to changing contexts and node mobility. * Intelligent human computer interaction: Applications software provides richer and natural interfaces to support common forms of human expressions, such as speech, hand gestures, etc. * usually have bandwidth and energy constraints; and RECONFIGURABLE CONTEXT-SENSITIVE MIDDLEWARE FOR REAL-TIME SOFTWARE * To facilitate the interactions among distributed applications by elevating the programming abstraction and forcing a clear separation between interface and implementation.

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.

Many architecture description languages (ADLs) have been proposed to model, analyze, configure, and deploy complex software systems. To face this diversity, extensible ADLs (or ADL interchange formats) have been proposed. These ADLs provide linguistic support for integrating various architectural aspects within the same description. Nevertheless, they do not support extensibility at the tool level, i.e. they do not provide an extensible toolset for processing ADL descriptions.

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

As Web services proliferate, size and magnitude of UDDI Business Registries (UBRs) are likely to increase. The ability to discover Web services of interest then across multiple UBRs becomes a major challenge specially when using primitive search methods provided by existing UDDI APIs. Clients do not have the time to endlessly search accessible UBRs for finding appropriate services particularly when operating via mobile devices. Finding services of interest should be time effective and highly productive. This paper addresses issues relating to the efficient access and discovery of Web services across multiple UBRs and introduces a novel exploration engine, the Web Service Crawler Engine (WSCE). WSCE is capable of crawling multiple UBRs, and enables for the establishment of a centralized Web services repository that can be used for discovering Web services much more efficiently. The paper presents experimental validation, results, and analysis of the proposed ideas.

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:

Due to the dynamic and ephemeral nature of ubiquitous computing (ubicomp) environments, it is necessary that application software in ubicomp environments is situationaware (SA) and should be adaptable to both users' situation changes and the requirement changes. Reconfigurable Context-Sensitive Middleware (RCSM) has been developed to provide development and runtime support for SA software in ubicomp environments, but do not provide runtime support for on-demand context acquisition, action scheduling and dynamic reconfiguration of SA software, and development support that maximize the reusability. In this paper, the development and runtime support provided by RCSM have been substantially expanded to greatly simplify the development of situation-aware application software, and to achieve reusability and runtime reconfigurability simultaneously.

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 derive two suites of complexity metrics, namely, Component Packing Density (CPD) metrics and Component Interaction Density (CID). The CPD metric relates component co nstituents to the number of integrated components. The CID metric suite relates interactions between components to the number of available interactions in the entire system. We also define a set of criticality criteria for component integration. Our proposed experimental design and the expected results are also outlined in this paper.

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.

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.

Chasm is a toolkit providing seamless language interoperability between Fortran 95 and C++. Language interoperability is important to scientific programmers because scientific applications are predominantly written in Fortran, while software tools are mostly written in C++. Two design features differentiate Chasm from other related tools. First, we avoid the common-denominator type systems and programming models found in most Interface Definition Language (IDL)-based interoperability systems. Chasm uses the intermediate representation generated by a compiler front-end for each supported language as its source of interface information instead of an IDL. Second, bridging code is generated for each pairwise language binding, removing the need for a common intermediate data representation and multiple levels of indirection between the caller and callee. These features make Chasm a simple system that performs well, requires minimal user intervention and, in most instances, bridging code generation can be performed automatically. Chasm is also easily extensible and highly portable.

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.

Language interoperability is a difficult problem facing the developers and users of large numerical software packages. Language choices often hamper the reuse and sharing of numerical libraries, especially in a scientific computing environment that uses a breadth of programming languages, including C, c ++, Java, various Fortran dialects, and scripting languages such as Python. In this paper, we propose a new approach to langauge interoparability for high-performance scientific applications based on Interface Definition Language (IDL) techniques. We investigate the modifications necessary to adopt traditional IDL approaches for use by the scientific community, including IDL extensions for numerical computing and issues involved in mapping IDLs to Fortran 77 and Fortran 90. 'Work performed under the auspices of the U.S. Department of Energy by Lawrence Livermore National Laboratory under Contract W-7405-Eng-48. This work has been funded by both ASCI PSE and DOE2000.

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 EMBL Nucleotide Sequence Database is a comprehensive database of DNA and RNA sequences and related information traditionally made available in flat-file format. Queries through tools such as SRS (Sequence Retrieval System) also return data in flat-file format. Flat files have a number of shortcomings, however, and the resources therefore currently lack a flexible environment to meet individual researchers' needs. The Object Management Group's common object request broker architecture (CORBA) is an industry standard that provides platform-independent programming interfaces and models for portable distributed object-oriented computing applications. Its independence from programming languages, computing platforms and network protocols makes it attractive for developing new applications for querying and distributing biological data. A CORBA infrastructure developed by EMBL-EBI provides an efficient means of accessing and distributing EMBL data. The EMBL object model is defin...

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.

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 separation of architecture definition language (ADL) and interface definition language (IDL) is widely accepted in the distributed system community. It separates issues of hierarchical composition and configuration from those of services, communication and synchronisation and thus eases reconfiguration without changing the interfaces and implementation and allows the change of services within well-defined configuration constraints. Our approach towards distributed system definition draws on the Darwin project's notion of distributed system architecture definition and on Eiffel's notion of design-by-contract. We extend contracts to deal with synchronisation and coordination at a higher level, explicitly targeting both large-scale loosely-coupled distributed components and tightly coupled parallel or multithreaded objects.

Universal Personal Computing (UPC) is a novel concept to support nomadic computing on the Internet. UPC enables mobile users to access their personalized computing environment anywhere on the Internet using any available terminals. The system is modeled as distributed objects using Common Object Request Broker Architecture (CORBA) to facilitate their distribution, interfacing, and integration. We have chosen the Specification and Description Language (SDL) for our system design. Through several iterations, we refine the specification and verify the correctness of the design. The final version serves as the basis for system implementation. The SDL specification allows a direct derivation of object interface description in Interface Definition Language (IDL). Finally some implementation issues are discussed. ᭧

Components can be a useful tool in software development, including the development of scientific computing applications. Many scientific applications require parallel execution, but commodity component models based on remote method invocation do not directly support the notion of parallel components. Parallel components raise questions about the semantics of method invocations and the mechanics of parallel data redistribution involving these components. Allowing parallel components to exist within a component framework comes at very little extra cost to the framework designer. However, the interaction semantics (i.e. method invocations) between two parallel components or between a parallel and non-parallel component can be complex and should require support from the underlying run-time system. The parallel data redistribution problem comes about when in order to increase efficiency, data are subdivided among cooperating parallel tasks within one component. When two or more components of this type are required to perform a separate computation on the same data, this data distribution must be decoded and mapped from the first component to the second component's specification. We demonstrate a method to handle parallel method invocation and perform automatic data redistribution using the code generation process of an interface definition language compiler. The generated code and run-time system accomplish the necessary data transfers and provide consistent behavior to method invocation. We describe the implementation of and semantics of parallel remote method invocation. We describe how collective method calls can be used to provide coherent interactions between multiple components. Several results and benchmarks are discussed.

The HuGeMap database stores the major genetic and physical maps of the human genome. HuGeMap is accessible on the Web at http://www.infobiogen.fr/ services/Hugemap and through a CORBA server. A standard genome map data format for the interconnection of genome map databases was defined in collaboration with the EBI. The HuGeMap CORBA server provides this interconnection using the interface definition language IDL. Two graphical user interfaces were developed for the visualization of the HuGeMap data: ZoomMap (http://www.infobiogen.fr/services/ zomit/ZoomMap.html ) for navigation by zooming and data transformation via magic lenses, and Mappet-Show (http://www.infobiogen.fr/services/Mappet ) for visualizing and comparing maps.

Next-generation telecommunication software must be flexible and reusable. These requirements motivate the use of object-oriented (OO) middleware like the Common Object Request Broker Architecture (CORBA). However, many existing telecommunication software products have already been written using the Distributed Computing Environment (DCE) RPC toolkit. To reduce porting effort and to minimize unnecessary rework, it is essential to provide a smooth migration path from DCE to CORBA. This paper provides two contributions to the study of migration strategies from DCE to CORBA. First, we describe a migration tool we developed that provides source-level interoperability between DCE RPC and CORBA. Our tool automatically translates DCE Interface Definition Language (IDL) into CORBA IDL and generates code that integrates existing DCE-based code with stubs and skeletons generated by CORBA IDL compilers. Second, we present our lessons learned applying this migration tool to a project at Bellcore...

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.

In high-performance scientific software development, the emphasis is often on short time to first solution. Even when the development of new components mostly reuses existing components or libraries and only small amounts of new code must be created, dealing with the component glue code and software build processes to obtain complete applications is still tedious and error-prone. Component-based software meant to reduce complexity at the application level increases complexity to the extent that the user must learn and remember the interfaces and conventions of the component model itself. To address these needs, we introduce Bocca, the first tool to enable application developers to perform rapid component prototyping while maintaining robust software-engineering practices suitable to HPC environments. Bocca provides project management and a comprehensive build environment for creating and managing applications composed of Common Component Architecture components. Of critical importance for high-performance computing (HPC) applications, Bocca is designed to operate in a language-agnostic way, simultaneously handling components written in any of the languages commonly used in scientific applications: C, C++, Fortran, Python and Java. Bocca automates the tasks related to the component glue code, freeing the user to focus on the scientific aspects of the application. Bocca embraces the philosophy pioneered by Ruby on Rails for web applications: start with something that works, and evolve it to the user's purpose.

The advantages of object - oriented (OO) programming are well - known Nevertheless, distributed OO middleware sys - tems (OOM) such as CORBA, DCOM or Java RMI have not been widely adopted for the developing of Internet applications Developers seem to perceive OOMs as over - complex, proprietary or incompatible with current WWW development practices Recognizing these di culties

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.

Services within the DISCWorld system can be represented by objects. These services may be distributed on nodes of a heterogeneous system, with communication between clients and these services and also between the services themselves, provided by a suitable middleware system. As well as managing communication, a middleware system has to provide for locating and activating services, gathering performance data and security. We describe how the CORBA 2.0 specification, developed by the OMG, and CORBAServices can be used as a basis for a middleware system to manage DISCWorld Services. We also describe how Java and Java RMI can be used in combination with CORBA and what benefits this brings. We discuss some of the problems with the mapping of the CORBA interface definition language, IDL, to Java.

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 . 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.

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++.