If you have trouble obtaining or printing these files see my troubleshooting tips. These are also available electronically in postscript for via anonymous ftp from wuarchive.wustl.edu or in PDF format.
Although component-based software development has widespread acceptance in the enterprise business and desktop application domains, developers of distributed real-time and embedded (DRE) systems have encountered limitations with the available component middleware platforms, such as the CORBA Component Model (CCM) and the Java 2 Enterprise Edition (J2EE). These limitations often preclude developers of DRE systems from fully exploiting the benefits of component software. In particular, component middleware platforms lack standards-based publisher/subscriber communication mechanisms that support key quality-of-service (QoS) requirements, such as low latency, bounded jitter, and end-to-end operation priority propagation. QoS-enabled publisher/subscriber services are available in object middleware platforms, such as Real-time CORBA, but such services have not been integrated into component middleware due to a number of development and configuration challenges.
This paper provides three contributions to the integration of publisher/subscriber services in component middleware. First, we outline key challenges associated with integrating publisher/subscriber services into component middleware. Second, we describe a methodology for resolving these challenges based on patterns. Third, we describe a pattern-oriented component middleware platform that we have developed to integrate publisher/subscriber services into component middleware applications.
Distributed real-time and embedded (DRE) systems have become critical in domains such as avionics (e.g., flight mission computers), telecommunications (e.g., wireless phone services), tele-medicine (e.g., robotic surgery), and defense applications (e.g., total ship computing environments). DRE systems are increasingly interconnected via wireless and wireline networks to form systems of systems. A challenging requirement for DRE systems involves supporting a diverse set of quality of service (QoS) properties, such as predictable latency/jitter, throughput guarantees, scalability, 24x7 availability, dependability, and security that must be satisfied simultaneously in real-time. Although increasing portions of DRE systems are based on QoS-enabled commercial-off-the-shelf (COTS) hardware and software components, the complexity of managing long lifecycles (often ~15-30 years) remains a key challenge for DRE developers and system integrators. For example, substantial time and effort is spent retrofitting DRE applications when the underlying COTS technology infrastructure changes.
This paper provides three contributions to improving the development, validation, and integration of DRE systems throughout their lifecycles. First, we illustrate the challenges in creating and deploying QoS-enabled component middleware-based DRE applications and outline our solution approach to resolve these challenges. Second, we describe a new software paradigm called Model Driven Middleware (MDM) that combines model-based software development techniques with QoS-enabled component middleware to address key challenges faced by developers of DRE systesm - particularly composition, integration, and assured QoS for end-to-end operations. Finally, we describe the structure and functionality of CoSMIC, which is an MDM toolsuite that addresses key DRE application and middleware lifecycle challenges, including developing component functionality, partitioning the components to use distributed resources effectively, validating the software, assuring multiple simultaneous QoS properties in real-time, and safeguarding against rapidly changing technology.
Middleware is increasingly used as the infrastructure for applications with stringent quality of service (QoS) requirements, including scalability. One way to improve the scalability of distributed applications is to use adaptive middleware to balance system processing load dynamically among multiple servers. Adaptive middleware load balancing can help improve overall system performance by ensuring that client application requests are distributed and processed equitably across groups of servers.
This paper presents the following contributions to research on adaptive middleware load balancing techniques: (1) it describes deficiencies with common load-balancing techniques, such as introducing unnecessary overhead or not adapting dynamically to changing load conditions, (2) it describes the capabilities of Cygnus, which is an adaptive load balancing service, and (3) it presents the results of empirical benchmarks that systematically evaluate different load balancing strategies provided in Cygnus by measuring their scalability showing how well each strategy balances system load. The findings in this paper show that adaptive middleware load balancing is a viable solution for improving the scalability of distributed applications.
The knowledge required to develop complex software has historically existed in programming folklore, the heads of experienced developers, or buried deep in the code. These locations are not ideal since the effort required to capture and evolve this knowledge is expensive, time-consuming, and error-prone. Many popular software modeling methods and tools address certain aspects of these problems by documenting how a system is designed. However, they only automate limited portions of software development and do not articulate why a system is designed in a particular way, which complicates subsequent software reuse and evolution.
Patterns, frameworks, and middleware are increasingly popular techniques for addressing key aspects of the challenges outlined above. Patterns codify reusable design expertise that provides time-proven solutions to commonly occurring software problems that arise in particular contexts and domains. Frameworks provide both a reusable product-line architecture -- guided by patterns -- for a family of related applications and an integrated set of collaborating components that implement concrete realizations of the architecture. Middleware is reusable software that leverages patterns and frameworks to bridge the gap between the functional requirements of applications and the underlying operating systems, network protocol stacks, and databases. This paper presents an overview of patterns, frameworks, and middleware, describes how these technologies complement each other to enhance reuse and productivity, and then illustrates how they have been applied successfully in practice to improve the reusability and quality of complex software systems.
A distributed application can be given increased resistance to certain types of malicious behavior, even when the environment in which it is operating contains untrustworthy elements. Recent trends in protecting applications use operating systems as only the first layer of security, anticipating that this layer may be breached. Another layer is added to react to and repair the damage done by intruders that succeed in breaching the first layer. A promising approach to designing the second layer of protection uses adaptive middleware to enable agile behavior and to coordinate protective responses across the distributed system, even in resource-depleted environments. This new approach to protection complements more traditional approaches -- in which only one layer of security is used -- by hardening critical components at multiple system levels. When integrated effectively, this multi-level approach makes it harder for intruders to corrupt or disable distributed systems and applications.
This paper presents three contributions to the study of protecting distributed applications against malicious behavior. First, we describe the key ideas and technologies behind the emerging multi-level approach to protecting distributed applications. Second, we explain how these ideas relate to security engineering in general. Finally, we report recent results in evaluating a collection of technologies that implement this approach. These results illustrate that adaptive middleware can increase survival time and enable applications to operate more effectively through attacks, though much additional research remains to be done.
Commercial off-the-shelf (COTS) distribution middleware is gaining acceptance in the distributed real-time and embedded (DRE) community. Existing COTS specifications, however, do not effectively separate quality of service (QoS) policy configurations and adaptations from application functionality. DRE application developers therefore often intersperse code that provisions resources for QoS guarantees and programs adaptation mechanisms throughout DRE applications, making it hard to configure, validate, modify, and evolve complex DRE applications. This paper illustrates (1) how standard component-based middleware can be enhanced to flexibly compose static QoS provisioning policies with application logic, (2) how adaptive middleware capabilities enable developers to abstract and encapsulate reusable dynamic QoS provisioning and adaptive behaviors, and (3) how component-based middleware and adaptive middleware capabilities can be integrated to provide a total QoS provisioning solution for DRE applications.
This paper presents three contributions to the challenges of applying the OMG Model Driven Architecture (MDA) to develop and deploy distributed real-time and embedded (DRE) applications. First, we motivate our MDA tool called CoSMIC, which is based on the Model Integrated Computing (MIC) paradigm that provides the intellectual foundation for MDA. Second, we describe how CoSMIC's generative abilities can be used to configure and assemble DRE component middleware required to deploy DRE applications. Third, we delineate the challenges involved in developing CoSMIC. Based on our collective experience developing MIC tools and DRE middleware, we are confident that combining these two paradigms will yield significant advantages in developing model based DRE applications.
We are currently integrating Data-Parallel (DP) CORBA with The ACE ORB (TAO), which is our widely used open-source implementation of RT-CORBA. This paper outlines our approach and present lessons learned to date on our model-based synthesis and integration of (1) HPEC application functionality, (2) Data-Parallel and Real-time CORBA component middleware configurations, and (3) data partitioning for parallelization and demonstrate empirically how this architecture offers a powerful and novel approach to HPEC computing environments.
ZEN is a CORBA ORB designed to support distributed, real-time, and embedded (DRE) applications that have stringent memory constraints. This paper discusses the design and performance of ZENs portable object adapter (POA) which is an important component in a CORBA object request broker (ORB). This paper makes the following three contributions to the study of middleware for memory-constrained DRE applications. First, it presents three alternative designs of the CORBA POA. Second, it explains how design patterns can be applied to improve the quality and performance of POA implementations. Finally, it presents empirical measurements based on the ZEN ORB showing how memory footprint can be reduced significantly while throughput is comparable to a conventional ORB implementation.
As distributed object computing (DOC) middleware standards and implementations evolve over time, they invariably must support a growing number of protocols to remain inter-operable. Memory footprints of middleware implementations can become large if a concerted effort is not made to prevent this growth. Large middleware memory footprints are problematic for important classes of distributed, real-time, and embedded (DRE) applications that have stringent memory constraints. This paper makes two contributions to the design of middleware to address key challenges of developing DRE applications. First, it describes the design of dynamically configurable general inter-ORB protocols (GIOP). Second, it explains how we applied patterns and Java features to minimize and customize the memory footprint of messaging protocols used in DRE middleware.
Advances in commercial distributed object computing (DOC) middleware technologies are enhancing the affordability and reducing the time-to-market of distributed enterprise applications, such as airline's reservation systems, banks asset management systems, and automated stock trading systems. DOC middleware encapsulates specific services or sets of services to provide reusable building blocks that can be composed to create enterprise applications rapidly and robustly. Commercial DOC middleware, such as CORBA, J2EE or the emerging .NET, offer ``horizontal'' infrastructure services, such as object request brokers, ``vertical'' models of domain concepts, such as common semantics for higher-level reusable component services, and ``connector'' mechanisms between components, such as remote method invocations or message passing.
Despite the many benefits of DOC middleware, however, developers of enterprise applications face two key unresolved challenges. First, middleware technologies, such as Sun's J2EE and the Microsoft's emerging .NET web services, may be challenged to provide a complete end-to-end solution to build enterprise applications. Enterprise applications require that the underlying middleware technology platform is available on heterogeneous platforms and languages, interface with legacy code in different languages and interoperate with multiple technologies from different vendors. Second, conventional implementations of DOC middleware web services do not support enterprise applications that possess multiple quality of service (QoS) demands, such as efficiency, scalability, dependability, and security that cross-cut multiple layers and require end-to-end enforcement.
A promising way to address these challenges is to apply Model-Integrated Computing (MIC) technologies. MIC is a paradigm for developing application functionality and QoS requirements at higher levels of abstraction than is possible with programming languages like Java, C++, or C#. Sophisticated MIC generator tools and aspect weavers can be applied to analyze the models and synthesize platform-specific code that is customized for specific middleware and application properties, such as isolation levels of a transaction, backup server properties in case of failure, or authentication and authorization strategies. This paper describes a portable, component-based middleware framework we are developing to support configurable and adaptive QoS management essential to the success of model-integrated computing.
This paper describes IKE, which is distributed object computing middleware that supports the creation of interoperable real-time distributed applications. These applications appear in many domains, such as telecom, aerospace, military testing and training ranges, and financial services. IKE combines the concepts of CORBA distributed objects and anonymous publish-subscribe data dissemination to provide a programming abstraction known as a stateful distributed object (SDO).
Every SDO can have both a remote method interface and publication state. The remote method interface allows client applications to invoke methods on target objects efficiently without concern for their location, programming language, OS platform, communication protocols and interconnects, or hardware. The publication state of a given SDO is disseminated to applications that have expressed their interest by subscribing to certain characteristics, such as the type of the SDO. Subscribers can read the publication state of an SDO as if it were a local object. The SDOs provided by the IKE metaobject model support inheritance from other SDOs, containment of other SDOs, and references to other SDOs.
IKE is implemented in C++ and is based on the ACE and TAO middleware. The API relies heavily on compile-time type-safety to help ensure reliable behavior at run-time---a critical feature of any real-time system. Automatic code generation is used to provide the high-level abstractions without unduly burdening application programmers.
This paper discusses the software architecture of a Real-time CORBA object request broker (ORB) called ZEN, which is written in Real-time Java and designed to eliminate common sources of overhead and non-determinism in ORB implementations. We illustrate how ZEN can be configured to select the minimal set of components used by an application. Our experience with ZEN indicates that combining Real-time Java with Real-time CORBA is a major step forward towards simplifying the development and maintenance of distributed middleware and applications with stringent quality of service requirements.
Commercial off-the-shelf (COTS) middleware increasingly offers not only functional support for standard interfaces, but also the ability to optimize their resource consumption patterns. For example, a COTS real-time object request broker (ORB) may permit users to configure its server-side thread pooling policies. On one hand, this flexibility makes it possible to use standard functional interfaces in applications where they were not applicable previously. On the other hand, the non-standard nature of the optimization mechanisms - i.e., the "knobs and dials" - acts against the very product-independence that standardized COTS interfaces are intended to provide.
This paper provides two contributions to the study of mechanisms for reducing the life-cycle costs of distributed real-time and embedded (DRE) systems. First, we present a mechanism-called a Quality Connector-that enables applications to specify the qualities of service that they require from their infrastructure, and then manages the operations that optimize the middleware to implement those requirements. Second, we show how Quality Connectors are being applied in practice to allocate communication resources automatically for real-time CORBA event propagation. Although middleware that configures itself in response to quality of service (QoS) requests has been investigated and applied in general-purpose computing contexts, we believe that the present work is among the first to put such capabilities into mission-critical DRE systems with stringent QoS requirements.
Load balancing middleware is used extensively to improve scalability and overall system throughput in distributed systems. Many load balancing middleware services are simplistic, however, since they are geared only for specific use-cases and environments. These limitations make it hard to use the same load balancing service for anything other than the distributed application it was designed for originally. This lack of generality forces continuous re-development of application-specific load balancing services. Not only does re-development increase deployment costs of distributed applications, but it also increases the potential of producing non-optimal load balancing implementations since proven load balancing service optimizations cannot be reused directly.
This paper presents a set of load balancing service features that address many existing middleware load balancing service inadequacies, such as lack of server-side transparency, centralized load balancing, sole support for stateless replication, fixed load monitoring granularities, lack of fault tolerant load balancing, non-extensible load balancing algorithms, and simplistic replica management. All the capabilities described in this paper are currently under development for the next generation of middleware-based load balancing service distributed with our CORBA-compliant ORB (TAO).
CORBA is increasingly popular as distributed object computing middleware for systems with stringent quality of service (QoS) requirements, including scalability and dependability. One way to improve the scalability and dependability of CORBA-based applications is to balance system processing load among multiple server hosts. Load balancing can help improve system scalability by ensuring that client application requests are distributed and processed equitably across a group of servers. Likewise, it can help improve system dependability by adapting dynamically to system configuration changes that arise from hardware or software failures.
This paper presents three contributions to research on CORBA-based load balancing. First, we describe deficiencies with common load-balancing techniques, such as introducing unnecessary overhead or not adapting dynamically to changing load conditions. Second, we present a novel adaptive load balancing service that can be implemented efficiently using standard CORBA features. Finally, we present the results of benchmark experiments that evaluate the pros and cons of different load balancing strategies empirically by measuring the overhead of each strategy and showing how well each strategy balances system load.
As network-centric computing becomes more pervasive and applications become more distributed, the demand for greater scalability and dependability is increasing. Distributed system scalability can degrade significantly, however, when servers become overloaded by the volume of client requests. To alleviate such bottlenecks, load balancing middleware mechanisms can be used to distribute system load equitably across object replicas residing on multiple servers. This paper describes the key design challenges we faced when adding this load balancing service to our CORBA ORB (TAO) and outline how we resolved the challenges by applying patterns.
Distributed object computing (DOC) middleware, such as CORBA, COM+, and Java RMI, shields developers from many tedious and error-prone aspects of programming distributed applications. Without proper middleware support, however, it is hard to evolve distributed applications after they are deployed. Therefore, DOC middleware should also support meta-programming mechanisms, such as smart proxies, interceptors, and pluggable protocols. These mechanisms can help improve the adaptability of distributed applications by allowing their behavior to be modified without changing their existing software designs and implementations significantly.
This papers examines and compares common meta-programming mechanisms supported by DOC middleware that allow applications to adapt more readily to changes in requirements and run-time environments. Some of these meta-programming mechanisms are relatively new, whereas some have existed for decades. Until recently, however, DOC middleware has not provided all of these mechanisms, so researchers and developers may not be familiar with the breadth of meta-programming mechanisms available today. The goal of this paper is to evaluate these mechanisms systematically to help researchers and developers determine which are best suited for their application needs.
Existing CORBA specifications, such as Real-time CORBA and CORBA Messaging, address many quality-of-service (QoS) properties by defining policies that control local and end-to-end priorities, connection multiplexing, queue ordering, and request routing. They do not, however, define strategies for configuring these QoS properties into applications flexibly, transparently, and adaptively. Application developers must therefore make these configuration decisions manually, which is tedious, error-prone, and sub-optimal for complex distributed systems. Although the recently adopted CORBA Component Model (CCM) defines a standard configuration framework for packaging and deploying software components, conventional CCM implementations focus on functionality rather than adaptive quality-of-service, which makes them unsuitable for next-generation applications with demanding QoS requirements.
In this paper, we explore how reflective middleware techniques can be applied to implement a CCM-compliant ORB in which QoS properties of components can be specified and adjusted dynamically. This paper presents three contributions to the study of middleware for QoS-enabled component-based applications. It outlines reflective middleware techniques designed to adaptively (1) select optimal communication mechanisms, (2) manage QoS properties of CORBA components in their containers, and (3) (re)configure selected component executors dynamically. Our ongoing research on CORBA and the CCM indicates that reflective middleware techniques are well-suited to address the QoS demands of next-generation component-based applications.
Distributed object computing (DOC) middleware shields developers from many tedious and error-prone aspects of programming distributed applications. Without proper support from the middleware, however, it can be hard to evolve distributed applications after they are deployed. Therefore, DOC middleware should support meta-programming mechanisms, such as smart proxies and interceptors, that improve the adaptability of distributed applications by allowing their behavior to be modified without drastically changing existing software.
This paper presents three contributions to the study of meta-programming mechanisms for DOC middleware. First, it illustrates, compares, and contrasts several meta-programming mechanisms from an application developer's perspective. Second, it outlines the key design and implementation challenges associated with developing smart proxies and portable interceptors features for CORBA. Third, it presents empirical results that pinpoint the performance impact of smart proxies and interceptors. Our goal is to help researchers and developers determine which meta-programming mechanisms best suit their application requirements.
This paper describes how recent advances in distributed object computing (DOC) middleware are enabling the creation of common quality-of-service (QoS) interfaces that support next-generation distributed applications. DOC middleware helps to simplify and coordinate applications in order to leverage the underlying network and endsystem QoS architectures more effectively. This paper also describes a QoS-enabled middleware framework used to customize the CORBA Audio/Video Streaming Service for applications on multiple operating system platforms.
Although existing CORBA specifications, such as Real-time CORBA and CORBA Messaging, address many end-to-end quality-of-service (QoS) properties, they do not define strategies for configuring these properties into applications flexibly, transparently, and adaptively. Therefore, application developers must make these configuration decisions manually and explicitly, which is tedious, error-prone, and often sub-optimal. Although the recently adopted CORBA Component Model (CCM) does define a standard configuration framework for packaging and deploying software components, conventional CCM implementations focus on functionality rather than adaptive quality-of-service, which makes them unsuitable for next-generation applications with demanding QoS requirements.
This paper presents three contributions to the study of middleware for QoS-enabled component-based applications. It outlines reflective middleware techniques designed to adaptively (1) select optimal communication mechanisms, (2) manage QoS properties of CORBA components in their containers, and (3) (re)configure selected component executors dynamically. Based on our ongoing research on CORBA and the CCM, we believe the application of reflective techniques to component middleware will provide a dynamically adaptive and (re)configurable framework for COTS software that is well-suited for the QoS demands of next-generation applications.
This paper presents an overview of the CORBA Component Model (CCM), focusing on the problems it addresses and the features it provides.
In many application domains, the distributed object computing (DOC) middleware is responsible for dispatching upcalls to one or more application objects when events or requests arrive from clients. Implementing efficient, predictable, and scalable middleware dispatching mechanisms is hard and implementing them for multi-threaded systems is even harder. In particular, dispatching mechanisms must be prepared to dispatch upcalls to multiple objects, to handle recursive requests originated from application-provided upcalls, and must often collaborate with the application to control object' life-cycle.
In our DOC middleware research we have implemented many dispatching mechanisms that repeatedly apply common solutions to solve the challenges outlined above. Moreover, we have discovered that the forces constraining dispatching mechanisms often differ slightly, thereby requiring alternative solutions. This paper presents two contributions to the design and implementation of efficient, predictable, scalable, and flexible DOC middleware and applications. First, it shows how patterns can be applied to the object-oriented systems to capture key design and performance characteristics of proven dispatching mechanisms. Second, it presents a pattern language that describes successful solutions that are appropriate for key dispatching challenges that arise in various real-time DOC middleware and applications.
Next-generation distributed interactive simulations have stringent quality of service (QoS) requirements for throughput, latency, and scalability, as well as requirements for a flexible communication infrastructure to reduce software lifecycle costs. The CORBA Events Service provides a flexible model for asynchronous communication among distributed and collocated objects. However, the standard CORBA Events Service specification lacks important features and QoS optimizations required by distributed interactive simulation systems.
This paper makes five contributions to the design, implementation and performance measurement of distributed interactive simulation systems. First, it describes how the CORBA Events Service can be implemented to support key QoS features. Second, it illustrates how to extend the CORBA Events Service so that it is better suited for distributed interactive simulations. Third, it describes how to develop efficient event dispatching and scheduling mechanisms that can sustain high throughput. Fourth, it describes how to use multicast protocols to reduce network traffic transparently and improve system scalability. Finally, it illustrates how an Events Service framework can be strategized to support configurations that facilitate high throughput, predictable bounded latency, or some combination of each.
To make informed choices among middleware alternatives, developers of distributed object systems should understand the patterns and components used to implement key features in CORBA ORBs. Recent Object Interconnection columns have explored the features of the CORBA Messaging specification. In this article, we describe key patterns and components used to implement an OMG IDL compiler that supports the Asynchronous Method Invocation (AMI) callback model defined in the CORBA Messaging specification.
Method-oriented middleware, such as SunRPC, DCE, Java RMI, COM, and CORBA, has traditionally provided synchronous method invocation (SMI) models to applications. Although SMI works well for conventional client/server applications, it is not well-suited for high-performance or real-time applications due to its lack of scalability. To address this problem, the OMG has recently standardized an asynchronous method invocation (AMI) model for CORBA.
This paper provides two contributions to research on asynchronous invocation models for method-oriented middleware. First, we outline the key design challenges faced when developing the CORBA AMI model and describe how we resolved these challenges in TAO, which is our high-performance, real-time CORBA-compliant ORB. Second, we present the results of empirical benchmarks that demonstrate the performance benefits of AMI compared with alternative CORBA invocation models. In general, CORBA AMI is more scalable than equivalent SMI designs, with only a moderate increase in programming complexity.
gperf is a ``software-tool generating-tool'' that
automates the generation of perfect hash functions. This paper
describes the features, algorithms, and object-oriented design and
implementation strategies incorporated in
gperf. It also
codesents the results from an empirical comparison between
gperf-generated recognizers and other popular techniques
for reserved word lookup.
gperf is distributed with the
GNU libg++ library and is used to generate the keyword recognizers for
the GNU C/C++ compilers and the TAO IDL compiler.
An Object Adapter is an integral part of the Common Object Request Broker Architecture (CORBA). An Object Adapter assists an Object Request Broker (ORB) in delivering client requests to server object implementations (servants). Services provided by an Object Adapter include: (a) generation and interpretation of object references, (b) operation dispatching, (c) object activation and deactivation, (d) mapping object references to servants, and (e) registration of servants.
This paper provides two contributions to the study of Object Adapters. First, it outlines the CORBA Portable Object Adapter (POA) specification, which is a recent addition to the CORBA standard that greatly simplifies the development of portable and extensible servants and server applications. The design goals, architectural components, and semantics of the POA are explained. Second, the paper describes the design choices made to adapt the POA for the TAO Real-time ORB. Key design issues regarding efficient demultiplexing, upcall and collocation optimizations, ORB and POA concurrency configurations, and predictability are covered.
Recent advances in network bandwidth and processing power of CPUs has led to the emergence of several multimedia streaming frameworks, such as NetShow, Realvideo and Vxtreme. Such frameworks typically rely on proprietary stream establishment and control mechanisms. To facilitate the development of standards-based distributed multimedia streaming applications, the OMG has defined a CORBA-based specification that stipulates the key interfaces and semantics needed to control and manage audio/video streams.
This paper makes two contributions to the study of CORBA-based distributed multimedia streaming frameworks. First, it describes the design and performance of TAO's audio/video (A/V) streaming framework, which is a freely available implementation of the OMG CORBA streams model. Second, it describes the design and performance of a distributed application that uses TAO's A/V streaming framework to establish and control MPEG video streams. Our experience with the A/V streaming framework indicates that it is a flexible and efficient model for developing multimedia streaming applications.
Distributed object computing forms the basis for next-generation application middleware. At the heart of distributed object computing are Object Request Brokers (ORBs), which automate many tedious and error-prone distributed programming tasks. This article presents a case study of key design patterns needed to develop ORBs that can be dynamically configured and evolved for specific application requirements and system characteristics.
Back to my CORBA Research page.
Last modified 11:34:34 CDT 28 September 2006