Academia.edu no longer supports Internet Explorer.
To browse Academia.edu and the wider internet faster and more securely, please take a few seconds to upgrade your browser.
2003, IEEE Transactions on Software Engineering
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.
The Computer …, 2001
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. 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, aimed at the automated checking of protocol interoperability between CORBA objects in open component-based environments. In addition, some advantages and disadvantages of our proposal are discussed, as well as some of the practical limitations encountered when trying to implement and use this sort of IDL extensions in open systems.
2000
Traditional IDLs were defined for describing the services that objects offer, but not those services they require from other objects, nor the partial ordering in which they expect their methods to be used. 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, aimed towards the automated checking of protocol interoperability between CORBA objects in open component-based environments. Furthermore, some advantages and disadvantages of our proposal are discussed, as well as some of the practical limitations encountered when trying to implement and use this sort of IDL extensions in open systems.
Common Object Request Broker Architecture (CORBA) is a standard for hybrid applications that is designed and supported by Object Management Group (OMG). This standard defines protocols and Relational Data Model Objects / Services which can be connected into heterogeneous software (written in different languages). So we can use CORBA to share the distributed object platform, without worrying about where they are located or who has designed them. CORBA can package the codes (in some programming languages) and add the packaging information, such as the ability to execute the codes and how to implement them. So this package or object code can execute some other programs or CORBA objects that they are in the network. CORBA uses a relational language called Interface Definition Language (IDL) to specify the interface of the classes and objects. The IDL definitions can be connected to the written codes in some popular languages such as Java, C++, Ada, and Smalltalk. To know the functionality and behaviors of objects and their interfaces, we need to abstractly model their definitions and specifications. Models are in different types (e.g., physical, mathematical, numerical, software, etc.) and have a variety of critical applications in all areas of science and technology. In other words, a summary of the facts is known as the models. Therefore, it could be mentioned that there are two objectives for the model including exploration and specification, the modeling process considers either or both of them. One of the main approaches to the modeling process is based on state-transition systems such as Kripke structures, Petri nets, and Büchi automata. The paper's ultimate goal is to provide a method to model the formal behavioral specifications of CORBA objects. In this paper, we use the formalism of Büchi automata as the operational semantics for the behavior of CORBA based objects. For this purpose, two different approaches that include using Petri nets as basic operational models and translating them to Büchi automata and direct using of Büchi automata are considered. Also, we show the applicability of our suggested modeling approaches by considering them in some case studies. As result, a Büchi automaton is a better model to verify a system.
ACM SIGPLAN Notices, 2000
CORBA is now established as one of the main contenders in object-oriented middleware. Beyond the definition of this standard for distributed object systems, the Object Management Group (OMG) has specified several object services (Common Object Services, COS) that should foster the interoperability of distributed applications. Based on experiment, the goal of this paper is to show that the OMG's style of specification of the CORBA services is not suited to guarantee that implementers will produce interoperable and substitutable implementations. To illustrate our point, we give an account of an experiment based upon the formal specification of one COS, namely the CORBA Event Service. This formal specification highlights several ambiguities and under-specifications in the OMG document. We then test several commercial and public domain implementations of the CORBA Event Service, in order to assess how the implementers have dealt with these under-specifications. We show that the choi...
Proceedings of the 15th …, 2000
CORBA is now established as one of the main contenders in object-oriented middleware. Beyond the definition of this standard for distributed object systems, the Object Management Group (OMG) has specified several object services (Common Object Services, COS) that should foster the interoperability of distributed applications. Based on experiment, the goal of this paper is to show that the OMG's style of specification of the CORBA services is not suited to guarantee that implementers will produce interoperable and substitutable implementations. To illustrate our point, we give an account of an experiment based upon the formal specification of one COS, namely the CORBA Event Service. This formal specification highlights several ambiguities and under-specifications in the OMG document. We then test several commercial and public domain implementations of the CORBA Event Service, in order to assess how the implementers have dealt with these underspecifications. We show that the choices made by the implementers lead to incompatible implementations. We finally suggest a solution to overcome the problem of specification of object services, which satisfies the views of both implementers and users. Specifically, we suggest that the specification of such services be made using a formal description technique, and that implementers be provided with test cases derived from the formal specification.
Proceedings of the International Symposium on Distributed Objects and Applications, 1999
We present a CASE tool based on an object-oriented Petri nets dialect called Cooperative Objects, dedicated to the design of CORBA systems. The notation is used for the formal behavioural specification of objects, and its associated tool puts an emphasis on supporting the design life cycle of CORBA systems. The tool offers enhanced interactivity to present the results derived from the capabilities of verification, validation and distributed interpretation provided by Cooperative Objects.
Proceedings of the 38th annual on Southeast regional conference, 2000
Component-based development (CBD) has gained in popularity in recent years due to its promise of building applications from reusable and plug-and-playable software components. An ultimate goal of CBD is making plug-and-playable software development not only feasible, but also easy. In order to achieve this goal, techniques for clearly specifying functionality of components and for determining the degree to which two components can interoperate are needed. In this paper, we briefly review the ICM (Interoperable Component Model), and enhance the model by adding a formalism and providing a testing framework based on the formal specification. Each component is accompanied with an interface that describes the component's type and behavior. The component interactions are specified in message protocols. With the specification model, we will define the behavior type conformance rules on components.
Journal of Systems Integration, 1998
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
Concurrency: Practice and …, 2000
+33 5 61 63 35 88
2002
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. 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
1999
In an open component market place, interface description languages (IDLs), such as corba's, provide for the consumer only a weak guarantee (concerning type signatures) that a software service will work in a particular context as anticipated. Stronger guarantees, regarding the intended semantics of the service, would help, especially if formalized in a language that allowed effective, automatic and static checking of compatibility between the server and the client's service descriptions
ECOOP'99Object-Oriented Programming, 1999
We propose to extend the CORBA interface definition of distributed objects by a behavioral specification based on high level Petri nets. This 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 early prototyping and testing of a distributed object system as soon as the behaviors of individual objects have been defined. The paper discusses several implementation issues of the multithreaded, distributed interpreter built for that purpose. The high level of formality of the chosen formalism allows for mathematical analysis of behavioral specifications.
ACM Transactions on Software Engineering and Methodology, 2003
The design of distributed applications in a CORBA based environment can be carried out by means of an incremental approach, which starts from the specification and leads to the high level architectural design. This paper discusses a methodology to transform a formal specification written in TRIO into a high level design document written in an extension of TRIO, named TRIO/CORBA (TC). The TC language is suited to formally describe the high level architecture of a CORBA based application. As a result, designers are offered with highlevel concepts that precisely define the architectural elements of an application. Furthermore, TC offers mechanisms to extend its base semantics, and can be adapted to future developments and enhancements in the CORBA standard. The methodology and the associated language are presented by means of a case study derived from a real Supervision and Control System.
Electronic Notes in Theoretical Computer Science, 2003
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. 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
Loading Preview
Sorry, preview is currently unavailable. You can download the paper by clicking the button above.