Modern distributed computing systems are becoming increasingly complex. A major trend currently is to build autonomous systems, i.e. systems that reconfigure themselves upon occurrence of events such as software and hardware faults, performance degradation, etc. Building autonomous systems requires both a software technology allowing the development of administrable systems and the ability to build control loops in charge of regulating and optimizing the behavior of the managed system.

In this talk, we will mainly focus on the first requirement, i.e. providing a software technology for the development of administrable systems. We argue that better configurability can be reached through the use of component-based software frameworks. In particular, we present DREAM, a software framework for the construction of message-oriented middleware (MOMs).

Several MOMs have been developed in the past ten years. The research work has primarily focused on the support of various non functional properties like message ordering, reliability, security, scalability, etc. Less emphasis has been placed on MOM configurability. From the functional point of view, existing MOMs implement a fixed programming interface (API) that provides a fixed subset of asynchronous communication models (publish/subscribe, event/reaction, message queues, etc.). From the non-functional point of view, existing MOMs often provide the same non-functional properties for all message exchanges, which reduces their performance.

To overcome these limitations, we have developed DREAM (Dynamic REflective Asynchronous Middleware), a component framework for the construction of dynamically reconfigurable communication systems. The idea is to build a middleware as an assembly of interacting components, which can be statically or dynamically configured to meet different design requirements or environment constraints. DREAM provides a component library and a set of tools to build, configure and deploy middleware implementing various communication paradigms. DREAM defines abstractions and provides tools for controlling the use of resources (i.e. messages and activities) within the middleware. Moreover, it builds upon the Fractal component model, which provides support for hierarchical and dynamic composition. DREAM has been successfully used for building various forms of communication middleware: publish-subscribe (JMS), total order group communication protocols, probabilistic broadcast,asynchronous RPC, etc.

Maintaining the consistency between database schemas and database applications is a difficult problem. Impacts of changes to the schema can be complex, far reaching and difficult to track. This is a difficult problem to deal with, especially when the database schema is not within the control of the application developers.

One approach is to avoid the problem by avoiding change to the schema. Another approach is to build the application is such a way that impact is confined to specific components, minimising the impact area that has to be reconciled. We propose a technique to predict the effects of schema changes, with the goal of better informing both the developer making changes, and developer who must reconcile an application with the new schema.

The major problem we face is providing traceability from relational database artefacts to object oriented code. Previous research has focused on using object oriented databases to implicitly provide this kind of traceability. However, despite the emergence of object, deductive and semi-structured databases the vast majority of databases used in practice remain relational databases. We therefore constrain our research to providing impact analysis with relational database schemata.

We investigate the use of Object Relational Mappings (ORM) and strongly typed queries to provide the traceability required. Having traceability between these artefacts we can statically extract dependency data from the application and the schema. We use the extracted data to populate a dependency model that can be used to predict the impact of a change. We use object oriented modelling techniques to provide the dependency model and predict the effects of change.

We shall evaluate these techniques using a real world case study.

The talk introduces the research training project PARIS, which is placed in the multi-disciplinary context of distributed information systems technology for virtual organizations and targets combined aspects of software engineering methodology and distributed middleware technology.

In virtual organizations, business processes are decomposed with respect to core competencies of its partner organizations. These assets are continually re-integrated pertaining to changing requirements of customers and markets. Each such constellation implies a specific interaction procedure between the partners that has to be implemented by an operative process-chain. The more dynamic, the more the virtual organization relies on integrated ICT. Service-oriented Grid architectures promise effective means to share functions and processes. Yet, gaps remain between technology and its application: the abstractions (e.g. services) are too low-level to be efficiently applied by business engineers and software engineering methodology to develop mission-critical systems on top is usually missing. Hence, PARIS aims at two research goals: (i) high-level abstractions for organizational interaction procedures that enable efficient realization of operational process-chains and (ii) software engineering methodology to develop information systems that enforce and control organizational constellations. The envisioned approach builds on two software engineering concepts: patterns and frameworks. Patterns are intended to abstract interaction procedures. For implementation, they ought to be plugged in a rule-driven and policy-controlled framework on top of conventional Grid Computing middleware.

To improve this situation we are developing tools and techniques to support a new approach to dynamic analyses called Distributed, Continuous Quality Assurance (DCQA). that execute around-the-world and around-the-clock, on a virtual computing pool made of up of numerous end-user machines. Our approach divides QA processes into multiple subtasks that are intelligently distributed to client machines around the world, executed by them, and their results returned to central collection sites where they are fused together to complete the overall QA process.

In this talk we will describe our approach and present the results of several feasibility studies.

Our findings can be applied in at least two scenarios: forwarding in a content-based publish/subscribe network and generalized searches on encrypted data (e.g. remote file servers, etc).

In the first part I present a technique to reason about complex planning scenarios using UCLMDA tools + an eclipse editor. In particular, I introduce a methodology to translate planning models into MOF models, where different kinds of analysis can be performed. I provide a medium-sized example (an autonomous Rover) to clarify the approach. Discussion is welcome on this approach.

In the second part I propose a methodology for testing and verifying (where possible) flight rules of planning domains. The methodology is self contained, in the sense the flight rules are verified or tested using the planner itself. More in detail:

• flight rules are characterised using patterns and encoded using LTL
• coverage conditions for specification-based testing are reviewed
• a translation of LTL formulae into planning goals is presented
• case study: verification of flight rules for the Rover scenario (see above)