Showing papers by "Pierre Verbaeten published in 2004"

An agent design method promoting separation between computation and coordination

Abstract: The development of (internet) agents is often a tedious and error-prone task resulting in poorly reusable designs, since both the internal computation of the agent as well as the coordination support are developed in an ad hoc fashion. To improve the process of agent-oriented software development, we propose an agent design method that imposes the separation of internal computation from coordination aspects. This method comprises two dimensions: a design formalism and an agent design process. As an illustration of the presented method, we present the design of an internet agent that is entitled to deploy a distributed service in a computer network, without breaking the consistency of that network. The presented design method has resulted in the development of ACF (Agent Composition Framework), a component framework to build flexible internet agents. We argue that the presented design method combined with this infrastructure can promote a modular and easy to manage approach to the design and development of internet agent applications.

A modular approach enforcing safe reconfiguration of producer-consumer applications

Abstract: Unanticipated software adaptations are becoming increasingly important in the domain of distributed systems. Due to performance and availability requirements, these adaptations need to be enforced at run-time. However for dynamic changes to yield valid systems, a safe state for reconfiguration of the involved software modules must be enforced. This paper proposes a solution to modularize support for achieving safe reconfiguration and separate it from basic application functionality. In addition, we describe a mechanism to obtain a safe state for unanticipated reconfiguration of producer/consumer based systems, rather than being limited to updates of independent software components. The presented method imposes such a safe state with minimal interference to the rest of the system, and with minimal contribution from the programmer. We believe that a wide range of producer/consumer based systems can take advantage of the presented solution.

NeCoMan: middleware for safe distributed service deployment in programmable networks

Abstract: Recent evolution in computer networks clearly demonstrates a trend towards complex and dynamic networks. To fully exploit the potential of such heterogeneous and rapidly evolving networks, it is essential for the protocol stacks of the connected devices to adapt themselves at runtime as the environment changes in which they execute. This illustrates the need for employing programmable (i.e. adaptable) network nodes. In this paper, we concentrate on deploying point-to-point based distributed services in programmable protocol stacks. More in detail, we examine safe runtime adaptations of such services so as to preserve service consistency in programmable networks. This has resulted in the development of the NeCoMan (Network Consistency Management) middleware, a generic distributed coordination platform responsible for safe addition, replacement and removal of point-to-point services among programmable nodes. The novelty of this reflective middleware is in its ability to improve the effectiveness of the deployment process. This is achieved by customizing the deployment process depending on the properties of both the network service that will be deployed and the underlying execution environment.

A Generalization and Solution to the Common Ancestor Dilemma Problem in Delegation-Based Object Systems

Abstract: This paper studies the diamond problem in the context of delegation-based object systems. The diamond problem occurs when the same ancestor is inherited multiple times via different inheritance paths. The challenge is that replication and sharing of distinct attributes of the common ancestor must be simultaneously supported. We illustrate the relevance of the diamond problem by showing that it arises not only in multiple inheritance but also in other inheritance techniques, hence the more general term ’the common ancestor dilemma’. More specifically the hybrid approach that integrates object-based inheritance in a class-based model is also affected by the problem. We show that the hybrid approach provides an elegant solution for orthogonal expression of replication and sharing. Attributes that should be shared are modeled as part of the delegating objects, whereas attributes that should not be shared are modeled as part of subobjects of the delegating objects.

Automating decisions in component composition based on propagation of requirements

Abstract: Automatic component composition is a way to achieve self-customizable systems that are able to adapt themselves through structural configuration to changing conditions in their environment. In this paper, we propose an automatic composition strategy for multi-flow architectures with hierarchically composable components. Our composition strategy takes automatic decisions for the composition of a target that is specified through a set of required properties imposed over its given structural constraints. The composition decisions are taken knowing the properties provided by individual available components. Properties characterize functional or non-functional aspects of a component. The composition strategy is driven by a mechanism of propagation of required properties, detailed in this paper.

Towards preserving correctness in self-managed software systems

Abstract: Currently, paradigms such as component-based software development and service-oriented software architectures promote modularization of software systems into highly decoupled and reusable software components and services. In addition, to improve manageability and evolveability, software systems are extended with management capabilities and self-managed behavior. Because of their very nature, these self-managed software systems often are mission critical and highly available. In this paper, we focus on the complexity of preserving correctness in modularized self-managed systems. We discuss the importance of consistent software compositions in the context of self-managed systems, and the need for a correctness-preserving adaptation process. We also give a flavor of possible approaches for preserving correctness, and conclude with some remarks and open questions.

Automating Decisions in Component Composition Based on Propagation of Requirements

Abstract: Automatic component composition is a way to achieve self-customizable systems that are able to adapt themselves through structural configuration to changing conditions in their environment. In this paper, we propose an automatic composition strategy for multi-flow architectures with hierarchically composable components. Our composition strategy takes automatic decisions for the composition of a target that is specified through a set of required properties imposed over its given structural constraints. The composition decisions are taken knowing the properties provided by individual available components. Properties characterize functional or non-functional aspects of a component. The composition strategy is driven by a mechanism of propagation of required properties, detailed in this paper.

The DiPS+ software architecture for self-healing protocol stacks

Abstract: Research domains such as active networks, ad-hoc networks, ubiquitous computing, pervasive computing, grid computing, and sensor networks, clearly show that computer networks will become more complex and heterogeneous. In many cases, central management and control of the network are far from trivial since both the topology and the connected devices change rapidly in such highly dynamic environments, while load circumstances may vary arbitrarily. The software architecture in a node needs to support flexibility. We have developed an architecture tailored to protocol stack software that allows customizing internal resource management in order to handle overload conditions gracefully. We show that the investment in explicit support for modularity and architectural constraints pays off: the paper elaborates on a case study in which dynamic adaptation of access control behavior leads to significant performance improvements.

A DiPS+ case study: a self-healing RADIUS server

Abstract: This report shows performance results of a RADIUS implementation using the DiPS+ software architecture. In addition it compares this implementation with a commercially available RADIUS implementation, and shows that the DiPS+ architecture differentiates between user types and request types. In fact, the DiPS+ prototype prioritizes incoming traffic based on application-specific preferences, and allocates the available processing resources to the highest priority requests.

Improving software reliability in data-centered software systems by enforcing composition time constraints

Abstract: Specifying and enforcing constraints and invariants such as architectural constraints and data typing, strongly enhances the safety and reliability of the software system. Next to design and development constraints, the composition of software systems in component-based software also introduces composition time constraints and dependencies. In data-centered software systems, for example, the software composer implicitly creates dataflow dependencies between software components. Describing composition time constraints and enforcing these constraints at deploy time or at run-time strongly improves the safety and reliability of the software. In this paper, we present an approach for expressing and enforcing dataflow dependencies in data-centered software systems, and conclude with a validation of the approach in a servlet-based case study.

Infrastructural support for data dependencies in data-centered software systems

Abstract: The identification of key concerns is crucial for a good application of the separation-of-concerns principle [5, 3]. However, an exhaustive list of all important non-functional concerns and the correct decomposition of software into those concerns is still an open question. Moreover, we believe that some of the important key concerns are application domain or software architecture specific. Therefore, we argue that in order to provide better infrastructural support, the infrastructure must take into account this architectural correlation. The infrastructure must provide explicit support for describing and enforcing implicit application information, that is specific to the software architecture. In this paper, we illustrate this idea for the concern of data dependencies in data-centered software systems.