789 research outputs found
FRIENDS - A flexible architecture for implementing fault tolerant and secure distributed applications
FRIENDS is a software-based architecture for implementing fault-tolerant and, to some extent, secure applications. This architecture is composed of sub-systems and libraries of metaobjects. Transparency and separation of concerns is provided not only to the application programmer but also to the programmers implementing metaobjects for fault tolerance, secure communication and distribution. Common services required for implementing metaobjects are provided by the sub-systems. Metaobjects are implemented using object-oriented techniques and can be reused and customised according to the application needs, the operational environment and its related fault assumptions. Flexibility is increased by a recursive use of metaobjects. Examples and experiments are also described
A metaobject architecture for fault-tolerant distributed systems : the FRIENDS approach
The FRIENDS system developed at LAAS-CNRS is a metalevel architecture providing libraries of metaobjects for fault
tolerance, secure communication, and group-based distributed applications. The use of metaobjects provides a nice separation of concerns between mechanisms and applications. Metaobjects can be used transparently by applications and can be composed according to the needs of a given application, a given architecture, and its underlying properties. In FRIENDS, metaobjects are used recursively to add new properties to applications. They are designed using an object oriented design method and implemented on top of basic system services. This paper describes the FRIENDS software-based architecture, the object-oriented development of metaobjects, the experiments that we have done, and summarizes the advantages and drawbacks of a metaobject approach for building fault-tolerant system
Implementing fault tolerant applications using reflective object-oriented programming
Abstract: Shows how reflection and object-oriented programming can be used to ease the implementation of classical fault tolerance mechanisms in distributed applications. When the underlying runtime system does not provide fault tolerance transparently, classical approaches to implementing fault tolerance mechanisms often imply mixing functional programming with non-functional programming (e.g. error processing mechanisms). The use of reflection improves the transparency of fault tolerance mechanisms to the programmer and more generally provides a clearer separation between functional and non-functional programming. The implementations of some classical replication techniques using a reflective approach are presented in detail and illustrated by several examples, which have been prototyped on a network of Unix workstations. Lessons learnt from our experiments are drawn and future work is discussed
Software engineering and middleware: a roadmap (Invited talk)
The construction of a large class of distributed systems can be simplified by leveraging middleware, which is layered between network operating systems and application components. Middleware resolves heterogeneity and facilitates communication and coordination of distributed components. Existing middleware products enable software engineers to build systems that are distributed across a local-area network. State-of-the-art middleware research aims to push this boundary towards Internet-scale distribution, adaptive and reconfigurable middleware and middleware for dependable and wireless systems. The challenge for software engineering research is to devise notations, techniques, methods and tools for distributed system construction that systematically build and exploit the capabilities that middleware deliver
Distributed urban traffic applications based on CORBA event services
Intelligent transportation systems (ITS) in urban environments are based today on
modern embedded systems with enhanced digital connectivity and higher processing capabilities,
supporting distributed applications working in a cooperative manner. This paper provides an
overview about modern cooperative ITS equipments and presents a distributed application to
be used in an urban data network. As a case example, an application based on an embedded
CORBA-compliant middleware layer and several computer vision equipments is presented.
Results prove the feasibility of distributed applications for building intelligent urban
environments
Designing Distributed, Component-Based Systems for Industrial Robotic Applications
none3noneM. Amoretti; S. Caselli; M. ReggianiM., Amoretti; S., Caselli; Reggiani, Monic
An Approach of Software Engineering through Middleware
ABSTRACT: The challenge for software engineering research is to devise notations, techniques, methods and tools for distributed system construction that systematically build and exploit the capabilities that middleware deliver.The construction of a large class of distributed systems can be simplified by leveraging middleware, which is layered between network operating systems and application communication and coordination of distributed components. Existing middleware products enable software engineers to build systems that are distributed across a local-area network. State-of-the-art middleware research aims to push this boundary towards Internet-scale distribution, adaptive and reconfigurable middleware and middleware for dependable and wireless systems
Preliminary definition of CORTEX interaction model
As scheduled in the Technical Annex, WP2-D3 comprises work on the basic communication abstractions and the context and environmental awareness. It is structured in an introduction, providing a short survey of the content and four technical chapters. Chapter 2 describes the notion of event channels as a basic middleware abstraction of the interaction model. The concept of event channels accommodates an event-based, generative, many-to-many, anonymous communication model. It contributes to the resolution of the trade-off between autonomy and the need of coordination. Rather than explicitly coordinating actions by transferring control, an event channel allows interaction via a shared data space, thereby maintaining the autonomy of components. A comparison with alternative schemes is presented in chapter 3. Here, the impact of the interaction scheme on the modelling and implementation of a complex robotic application is analysed. It provides additional arguments in favour of a publisher/subscriber communication architecture. One of the challenges in CORTEX is to integrate the cooperation of components through the environment into the general interaction concept. The sensor capabilities of the sentient components and their ability to interact with the environment open new ways of cooperation. A mechanism called Stigmergy which is borrowed from biology and discussed in the CORTEX context is presented in chapter 4. Any activity which is carried out in the physical world needs to adapt to the pace and dependability requirements dictated by the environment. In technical terms this means that non-functional properties of the system, as timeliness and reliability of operation have to be included. These Quality of Service (QoS) attributes have to be guaranteed even in an environment where unanticipated dynamic change is one of the inherent properties. Chapter 5 introduces an adaptive QoS mechanism based on a reliable and timely system service. This service, called the Timely Computing Base (TCB) is able to monitor distributed system activities and to provide an "early warning system" for temporal and functional failures. The TCB thus provides part of the context and environmental awareness needed for adaptatio
- âŠ