Interface Definition Language

BibTex@ misc {title={Smart Object Architecture for Energy-Efficient Wireless Sensors}, author={Ashutosh Verma, Winston Wu, Sridhar Vemuri, Gregory Pottie, William Kaiser}, abstract={Advances in distributed embedded computing and wireless networking have ...

Divided into four main sessions, the workshop covered some of the most important issues related to object interoperability at different levels (such as protocols or semantics). This report has two main goals. First, it tries to provide a snapshot of some of the current research being carried out within the object-oriented community in these areas. And second, it summarizes some of the open questions and issues related to object interoperability, in order to set the basis for further research activities.

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.

This paper presents an overview of the application of ITU-SOL for the development of distributed systems according to the RM-OOP. The use of the advanced SITE tools for the simulation and prototype code generation of/from SOL specifications of computational as well as engineering objects is illustrated. The advantages of this approach are shown by applying it on the OOP trading function as an example. Furthermore, concepts and principles for a smooth, semi-automatic SOL based transition between viewpoints, which are currently under development, are sketched out.

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.

Simplifying the administration of location-based access-control policies requires a mechanism that supports both intuitive and scalable spatial constraint specifications and a flexible enforcement architecture. Policy Mapper is an administrative tool that helps define access control at conceptual and logical levels to carry out constraint specification and enforcement. The tool also provides an Interface Definition Language that couples the two levels. Policy Mapper bridges a critical gap between the expressiveness and enforcement of spatial constraints in location-based access-control policies.

METU INteroperable Database System (MIND) is a multidatabase system that aims at achieving interoperability among heterogeneous, federated DBMSs. MIND architecture if based on OMG distributed object management model. It is implemented on top of a CORBA compliant ORB, namely, ObjectBroker. MIND provides users a single ODMG-93 compliant common data model, and a single global query language based on SQL. This makes it possible to incorporate both relational and object oriented databases into the system. Currently Oracle 7, Sybase and METU OODBMS (MOOD) have been incorporated into MIND. The main components of MIND are a global query processor, a global transaction manager, a schema integrator, interfaces to supported database systems and a user graphical interface.In MIND all local databases are encapsulated in a generic database object with a well defined single interface. This approach hides the differences between local databases from the rest of the system. The integration of export...

We present a proposal for lowering the overhead of interface contract checking for science and engineering applications. Run-time enforcement of assertions is a well-known technique for improving the quality of software; however, the performance penalty is often too high for their retention during deployment, especially for long-running applications that depend upon iterative operations. With an efficient adaptive approach the benefits of run-time checking can continue to accrue with minimal overhead. Examples from scientific software interfaces being developed in the high performance computing research community will be used to measure the efficiency and effectiveness of this approach.

In this paper, we present, Active Surroundings, a group-aware middleware infrastructure for ubiquitous computing environments. Our system focuses on two key issues: group-awareness and transparent application reconfiguration. To achieve these goals, Active Surroundings ...

A component-based software system (CBSS) is a software system that is developed by integrating components that have been deployed independently. In the last few years, many researchers have proposed metrics to evaluate CBSS attributes. However, the practical use of these metrics can be difficult. For example, some of the metrics have concepts that either overlap or are not well defined, which could hinder their implementation. The aim of this study is to understand, classify and analyze existing research in component-based metrics, focusing on approaches and elements that are used to evaluate the quality of CBSS and its components from a component consumer's point of view. This paper presents a systematic mapping study of several metrics that were proposed to measure the quality of CBSS and its components. We found 17 proposals that could be applied to evaluate CBSSs, while 14 proposals could be applied to evaluate individual components in isolation. Various elements of the software components that were measured are reviewed and discussed. Only a few of the proposed metrics are soundly defined. The quality assessment of the primary studies detected many limitations and suggested guidelines for possibilities for improving and increasing the acceptance of metrics. However, it remains a challenge to characterize and evaluate a CBSS and its components quantitatively. For this reason, much effort must be made to achieve a better evaluation approach in the future.

CORBA is a standard proposed by the Object Management Group (OMG) in order to promote interoperability between distributed object systems. CORBA provides a programming-language neutral Interface Definition Language (IDL) that describes the syntactic aspects of services supported by remote objects. However, CORBA IDL does not provide any means to specify the behavior of objects in an abstract and formal way. In the current practice, behavioral specification is provided either in plain English, or directly in the programming language chosen for the implementation. We propose to extend the CORBA interface definition of distributed objects by a behavioral specification based on high level Petri nets. We detail at the syntactic and semantic level how this formalism supports the features of the CORBA object model. We present a realistic case study to demonstrate our approach. Our technique allows specifying in an abstract, concise and precise way the behavior of CORBA servers, including internal concurrency and synchronization. As the behavioral specification is fully executable, this approach also enables to prototype and test a distributed object system as soon as the behaviors of individual objects have been defined. The paper discusses several implementation issues of the tool that supports the edition of models and their interactive excution. The high level of formality of the chosen formalism allows for mathematical analysis of behavioral specifications.

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.

This paper is focused on the performance analysis, comparison and optimization of distributed object middleware for Java 2: RMI (Remote Method Invocation), CORBA IDL (Interface Definition Language) and RMI-IIOP (Remote Method Invocation on Internet Inter-ORB Protocol). The paper presents the following contributions to the research on distributed object performance. First, a detailed performance analysis is provided with the comparison. These results help to understand how the models perform. Second, an overhead analysis has been done, which explains why there are differences in peRformance. Third, optimizations and improved performance for RMI-IIOP and CORBA IDL are presented. These show considerably better performance in all areas compared to the original versions.

Recent developments of global computing systems such as Ninf, NetSolve and Globus have opened up the opportunites for providing high-performance computing services over wide-area networks. However, most research focused on the individual architectural aspects of the system, or application deployment examples, instead of the necessary charactersistics such systems should intrinsically satisfy, nor how such systems relate with each other. Our comparative study performs deployment of example applications of network-based libraries using Ninf, NetSolve, and CORBA systems. There, we discover that dedicated systems for global computing such as Ninf and NetSolve have management, progammability, and in does not suffer performance disadvantages over more generic distributed computing capabilities provided by CORBA. Such results indicate the advantage of dedicated global computing systems over general systems, stemming further basic research is necessary across multiple systems to identify the ideal software architectures for global computing.

Patterns, middlewares and frameworks have been used for decades in software architecture to address the main problems encountered today by the MPSoC and NoC communities: heterogeneity of languages, programming models, simulation/execution environments, interaction semantics and communication protocols. A complete semantics mapping of CORBA Interface Definition Language (IDL) and General Inter-ORB Protocol (GIOP) on the Open Core Protocol (OCP) has been investigated for hardware components. This mapping is generic, highly configurable and illustrated through our target application: Software Defined Radio.

We investigate the trade off between investing effort in improving the features of a research environment that increases productivity and investing such effort in actually conducting the research experiments using a less elaborated, albeit sufficiently operational environment. The study case presented is an interactive genetic algorithm environment we created to evolve user interfaces designs. We present three productivity improvements integrated in our environment and examine whether on the long run the research productivity can be in fact increased by spending development time on enhancing the research tools rather than on performing the research itself. The three improvements are the integration of the entire system interface into a main wxPython window, the addition of a runs manager for setting up multiple experiments, and the creation of a data manager for effective exploration and visualization of data produced in the experiment runs. We also discuss several guidelines for transitioning a research environment such as ours from a researcher's tool to an end-user's tool.

Construction of the first Gemini 8-m telescope is well underway. The software that provides the user interface and high-level control of the observatory, the Observatory Control System (OCS), is also proceeding on track. The OCS provides tools that assist the astronomer from the proposal submission phase through planning, observation execution, and data review. A capable and flexible software infrastructure is required to support this comprehensive approach. New software technologies and industry standards have played a large part in the implementation of this infrastructure. For instance, the use of CORBA has provided many benefits in the software system including object distribution, an interface definition language, and implementation language independence. In this paper we describe the infrastructure of the Observatory Control System that supports observation planning and execution. Important software decisions and interfaces that allow Internet access and the ability to substitute alternate implementations easily are discussed as a model for other similar projects.

Recent days, the systems based on mobile agents have attracted the attention of many researchers in different areas, because of the autonomic and pro-active aspects of the agent, as well as its adaptive and dynamic behaviors in solving complex problems. However, the mobility of these entities needs to be secured against multiple vulnerabilities that present a real obstacle to its wide expansion. When the mobile agent is migrating from one node to another over the network, it is difficult to guarantee that it will be executed safely and correctly on the hosting platform, neither that it will not encounter in its way malicious entities that try to harm it. In this paper, we try to address these security issues by introducing an approach based on cryptographic mechanisms. This approach involves an Identity-Based Key Agreement Protocol to get a session key and ensure authentication, an Advanced Standard Encryption (AES) for the confidentiality of data exchanged, as well as a Binary Serialization to get an easy and persistent portability of the agent across the network.

In this article we examine the augmentation of application interfaces with enhanced specifications that include sequencing constraints called protocols. Protocols make explicit the relationship between messages (methods) supported by the application. These relationships are usually only given implicitly, either in the code or in textual comments. We define notions of interface compatibility based upon protocols and show how compatibility can be checked, discovering a class of errors that cannot be discovered via the type system alone. We then define software adaptors that can be used to bridge the difference between applications that have functionally compatible but type-and protocol-incompatible interfaces. We discuss what it means for an adaptor to be well formed. Leveraging the information provided by protocols, we show how adaptors can be automatically generated from a high-level description, called an interface mapping.

This article describes an approach to the development of highly reliable and reusable CORBA applications. Interface description language (IDL) specifications are extended with LOTOS specifications of the functional and dynamic behavior of the interface operations. These extended interface specifications are compiled into header files and stub code using standard CORBA mechanisms. The LOTOS part can be compiled into C-code yielding

METU INteroperable Database System (MIND) is a multidatabase system that aims at achieving interoperability among heterogeneous, federated DBMSs. MIND architecture if based on OMG distributed object management model. It is implemented on top of a CORBA compliant ORB, namely, ObjectBroker. MIND provides users a single ODMG-93 compliant common data model, and a single global query language based on SQL. This makes it possible to incorporate both relational and object oriented databases into the system. Currently Oracle 7, Sybase and METU OODBMS (MOOD) have been incorporated into MIND. The main components of MIND are a global query processor, a global transaction manager, a schema integrator, interfaces to supported database systems and a user graphical interface.In MIND all local databases are encapsulated in a generic database object with a well defined single interface. This approach hides the differences between local databases from the rest of the system. The integration of export...

This paper describes a proposal for typing the behavior of objects in component models. Most component models, CORBA in particular, do not offer any support for expressing behavioral properties of objects beyond the "static" information provided by IDLs. We build on the works by Honda et al. [6] and Gay and Hole [5] to show how session types can be effectively used for describing protocols, extending the information currently provided by object interfaces. We show how session types not only allow high level specifications of complex object interactions, but also allow the definition of powerful interoperability tests at the protocol level, namely compatibility and substitutability of objects

Submitted for the DPP05 Meeting of The American Physical Society Modernization and Componentization of Fusion Modules for Future Integrated Modeling OVSEI VOLBERG, SVETA SHASHARINA, JOHAN CARLSSON, Tech-X Corporation-We discuss the development of the Framework for Modernization and Componentization of Fusion Modules, which contains a set of tools, standards and techniques for modernization of modules extracted from established fusion codes with subsequent conversion of these modules to components in accordance with modern software engineering practices. The National Transport Code Collaboration (NTCC) project created a community-owned library of modules for integrated fusion modeling. The standards enforced for these modules and strict review process make this library a valuable asset for plasma simulation. Component based approach addresses the modeling of complex, mutually interacting, computationally intensive systems via its reformulation as a problem of coupling between subsystems designated as components. A certain challenge in developing such components from legacy codes could be addressed by Common Component Architecture (CCA) tools. We report on the results of our application of CCA tools to the development of components from two NTCC modules, GLF23 and MMM95, and coupling them with another component made from the new nonlinear solver. We also report on the comparison of the NTCC standards with the standards of several community-wide projects for integrated modeling in the other areas of science.

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. In this paper, we present an extensible toolset for easing the development of architecture-based software systems. This toolset is not bound to a specific ADL, but rather uses a grammar description mechanism to accept various input languages, e.g. ADLs, Interface Definition Languages (IDLs), Domain Specific Languages (DSLs). Moreover, it can easily be extended to implement many different features, such as behavioral analysis, code generation, deployment, etc. Its extensibility is obtained by designing its core functionalities using fine-grained components that implement flexible design patterns. Experiments are presented to illustrate both the functionalities implemented by the toolset and the way it can be extended.

We present a technique for analysing structural constraints on data aggregates in high-level languages. Our technique includes a formal constraint language and a dataitow algorithm for automatically checking equality constraints. The constraint language is used to augment the type information on program interfaces. For extanple, one can specify that a procedure must return aggregates A and B where each element in aggregate A points to some element in aggregate B, and that parameter C will have the properties of a rooted tree both on input and output. Our dataflow algorithm tracks the constraints which must apply at eac.h statement in order for the procedure to satisfy its interface, and detects invalid programs which fail to satisfy the constraints on their interfaces. We apply our technique to several examples. Our work is motivated by the requirements for expressive interface definition languages for distributed systems, and by the desire to mechanically check program modules against their interfaces. Our analysis techniques also yield information which may enable compilers mad stub generators to produce better implementations.

I would like to thank my supervisor, Dr. Mudawwar, for inspiring and advising me in all the phases of the thesis. Also, I would like to thank all the Computer Science Department’s Professors for the knowledge they conveyed to me and for their helpful critiques. I thank Bjarne Stroustrup for the helpful discussions and providing me with useful information via email. Many thanks to Luca Cardelli for the long discussions we had by email. I learnt a lot from his valuable published papers. My Special thanks to my parents, Iman and Mohamed for their endurance and patience and for encouraging me. Thanks to my friend Doha for giving me the spirit to continue. Thanks to all my colleagues in ACS for their encouragement. Thanks to Dr. Mona Kaddah for her understanding and cooperation, and special thanks to Dr. Sherif El Kassas for the long discussions we had on subtyping and for providing me with useful URLs on compilers. Finally, many thanks to everyone supported me and endured my moments of ...

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 coputing. In the scientific computing context, component models also promote collaboration using independently developed software, thereby allowing particular individals or groups to focus on the aspects of greatest interest to them. The CCA supports parallel and distributed coputing 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 ovehead 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 cobustion resea...

CORBA is a standard proposed by the Object Management Group (OMG) in order to promote interoperability between distributed object systems. CORBA provides a programming-language neutral Interface Definition Language (IDL) that describes the syntactic aspects of services supported by remote objects. However, CORBA IDL does not provide any means to specify the behavior of objects in an abstract and formal way. In the current practice, behavioral specification is provided either in plain English, or directly in the programming language chosen for the implementation. We propose to extend the CORBA interface definition of distributed objects by a behavioral specification based on high level Petri nets. We detail at the syntactic and semantic level how this formalism supports the features of the CORBA object model. We present a realistic case study to demonstrate our approach. Our technique allows specifying in an abstract, concise and precise way the behavior of CORBA servers, including internal concurrency and synchronization. As the behavioral specification is fully executable, this approach also enables to prototype and test a distributed object system as soon as the behaviors of individual objects have been defined. The paper discusses several implementation issues of the tool that supports the edition of models and their interactive excution. The high level of formality of the chosen formalism allows for mathematical analysis of behavioral specifications.

This study presents an in-depth analysis of the performance of Software Communications Architecture (SCA) component-based waveform applications in terms of inter-component communications. The main limitation with SCA, in the context of embedded systems, is the additional cost introduced by the use of Object Request Broker (ORB) middleware. The ORB middleware handles the interaction between components and objects in SCA distributed environment. This interaction should be highly efficient, due to the real time nature of SCA systems and transparent to the application programmer. Approach: We can achieve high efficiency in SCA systems by enhancing the Inter-Process Communications (IPC) mechanisms in Operating systems (OS) micro kernels, while we achieve transparency through Interface Definition Language (IDL). Different encoding mechanisms like "External Data Representation (XDR), Network Data Representation (NDR) and Common Data Representation (CDR) facilitate inter-component communication transparently and efficiently". Marshalling procedures format data from the local machine representation to common network representations. A most common encoding mechanism for Common Object Request Broker Architecture (CORBA) systems is CDR representation. Measurements have been performed with ORBExpress DSP as a CORBA distribution and Open Source SCA Implementation Embedded (OSSIE) for SCA implementation. In order to perform these measurements we proposed two metrics for profiling the ORB that are invocation and marshalling. In addition, we propose three elements of data types to evaluate the performance of ORB middleware that are, Basic, Array and Sequence data types. Results: The CORBA bus is really the part, which brings an overhead to the SCA radio systems. This overhead is due to method invocations that have been carried out by ORB middleware. Conclusion: Performance benchmarks of ORBExpress DSP middleware show that, although using CORBA for inter-component communications introduces delays and overheads, the overall effect can be reduced by sending packets of data instead of basic data type elements.

Abstract. Generic programming is a paradigm for systematic design and clas-sification of software components for optimal reuse. It has been the guiding methodology behind the design of the C++ Standard Template Library and nu-merous other C++ libraries. Generic ...

VCE/ OSE' offers a comprehensive RPC-based solution fair the development of open distributed applications across network of heterogeneous multiple-vendor machines. However, o e n simple DCE applications may have a rather complicated structure, requiring good understanding of the elaborate DCE technology. In this paper, we examine the DCE application development path, and introduce two new tools, idlgen and gluegen (collectively called MakeDCE), u7hich he& to separate applicalion logic from DCE aspects. The development ojp simple DCE applications using idlgen arid gluegen remains a rather simple task, requiring very little knowledge of DCE, and of the DCE toolkit. These tools are particularly useful for splitting existing monolithic programs into clients and servers, with almost no change to the original application code. Complex IICE appIica<tions are supported as well, even though the splitting approach may not be fully applicable.

PSL is a framework for describing dynamic and architectural properties of open systems. PSL extends established interface-based tactics for describing the functional properties of open systems to the realm of protocol description. PSL specifications consist of logical and temporal rules relating situations, each of which describes potential states with respect to instances of interfaces, their attributes, and the issuance and reception of events. PSL accommodates refinement and extensibility of specifications along the three dimensions of interfaces, situations, and orderings. A specialized form, PSL/IDL describes protocols in CORBA systems. 1 Introduction An open system, in the technical sense [28, 1, 63] (not necessarily the commercial sense) is encapsulated, reactive, spatially extensible, and temporally extensible: Encapsulation. An open system is composed of possibly many components, each described by one or more public interfaces along with an otherwise inaccessible implementa...

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

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.

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.

We propose a model for building object-oriented applications based on the composition of application slices or fragments that provide their own overlapping definitions or expectations of the same domain objects. Different slices may implement different functional or implementation concerns, or embody different access rights and privileges to the same domain objects. We call such slices views and we recognize that the behavior embodied in views may be abstracted into generic class-like algebraic structures called viewpoints, from which views for specific domain classes may be generated. In this paper, we are interested in the problem of distributing view-based applications when different sites access different slices of the same domain objects. Specifically, we are interested in the problem of offering different views of the same domain objects to different client programs in a CORBA-like environment. We first discuss the principles behind view programming, and then explore ways in which objects with views may be distributed in a way that supports different sets of functionalities to different client programs. An interesting application of view programming in a distributed context is the selective duplication of object slices.

Generic typing is a very desirable and useful language feature; in particular it is a welcome feature in the teaching of data structures in CS2. Hence its introduction in Java in 1.5 version was indeed a welcome addition to one of the most popular languages of current use in academia. On initial inspection the definition and use of generics is straightforward, but on closer inspection generic types do not interact smoothly with the object orientation paradigm. Wilcards is a Java 1.5 mechanism introduced to deal with generics and Object Orientation, in particular with subtypes. This papers presents the use of wildcards and provides guidelines in teaching its use in the design of generic classes and generic methods.

We investigate the trade off between investing effort in improving the features of a research environment that increases productivity and investing such effort in actually conducting the research experiments using a less elaborated, albeit sufficiently operational environment. The study case presented is an interactive genetic algorithm environment we created to evolve user interfaces designs. We present three productivity improvements integrated in our environment and examine whether on the long run the research productivity can be in fact increased by spending development time on enhancing the research tools rather than on performing the research itself. The three improvements are the integration of the entire system interface into a main wxPython window, the addition of a runs manager for setting up multiple experiments, and the creation of a data manager for effective exploration and visualization of data produced in the experiment runs. We also discuss several guidelines for transitioning a research environment such as ours from a researcher's tool to an end-user's tool.

Object oriented programming and design patterns form a very good framework for implementing a computational algebra system. Object oriented programming offers different kinds of mechanisms for obtaining high level of genericity; and these are also mechanisms for reusing. The need to represent and work with abstract algebraic structures implies the need for genericity. This could be achieved by using parametric polymorphism or type polymorphism. We analyze in this article the suitability of using parametric polymorphism, in an object-oriented programming context, for implementation of algebraic structures, showing some advantages but also some problems. The implementation issues are discussed for the particular case of the square matrices of a certain order. The analysis emphasizes also general advantages of using parametric types-such as type safety, but also some constrains forced by them.

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) in order to promote interoperability between distributed object systems. CORBA provides a programming-language neutral Interface Definition Language (IDL) that describes the syntactic aspects of services supported by remote objects. However, CORBA IDL does not provide any means to specify the behavior of objects in an abstract and formal way. In the current practice, behavioral specification is provided either in plain English, or directly in the programming language chosen for the implementation. We propose to extend the CORBA interface definition of distributed objects by a behavioral specification based on high level Petri nets. We detail at the syntactic and semantic level how this formalism supports the features of the CORBA object model. We present a realistic case study to demonstrate our approach. Our technique allows specifying in an abstract, concise and precise way the behavior of CORBA servers, including internal concurrency and synchronization. As the behavioral specification is fully executable, this approach also enables to prototype and test a distributed object system as soon as the behaviors of individual objects have been defined. The paper discusses several implementation issues of the tool that supports the edition of models and their interactive excution. The high level of formality of the chosen formalism allows for mathematical analysis of behavioral specifications.

The advantages of object-oriented (OO) programming are well-known. Nevertheless, distributed OO middleware systems (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 overcomplex, proprietary or incompatible with current WWW development practices. Recognizing these difficulties more WWW-friendly proposals based on XML are starting to appear. This paper describes a simple OOM system that uses RDF as its Interface Definition Language (IDL) and HTTP as its RPC protocol. This approach provides most of the advantages of object-orientation while mantaining full compatibility with the existing WWW infrastructure.

METU INteroperable Database System (MIND) is a multidatabase system that achieves interoperability among heterogeneous, federated DBMSs. MIND architecture is based on OMG distributed object management model. It is implemented on top of a CORBA compliant ORB, namely, ObjectBroker. MIND provides users a single ODMG-93 compliant common data model, and a single global query language based on SQL. This makes it possible to incorporate both relational and Object oriented databases into the system. Currently Oracle7, Sybase and METU OODBMS (MOOD) has been integrated to MIND. The main components of MIND are a global query processor, a global transaction manager, a schema integrator, interfaces to supported database systems and a graphical interface. In MIND all local databases are encapsulated in a generic database object with a well de ned single interface. This approach hides the di erences between local databases from the rest of the system. The integration of export schemas is currently performed manually by using an object de nition language (ODL) which is based on OMG's interface de nition language. The DBA builds the integrated schema as a view over export schemas. The functionalities of ODL allow selection and restructuring of schema elements from existing local schemas. MIND global query optimizer aims at maximizing the parallel execution of the subqueries. Through MIND global transaction manager, the serializable execution of the global transactions are provided.