Distributed Software Components Research Articles

How To Generate Distributed Software Components From Centralized Ones?

Adapting software components to be used in a particular application is a crucial issue in software component based technology. In fact, software components can be used in contexts with characteristics different from those envisaged when designing the component. Centralized or distributed deployment infrastructure can be one of these assumptions. Thus, a component can be designed as a monolithic unit to be deployed on a centralized infrastructure, nevertheless the used infrastructure needs the component to be distributed. In this paper, we propose an approach allowing us to transform a centralized software component into a distributed one. Our technique is based on refactoring and fragmentation of component source-code.

A component based methodology for Web application development

Today’s enterprises increasingly rely on the Web to support their operations, global business alliances, and integration of their business processes with those of their suppliers, partners, and customers. In order to stay competitive, businesses must also respond to changing business and competitive environments in near real-time. This requires that the architecture and design of business systems and applications should allow quick reconfiguration as well as collaboration among distributed software components. Existing software design methodologies often lack the Web focus and explicit support for componentization. This paper presents a methodology for requirements analysis and high-level design, specifically for component-based Web applications. Using the Web page as the fundamental building block of Web applications, the proposed methodology introduces page and component classifications, and a set of tags to implement link semantics. Based on these constructs, the methodology then specifies procedures for requirements analysis and design. A running business example is used to illustrate various stages of the analysis and design process.

A test framework for CORBA* component model-based software systems

In this paper we present a framework for testing software systems that is based on the Common Object Request Broker Architecture (CORBA <sup xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">∗</sup> ) component model (CCM) standard. An important aspect of CCM-based systems is that they must be verifiable and testable at the abstract level of their design, regardless of the language chosen to implement the component. Component-based systems allow the development and testing of components to be divided among development groups working in parallel. However, dependencies between separately developed components may cause delays in testing. The test framework we present allows for the automatic generation—based on their external specification—of reactor components that testers can use as substitutes for components their components depend on, but that have not yet been developed. The test components generated can respond to an invocation interactively or automatically by means of a test script. The framework can also visualize interactions between components as they flow through a distributed system, and can compare runtime interactions with design specifications. The approach to testing that we describe was first explored in the distributed software component (DSC) framework developed as part of the FRIENDS project, and has been used successfully in the WINMAN European research project, which deals with network management applications. The test framework has now been extended and adapted for the CCM architecture. It is currently implemented as part of the COACH research project, which is sponsored by the European Commission. © 2003 Lucent Technologies Inc.

Software objects in distributed flow measurements

Abstract Increasing complexity of the contemporary industrial measurement systems is a common characteristic. Partitioning of the measurement process into software components that can be realized as separate objects facilitates the development of the measurement system. Using a client/server approach, the measurement system components become shareable and accessible across the network. The components can be deployed anywhere on the network and shared by a considerable number of applications. The paper describes a realization of the flow measurement system with distributed software components, i.e., measurement procedures, which include the concurrent calculation of the measurement results and the corresponding uncertainties.

The FRIENDS platform-A software platform for advanced services and applications

New high-speed networks provide new opportunities for service providers to offer advanced voice, data, and multimedia services. This paper describes an extendible framework for the efficient creation and deployment of services. The framework integrates the needs of service providers, service developers, and end users within a single coherent architecture. In this architecture, services are composed of distributed software components. The framework provides the infrastructure for component interaction and encourages reuse of service logic from a rich set of basic components. This paper describes details of both the infrastructure and the components that implement the reusable service logic. The application of the service framework is illustrated by a case study of a multi-party service for collaborative work in project teams. The integration of the service framework and the Lucent Softswitch is a promising direction for future research.

Programming the Grid: Distributed Software Components, P2P and Grid Web Services for Scientific Applications

Computational Grids [17,25] have become an important asset in large-scale scientific and engineering research. By providing a set of services that allow a widely distributed collection of resources to be tied together into a relatively seamless computing framework, teams of researchers can collaborate to solve problems that they could not have attempted before. Unfortunately the task of building Grid applications remains extremely difficult because there are few tools available to support developers. To build reliable and re-usable Grid applications, programmers must be equipped with a programming framework that hides the details of most Grid services and allows the developer a consistent, non-complex model in which applications can be composed from well tested, reliable sub-units. This paper describes experiences with using a software component framework for building Grid applications. The framework, which is based on the DOE Common Component Architecture (CCA) [1,2,3,8], allows individual components to export function/service interfaces that can be remotely invoked by other components. The framework also provides a simple messaging/event system for asynchronous notification between application components. The paper also describes how the emerging Web-services [52] model fits with a component-oriented application design philosophy. To illustrate the connection between Web services and Grid application programming we describe a simple design pattern for application factory services which can be used to simplify the task of building reliable Grid programs. Finally we address several issues of Grid programming that better understood from the perspective of Peer-to-Peer (P2P) systems. In particular we describe how models for collaboration and resource sharing fit well with many Grid application scenarios.

The JEDI event-based infrastructure and its application to the development of the OPSS WFMS

The development of complex distributed systems demands the creation of suitable architectural styles (or paradigms) and related runtime infrastructures. An emerging style that is receiving increasing attention is based on the notion of event. In an event-based architecture, distributed software components interact by generating and consuming events. An event is the occurrence of some state change in a component of a software system, made visible to the external world. The occurrence of an event in a component is asynchronously notified to any other component that has declared some interest in it. This paradigm (usually called "publish/subscribe", from the names of the two basic operations that regulate the communication) holds the promise of supporting a flexible and effective interaction among highly reconfigurable, distributed software components. In the past two years, we have developed an object-oriented infrastructure called JEDI (Java event-based distributed infrastructure). JEDI supports the development and operation of event-based systems and has been used to implement a significant example of distributed system, namely, the OPSS workflow management system (WFMS). The paper illustrates the main features of JEDI and how we have used them to implement OPSS. Moreover, the paper provides an initial evaluation of our experiences in using the event-based architectural style and a classification of some of the event-based infrastructures presented in the literature.

Interconnection of Distributed Components: An Overview of Current Middleware Solutions*

From design and manufacturing to electronic commerce, coordinating business activities in engineering applications requires accessing data and software from distributed sources. The Common Object Request Broker Architecture (CORBA) of the Object Management Group emerged in the 1990’s as a standard for access to distributed software components. Since that time, the standard has matured significantly, providing advanced features for event notification and transaction processing. At the same time, Java-based technology for distributed object computing has also emerged, from Remote Method Invocation to Enterprise JavaBeans, Jini Connection Technology, JavaSpaces, Java Messaging Service, and Java Transaction Service. Sorting through the options available for the use of such tools can be a difficult task. This paper provides an overview of CORBA and Java technology for distributed object computing. A comparison of these different technologies is presented, discussing the similarities and differences, as well as the way in which such tools can be used together for distributed access to the types of software and data components that are needed for the construction of distributed engineering applications. Future directions for the use of such tools are also identified.

Behavioral specification of distributed software component interfaces

Networked computers are finding their way into a broader range of environments, from corporate offices to schools, homes, and shirt pockets. This new computing model fosters the development of distributed software components that communicate with one another across the underlying networked infrastructure. A distributed software component can be plugged into distributed applications that may not have existed when it was created. The intention is that many developers will reuse distributed software components to build new systems. An interface definition language usually is used to describe a distributed software component's interface. However, a notable limitation of current IDLs is that they generally only describe the names and type signatures of the component's attributes and operations. Current IDLs don't formally specify the behavior of the software component's operations. To help solve these problems, the authors have developed Biscotti (behavioral specification of distributed software component interfaces), a Java extension that enhances Java remote method invocation interfaces with Eiffel-style preconditions, postconditions, and invariants.

Distributed Batch Process Management Framework Based on Design Patterns and Software Components

Requirements for product quality and the increased number of complex speciality products as well as flexibility requirements for the usage of production equipment have emphasised the benefits of discontinuous batch production in process industries. Even if batch control has for a long time been a challenge to control engineers, emerging standards and software component technologies have now enabled them to design novel automation concepts. VTT Automation is developing a new software component-based framework for batch process management. In the experimental domain specific framework, the new batch control standard, experience with object-oriented design pattern based approach, and distributed software component technology is integrated.

Plug and play software hones car and plane manufacture

Working together, manufacturers, parts suppliers, information technology vendors, universities, and research organizations pull together complete manufacturing systems from distributed software components. The European Airbus consortium, Airbus Industrie, Blagnac, Cedex, France, is a good example, uniting as it does Aerospatiale (France), British Aerospace, Spain's CASA, Daimler-Benz Aerospace Airbus (Germany), and others in the development and manufacture of a range of commercial airliners. Airbus also amply demonstrates the functionality of such consortia: manufacturing is spread throughout the companies involved, and their disparate suppliers. The logistical challenges are great, but comparatively easy to surmount when measured against the challenges of integrating the design processes, computer aided design tools, and relevant databases of the consortia partners and suppliers. Airbus partners are not the only consortia members facing information and file format challenges. Searching for and exchanging data often wastes the design time of thousands of mechanical and electronics engineers in the automotive and aerospace industries across Europe. By using the same data in the same format across the enterprise, manufacturers can focus on developing new models.

Constructing Workstation Applications: Component Integration Strategies for a Changing Health-Care System

A health-care workstation is the means by which a professional interacts with the information artifacts of health care. However, a major transformation is taking place in the software architecture of health-care systems that alters significantly the role of the workstation. Health-care systems are becoming more complex in response to the need to support "extended enterprises" across regions, and provide both horizontal and vertical integration capabilities. Component-based software methodologies are being introduced that match well the needs of these large systems and the component services they must integrate. In the component-based framework, a workstation functions less as a "portal" for information transactions carried out on distant host computers, and more as the "orchestrator" for tasks involved in assembling, organizing, presenting, and manipulating information. Applications residing on workstations access distributed software components that carry out encapsulated functions for the application. Component-integration methodologies include both formal and ad hoc approaches; the principal emerging technologies are the World Wide Web (WWW), CORBA, Java, OLE, and OpenDoc. An emerging strategy appears to be that of developing application integration environments that encompass and support all of these integration methodologies. Component-based approaches also facilitate standardization at the message level, as messages to classes of components can serve to focus such standardization.