Search

This paper proposes automatic generation method of proxy client code to automation of web service selection process through a monitoring agent. The technique of this paper help service consumer to provide source code of proxy client as it bring an attribute value of specific element of WSDL document using template rule. Namely, a XSLT script file provide code frame of dynamic invocation interface model. The automatic code generation technique need to solving starvation status of selection architecture. It is required to creating request HTTP message for every service on the result of search. The created proxy client program code generate dummy message about services. The proposed client code generation method show us a possibility of application in the automatic generation programming domain.

Asynchronous invocations are needed in the context of distributed object frameworks to prevent clients from blocking during remote invocations. Popular Web service frameworks offer only synchronous invocations (over HTTP). An alternative is messaging protocols but these implement a different communication paradigm. When client asynchrony is not supported, client developers have to build asynchronous invocations on top of the synchronous invocation facility. But this is tedious, error-prone, and might result in different remote invocation styles used within the same application. We present a number of patterns for asynchronous invocations and explain how these patterns can be used to build asynchronous invocation facilities for Web service frameworks. We exemplify this approach by explaining the design and implementation of an asynchronous invocation framework for Apache Axis.

CORBA is becoming one of the most important middleware for supporting object-oriented and client/server paradigms in distributed computing systems. However, application systems based on CORBA are still scarce to date. One reason is that only few CORBA object services have been developed. To have a new CORBA application, a programmer must make the effort to design a program with a CORBA interface. In our previous work [Proceedings of the Sixth IEEE Computer Society Workshop on Future Trends of Distributed Computing Systems (1997) 2], a re-engineering approach was proposed to convert RPC-based programs into CORBA objects. This has successfully increased the development of CORBA applications. However, the source code is required in this approach. In many cases, software designers cannot acquire the source code. This prevents adapting existing PC software applications, particularly for Windows applications. Our study addresses this problem. A graphic factory temperature monitor system, which integrates MS-Excel under MS-Windows, was implemented to demonstrate the feasibility of our approach.

In the framework of distributed object systems, this paper presents the concepts and an implementation of an overlapping mechanism between communication and computation. This mechanism allows to decrease the execution time of a remote method invocation with parameters of large size. Its implementation and related experiments in the C++//language running on top of GLOBUS and NEXUS are described.

Remote method invocation and RMI over IIOP relieve developers of many Corba complexities. Companies looking for a simpler way to achieve interoperability should strongly consider these models.

Object-oriented distributed real-time applications require enforcement of end-to-end timing constraints on service requests from clients to servers. Thus, timing aspects should be integrated and handled by CORBA which is a standard to support distributed object-oriented applications. In spite of the release of real-time CORBA (RT-CORBA) specification, a few vendors have ported their ORBs (Object Request Brokers) to real-time operating systems. In this paper we analyze existing RT-CORBA implementations, and we propose a framework that integrates the main components (scheduling, real-time communication, end-to-end quality of service providing, etc.) necessary for implementation of RT-CORBA to support static and dynamic real-time applications.

The distributed and heterogeneous natures of todays computing systems require a middleware Infrastructure capable of supporting a three-tier computing architecture. Business logic can be built, or existing applications encapsulated, Into middle tier components that Interact with end users via standard Interfaces such as web browsers and standard GUI desktops, and back-end data repositories. The Common Object Request Broker Architecture, or CORBA for short, is a specification produced by the Object Management Group (OMG) that addresses Interoperability in distributed heterogeneous environments. The CORBA standard represents industry consensus from more than 800 companies. It is an open, vendor-independent architecture and Infrastructure that computer applications use to work together over networks. Using the standard protocol IIOP, a CORBA-based program from any vendor, on almost any computer, operating system, programming language, and network, can interoperate with a CORBA-based program from the same or another vendor, on almost any other computer, operating system, programing language, and network. It defines an Object Request Broker (ORB) for transparent invocation of remote objects, as well as supporting system level Object Services and higher level Common Facilities. CORBA assumes a heterogeneous environment In which objects Implemented in different languages on different platforms can inter-operate. There are many implementations of the CORBA standard, some of them in the form of commercial products that have demonstrated strong market acceptance. This paper presents CORBA In a simple and easy to understand language. It assumes only a basic familiarity with computers and programming languages. Object Services is one of the five integral components of the Object Management Architecture (OMA) - which forms the heart of CORBA. There are several Object Services like Collection Service, Concurrency Service, Event Service, Naminty Service, Query Service, Notification Service, Time Service, Transaction Service, etc. This paper presents in a very simplified form, one of these services called as CORBA notification Service. It compares and contrasts It with the Event Service and discusses the deficiencies In Event Service and how the Notification Service resolves them. The applicability of the Notification Service in real-life scenarios Is also discussed.

Software systems use many third party libraries by invoking their APIs. A software system may potentially use an API in an inefficient manner, for example, by creating unnecessary or a large number of short-lived objects. This can cause performance degradation in terms of memory usage and latency in critical applications. In this paper we use an object invocation model based on object creation and their method invocations from different code locations. We use a framework to extract the model features from a running software system. The extracted features are then used in a clustering based mechanism to identify problematic code locations within the software system. We demonstrate our approach by analyzing Java Collection API objects in a Java-based open source editor JEdit. We have successfully identified interesting code locations and discussed their impact on software performance.

The paper presents a distributed service invocation approach for cross-organizational data-intensive web services. Our approach applies one service proxy in each organizational domain, which is responsible for service scheduling and invocation. Service Invocation across different domain is realized by the coordination of service proxies. Three performance improvement methods, which use compression, cache with consistency and two-level cache technologies, are discussed with focus. The most suitable one of them will be chosen according to different service types and invocation metadata. The structure design and implementation of service proxy is also presented succinctly. Experimental evaluations demonstrate that our approach combined with these three methods gives significant performance improvements for service invocation.

CORBA (Common Object Request Broker Architecture) provides 16 Common Object Services for distributed application development, but none of them are fault-tolerance related services. In this paper, we propose a replicated object based Fault-Tolerant Object Service (FTOS) for CORBA environment. Two fault-tolerant mechanisms are provided in FTOS including dynamic voting mechanism and object replication mechanism. The dynamic voting mechanism uses majority-voting strategy to ensure object state consistency in failure situations. The object replication mechanism can help system administrators to replicate and start-up objects easily. Our implementation provides a library according to the style of COSS. With this library, programmers can develop distributed applications with fault-tolerance capability very easily.

A distributed system is said to be fault-tolerant if it is able to provide important services despite partial failures of the computers or software objects in the system. These systems are needed to support applications such as remote access and control, virtual mobile offices and wide area collaborative systems where there are chances of failures in the network and software objects. Fault-tolerance is usually achieved by replicating the objects in the system. Traditional distributed applications constructed using Java RMI (remote method invocation) are not fault-tolerant because of the lack of support of object replication. The objective of the present work is to design a remote method invocation that supports server object replication. To provide a fault-tolerant service to the remote client objects, server objects are actively replicated. The problems associated with the method invocation in the context of active server object replication are presented and solutions are discussed and implemented. Copyright © 2001 John Wiley & Sons, Ltd.

The introduction of Java's proprietary remote method invocation (RMI) with version 1.1 of the Java Development Kit simplified the challenging task of developing distributed object-based systems. RMI provides convenient integration with Java; however, it lacks interoperability with other languages. The Object Management Group's Common Object Request Broker Architecture (CORBA), on the other hand, is a platform- and language-neutral specification for developing distributed object systems. CORBA provides services not covered by RMI, such as managing transactional safety and persistency. We use a small chat room application to describe how a programmer can combine Java RMI's ease of use with CORBA's language neutrality. We start with an implementation based on a set of distributed objects using RMI. We then adapt the example to CORBA or, more specifically, the RMI-over-IIOP (Internet inter-ORB protocol) specification developed by Sun and IBM.

This paper presents a comprehensive comparison of the architectural differences and similarities of the two most popular Java-based distributed object models: RMI and CORBA. Performance and timing issues related to the CORBA and RMI architectures are also considered. The following aspects are studied for client server applications, on Sun UltraSparcs under Solaris 2.5.1 and Pentium II under Windows NT 4.0: response time for method invocation without parameters as well as with variable number of parameters; response time for applet clients, and response time for variable number of clients requesting the same service. The goal is to provide a reference framework that supports the selection of either mechanism for the development of web-based distributed real-time applications: chat programs, interactive games, shared boards, etc.

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.

The authors describe a distributed programming model based on an object group service (OGS) and discuss various levels of group transparency and their impact on invocation overheads. Their OGS extends CORBA so that it can gather several objects inside a group and transparently handle group membership and consistent invocation of group members.

Many computer applications today require some form of distributed computing to allow different software components to communicate. Several different commercial products now exist based on the Common Object Request Broker Architecture (CORBA) of the Object Management Group. The use of such tools, however, often requires the modification of existing systems, rather than the development of new applications. The objective of this research has been to integrate the use of a CORBA tool into an existing engineering design application for the purpose of (1) evaluating the amount of re-engineering that is involved to effectively integrate distributed object computing into an existing application, and (2) evaluating the use and performance of distributed object computing in an engineering domain, which often requires the transfer of large amounts of information. The results of this work demonstrate that CORBA technology can be easily integrated into existing applications. The ease of the integration as well as the efficiency of the resulting system, however, depends upon the degree of modification that developers are willing to consider in the re-engineering process. The most transparent approach to the use of CORBA requires less modification and generally produces less efficient performance. The less transparent approach to the use of CORBA can potentially require significant system modification but produce greater performance gains. This work outlines issues that must be considered for the partitioning of functionality between the client and the server, development of an IDL interface, development of client and server-side wrappers, and support for concurrent, multi-user access. In addition, this work also provides performance and implementation comparisons of different techniques for the use of wrappers and for the transfer of large data files between the client and the server. Performance comparisons for the incorporation of concurrent access are also presented. Copyright © 1999 John Wiley & Sons, Ltd.

The integration of distributed computing and the object model leads to distributed object computing, in which objects rather than processes are distributed across multiple computers. A well-established standard for distributed object computing is the Common Object Request Broker Architecture (CORBA). Previously, you would have had to create-and enable the application to use-the components that provide such additional capabilities. Using these components requires specialized knowledge and understanding of problems outside the application domain. With the advent of interceptors-non-application components that can alter application behavior-you can enhance CORBA applications at runtime with components whose operation is transparent to both the application and the CORBA framework, modifying application behavior without modifying the application or the CORBA framework.

Distributed real-time applications have presented the need to extend the Object Management Group‘s Common Object Request Broker Architecture (CORBA) standard to support real-time. This paper describes a Dynamic Real-Time CORBA system, which supports the expression and enforcement of end-to-end timing constraints as an extension to a commercial CORBA system. The paper also describes performance tests that demonstrate the system‘s ability to enforce expressed timing constraints.

Now a day’s usage of mobile phones is higher when compared with the usage of laptops and desktops. Researchers are interested in invocation of functionalities to the user with minimal over head by using dynamic invocation and with language interoperability approach. Even though various traditional approaches introduced in the traditional mechanisms those are not optimum and used for only few simple query or minimal parameters. For dynamic invocation we introduced a novel Proxy based approach and for the language interoperability we introduced WSDL files.

Software systems use several third party libraries via their available interfaces popularly known as the application programming interface (API). The runtime usage of the API in an object-oriented software system can be defined by several characteristics including the type and number of API objects created, the methods invoked on those objects, and the source code locations from where the objects were created or invoked during their lifetime. These characteristics can be used to identify the source code locations exhibiting different types of runtime behavior which can be used for program comprehension, debugging, performance monitoring and fault detection. In this paper, we define object invocation model based on above-mentioned characteristics. We also propose an implementation framework that can be used to extract key model parameters from any source code. The Java Collections API is one of the most widely used Java APIs. We demonstrate effectiveness of our proposed approach by analyzing object invocation model for Java Collection API in a large open source project.

The World Wide Web and Distributed Object-Oriented Systems (e.g. CORBA) provide future infrastructures for distributed client/server computing. This paper presents our work to provide the integration of CORBA objects into the Web: first, to describe Web services using object-oriented technologies and second to access any Information System developed with CORBA from the Web. We present a new Shared Information Space model with the following issues: Object Orientation Design, Distributed and Heterogeneous Environment, Users' Point of View, Object Invocation and Navigation. Navigation over SIS is supported by CorbaWeb, a Generic Object Navigator, composed of metascripts allowing the access, the representation and the invocation of any CORBA object from the Web. These operations are achieved by scripts written in CorbaScript, an interpreted scripting language which can dynamically invoke any CORBA objects.

Distributed computing has made significant advances in the past few years as witnessed by the release of OSF's Distributed Computing Environment (DCE) and the adoption of a set of specifications for distributed object computing by the Object Management Group (OMG). In this report, we discuss OMG's work in distributed computing based on object technology. We attempt to provide a comprehensive coverage of OMG's technology, including an overview of Object Management Architecture, the rationale, behind OMG's work, a technical tour of CORBA, and an overview of Object Services and Common Facilities. A technical comparison between DCE and CORBA is provided. User perspective and the future potential of OMG's technology are discussed in the conclusion.

The use of computer systems have been widely used in such applications, scientific, manufacturing and business. The main idea of distributed computing systems is to use a client-server architecture in combination with remote method invocation. The invocation of these methods is to send data from a client to a server for processing and then the server returns data to the client for presentation. In general, distributed platforms Java-RMI, CORBA and Web Services provide a range of methods to communicate with distributed objects on remote computers. This paper presents a comparative study (measurement of processor usage, memory, packets on the network, etc.) Between CORBA and Web Services, implementing two distributed services, a basic arithmetic operations and sending strings.

Asynchronous invocations are needed in the context of distributed object frameworks to prevent clients from blocking during remote invocations. Popular Web Service frameworks offer only synchronous invocations (over HTTP). When a client with asynchronous invocation of Web Service is not supported, client developers have to build asynchronous invocations on top of the synchronous invocation facility. But this is tedious, error-prone, and might result in different remote invocation styles used within the same application. Current autonomic computing application uses synchronous Web Service to manage their resources. In this paper we propose autonomic system by using Design Patterns for Web Service, which is amalgamation of fire and forget, chain of responsibility and Case based reasoning Design Patterns. The system will provide synchronous and asynchronous paradigm based on demand of client. By using our proposed Adaptive Design Pattern for invocation of Web Services previous Web Service systems will update their resources based on client request. Our proposed system satisfies the properties of autonomic system. The pattern is described using a java-like notation for the classes and interfaces. A simple UML class and Sequence diagrams are depicted.

Invocations are widely used by many web applications, but have been found to be a common source of errors. This paper presents a new technique that can statically verify that an invocation's set of argument names, types, and request method match the constraints of a target interface. An empirical evaluation of the technique shows that it is successful at identifying previously unknown errors in web applications.

In the previous chapter, we built our functional technical knowledge in SharePoint 2010 development by showing how we can connect to external systems directly from within SharePoint. This technique will become helpful in our blended solution chapters later in the book.

Existing object databases allow the behaviour of an object to be defined in terms of methods declared by types. Such methods provide modular access to data fields and other computational functionality. Usually, the type of an object is fixed and therefore changes to its behaviour involves schema evolution. Consequently, dynamic configurations of object behaviour are generally not supported. We define the notion of role-based object behaviour and show how we integrated it into an existing object database extended with a notion of collections to support object classification and role modelling. We present a metamodel that enables specific services to be associated with objects based on collection membership and show how such a model supports flexible runtime configuration of loosely coupled services. We further outline how this role-driven service invocation mechanism might be applied in different application scenarios.

Systems based on the service-oriented architecture (SOA) paradigm must be able to bind to arbitrary Web services at runtime. However, current service frameworks are predominantly used through precompiled service-access components, which are invariably hard-wired to a specific service provider. The Dynamic and Asynchronous Invocation of Services framework is a message-based service framework that supports SOA implementation, allowing dynamic invocation of SOAP/WSDL-based and RESTful services. It abstracts from the target service's internals, decoupling clients from the services they use.

The Common Object Request Broker Architecture (CORBA) from the Object Management Group has been the most influential standard in the OO world and one of the principal steps in the industry's move to component-based development. The author gives us a preview of CORBA 3, the next step in the technology.

Almost every application requires some means of keeping data across program runs. Most applications use a file or database for the storage or persistence of data. However, databases are not typically used to store objects, particularly Java objects. On the other hand, flat files alone do not cope well with object structure. What is required is some means to preserve the state of a Java object so that it may be easily stored and subsequently restored to its original state.

Typically, objects are monolithic entities with a fixed interface. To increase the flexibility in this area, this paper presents first-class object sets as a language construct. An object set offers an interface which is a disjoint union of the interfaces of its member objects. It may also be used for a special kind of method invocation involving multipleobjects in a dynamic lookup process. With support for feature access and late-bound method calls object sets are similar to ordinary objects, only more flexible. The approach is made precise by means of a small calculus, and the soundness of its type system is shown by a mechanically checked proof in Coq.

The problems of finding objects in large and wide-area networks where objects may change their location in volatile memory as well as on stable storage are presented. The authors discuss possible solutions and describe those adopted in the Hermes system (a corporate wide, real life office application). They have designed and developed a location-independent-invocation (LII) mechanism that combines finding with invocation, using temporal location information. The mechanism also updates the system's knowledge of an object's location as a side-effect of invocation and object migration. Assumptions about object mobility indicate that objects are likely to be found within a few propagations of an invocation. If they cannot be found in this way, stable-storage and name services are used to locate the object. The major contribution of this work is to show how LII can be achieved in a large and dynamic environment in which objects are supported by neither are operating system nor the programming language. >

Object mobility is the basis for highly dynamic distributed applications. This paper presents the design and implementation of mobile objects on the basis of the CORBA standard. Our system is compatible to the CORBA Life-Cycle–Service specification and thus provides object migration between different language environments and computer systems. Unlike others, our Life-Cycle–Service implementation does not need vendor-specific extensions and just relies on standard CORBA features like servant managers and value types. Our implementation is portable; objects can migrate even between different ORBs. It supports object developers with a simple programming model that defines the state of an object as value type, provides coordination of concurrent threads in case of migration, and takes care of location-independent object addressing. Additionally we seamlessly integrated our implementation with a dynamic code-loading service.

This paper presents a framework for dynamic invocation of geographically replicated Web services. The framework implements a transparent invocation process, based on different server selection policies, which aims at reducing service response time at the client side. Preliminary experimental results, obtained in a real-world Internet setting, show that, in addition to the individual capacity of each server, the service invocation process is affected mainly by client characteristics such as connection bandwidth and workload distribution throughout the day.

In this paper we present a new infrastructure for building distributed applications that communicate through remote objects. The objects are available by the use of the Java RMI, enhanced by replication. Shared objects may be arbitrary complex with references to other objects allowing nested invocations. The replication process may be controlled and tuned by careful design of shared objects granularity, explicit synchronization operations, and replication domains definitions.

Active replication is a common approach to building highly available and reliable distributed software applications. The redundant nested invocation (RNI) problem arises when servers in a replicated group issues nested invocations to other server groups in response to a client invocation. Automatic suppression of RNI is always a desirable solution, yet it is usually a difficult design issue. If the system has multithreading (MT) support, the difficulties of implementation increase dramatically. Intuitively, to design a deterministic thread execution control mechanism is a possible approach. Unfortunately, some modern operating systems implement threads on the kernel level for execution fairness. For the kernel thread case, modification on thread control implies modifying the operating system kernel. This approach loses system portability which is one of the important requirements of CORBA or middleware. In this work, we propose a mechanism to perform the auto-suppression of redundant nested invocation in an active replication fault-tolerant (FT) CORBA system. Besides the mechanism design, we discuss the design correctness semantic and the correctness proof of our design.

The goal of this paper is to report our findings as to which CORBA services are ready to support distributed system software in a heterogeneous environment. In particular, we implemented intercommunication between components in our Management System for Heterogeneous Networks (MSHN) using four different CORBA mechanisms: the Static Invocation Interface (SII), the Dynamic Invocation Interface (DII), Untyped Event Services, and Typed Event Services. MSHN's goals are to manage dynamically changing sets of heterogeneous adaptive applications in a heterogeneous environment. We found these mechanisms at various stages of maturity, resulting in some being less useful than others. In addition, we found that the overhead added by CORBA varied from a low of 10.6 milliseconds per service request to a high of 279.1 milliseconds per service request on workstations connected via 100 Mbits/sec Ethernet. We therefore conclude that using CORBA not only substantially decreases the amount of time required to implement distributed system software, but it need not degrade performance.

A network management environment with dynamic behaviour can be used as a base for developing a wide range of applications from active networks to "on the fly" customised network management interfaces. This paper presents the dynamic features of the "BaseLayer", a network management tool developed by Machine Intelligence Research Laboratory, University of Ottawa. The dynamic features include the possibilities of adding new managed object (MO) classes without turning down the network management application and of adding new methods and attributes to MOs without turning down the factory servers for those managed objects. The second facility defines the Dynamic Managed Objects (DMOs) that can be changed at runtime by adding new methods and attributes "on the fly". While for adding new managed object classes the Interface Repository (IFR) and the Dynamic Invocation Interface (DII) provided by CORBA were used for DMO implementation a master-shadow server architecture was designed. In the new architecture each DMO factory server has at least 2 processes: a master process, which holds the MO instances and their attributes, and one or more shadow processes, which hold the new added methods.

This paper describes a technique that allows an MPI code to be encapsulated into a component. Our technique is based on an extension to the Common Object Request Broker Architecture (CORBA) from the OMG (Object Management Group). The proposed extensions do not modify the CORBA core infrastructure (the Object Request Broker) so that it can fully co-exist with existing CORBA applications. An MPI code is seen as a new kind of CORBA object that hides most of the cumbersome problems when dealing with parallelism. Such technique can be used to connect MPI codes to existing CORBA software infrastructures which are now being developed in the framework of several research and development projects such as JACO3, JULIUS or TENT from DLR. To illustrate the concept of parallel CORBA object, we present a virtual reality application that is made of the coupling of a light simulation application (radiosity) and a visualisation tool using VRML and Java.

The paper presents a proposal for incorporating a group communication paradigm into an object-based environment. Group communication is an interaction involving an arbitrary number of participants. Its application simplifies specification and implementation of complex systems. Object-oriented programming can significantly profit from the addition of a group mechanisms. The proposed mechanism, Multiple Object Invocation, provides group communication among objects. The paper first presents a model of general structure of group services and the use of group communication in this model. Multiple Object Invocation is presented and its characteristics and application in the general model is discussed. Implementation of Multiple Object Invocation in the Emerald object-oriented language and distributed operating system is presented. >

Asynchronous invocations are an important functionality in the context of distributed object frameworks, because in many situations clients should not block during remote invocations. There should be a loose coupling between clients and remote services. Popular web service frameworks, such as Apache Axis, offer only synchronous invocations (over HTTP). An alternative are messaging protocols but these implement a different communication paradigm. When client asynchrony is not supported, client developers have to build asynchronous invocations on top of the synchronous invocation facility. But this is tedious, error-prone, and might result in different remote invocation styles used within the same application. In this paper we build a framework using patterns for asynchronous invocation of web services. The framework design is based on the asynchrony patterns and other patterns from the same pattern language.

New applications and software environments are increasingly distributed across a large or even unpredictable number of networked computing devices, require mobile and ad-hoc networking capabilities, and must integrate with more systems, all of which create greater demands on the middleware used to realize these systems. On the Java platform, RMI is a well-established paradigm, yet deficiencies become evident in particular with regard to scalability and remote invocation completability – which is the assurance that invocations are executed according to client and service expectations regardless of the state of the participants or the communication network. While the Java Message Service (JMS) addresses these deficiencies, it lacks the simplicity, explicit contracts, clear coupling, and strong typing of an object-oriented invocation paradigm. This paper will describe our Java Invocation Layer for Messaging (JILM), a(n) (a)synchronous invocation layer to support object-oriented invocations while leveraging the unique distribution and QoS properties that JMS provides.

This paper presents COMET, a Common Object Management Environment, that investigates basic problems associated with distributed computing in an internet environment with mobile objects. COMET offers a uniform invocation model, based on dialogues, that integrates both communication and execution aspects. On the communication side, dialogues support asynchronous invocation with preservation of causal relationships. Applications can thus take advantage of the increased parallelism that is possible in a distributed environment. Furthermore COMET's invocation model supports multiple object flavors, offering high-level functionality, s.a. persistence, replication and atomicity. This is realized by modeling invocations as flavor-specific actions, that manipulate typed memory. Reflective techniques are used to dynamically adjust dialogue algorithms according to object flavor. >

Invocation batching combines multiple object invocations into a single message; result chaining makes results from one batched invocation available to the other invocations batched with it. Invocation chaining, or the combination of invocation batching with result chaining, is the key to allowing lightweight objects to be manipulated efficiently across heavyweight boundaries, whether between machines, between address spaces, or between user and kernel. By reducing the number of boundary crossings, invocation chaining reduces the total cost of invocation, making it more effective than previous solutions such as asynchronous messaging. This paper describes an initial implementation of invocation chaining. >

The common object request broker architecture (CORBA) is intended to simplify the task of developing distributed applications. Although it is well-suited for conventional remote procedure call style applications, several limitations become evident when CORBA is used for a broader range of performance-sensitive applications running in heterogeneous environments over high-speed networks. This paper illustrates the performance limitations of existing CORBA implementations in terms of their support for the dynamic invocation interface (DII) and the dynamic skeleton interface (DSI). The results indicate that object request broker implementers must optimize both the DII and DSI significantly before CORBA will be suitable for performance-sensitive applications on high-speed networks. In addition, the CORBA 2.0 DII specification must be clarified in order to ensure application portability and optimal performance.

Over the last several years, there has been an emphasis on distributed client/server computing in business as well as government. A useful means of achieving this capability is through the use of object technology. Distributed object systems offer many benefits, such as downsizing and right sizing, resulting in a trend toward small, modular, commercial or government off-the-shelf components as a means of system development. Distributed object management standards, such as the Common Object Request Broker Architecture (CORBA) specification are aiding the integration process. One area of distributed object systems that has received little attention to date is security. Security is a difficult problem in traditional software systems, and adding distribution and use of object-oriented techniques just increases the complexity of the problem. The Object Management Group (OMG) is beginning to solicit proposals from vendors for handling security in a distributed object environment. This paper gives an overview of distributed object management and standards being specified by the OMG. It applies traditional security engineering analysis to CORBA and highlights some of the security function interdependencies among CORBA components. >

This paper presents a visual client/server monitoring and management tool, CSMonitor, that provides realtime message monitoring of distributed CORBA objects, network traffic monitoring, statistic information for load balancing, and various management information for client and server nodes. The key component of CSMonitor is a CORBA interceptor module, which we developed in Visibroker for Java. CSMonitor provides various client/server and distributed computing information graphically. Hence, this tool can be effectively used in developing CORBA-based applications in order to verify the object clustering and design model and in monitoring the network overload of running CORBA applications. By having CSMonitor running, note it becomes possible to visualize the hidden inside of Object Request Broker (ORB), and to use the information provided by CSMonitor for performance optimization.