How easy is it to use in practice? What are the pitfalls? We then reveal the initial results of a project to explore the issues surrounding installing, configuring and securing an exemplar OGSA Middleware (GT3) across organisations, and give some preliminary performance indications.

What potential does Grid middleware have to: (1) provide insight into different ways of using Service Oriented Architectures, and (2) support automatic deployment and debugging? We present a more sophisticated approach for evaluating GT3, using an architectural/role/scenario based comparison of two alternative designs for a Grid application, implemented using different GT3 mechanisms.

Finally we ponder the possibilities for automatic Grid deployment, and an approach for enhancing Grid debugging support aided by knowledge of deployment context.

Consistency checking of documents encompasses the writing of constraints between related documents, identifying, locating and repairing of inconsistencies. After a consistency check is performed, a number of inconsistencies may be identified and located. A tool is then used to analyse constraints and generate repair actions. Consequently, a set of at least two repair actions is generated to remove inconsistency. There may be to two reasons for this: First, inconsistency occurs between at least two elements and second, the mechanism for generating repair actions is based on the first order logic system, which is undecidable. Moreover, all generated repair actions for a particular constraint, may equally repair that inconsistency. So, which repair action should the user select? This is a conflict.

In this seminar I discuss the use of strategies (heuristics) for supporting the user in selecting a repair action. This selected repair action should give the user a level of confidence.

Experience shows that when products of a family are used in similar domains, extensions present commonalities, which should be re-integrated to enhance the features of the base framework. This is not a straightforward process as candidate changes may cause unexpected errors if applied to existing deployments. Particularly, when considering database schema variations, code impact may happen not only static SQL queries embedded in the code, but also dynamically generated SQL queries and associated code.

This seminar will argue that this is a real problem facing the software industry across a variety of domains. This will be enforced by two examples: a commercial product family in the financial area and set of related systems in bioinformatics. In addition, it will be discussed a research that attempts to partially solve the problem and its results when applied to one of the case studies above.

In this talk, we will introduce a novel approach where event routing relies on deterministic decisions driven by a limited view on the subscription information and, when this is not sufficient, resorts to probabilistic decisions performed by selecting links at random. Algorithm's description will be followed by a brief overview of simulation results, aimed at showing that the particular mix of deterministic and probabilistic decisions we put forth in this work is very effective at providing high event delivery and low overhead in highly dynamic scenarios, without sacrificing scalability

Our proposition starts with the service specification that not only takes into account the qualities of service provided to the user, but also the introduced resource assumption on the service host. With the above service specification, we introduce an incentive-compatible mechanism for service allocation and the associated distributed reputation mechanism to stimulate and facilitatethe service provision/consumption in selfish mobile ad hoc networks. Additionally, to alleviate the networks' dynamic topology, a middleware group service is designed based on various attributes of group membership for handling group initialization and dynamics.

Lack of cooperation seems to be one of the the biggest obstacles for the success of these networks. Without incentives for cooperation, most participating nodes will act as freeloaders and will not provide services to others but will only consume services, and so the overall service quality is only a fraction of what it could be.

In the talk, we will focus on peer-to-peer file sharing networks and look at some of the already existing incentives schemes, we will analyze the problem using game theory, and we will look at a possible solution that will hopefully be more lighweight and flexible than existing approaches.

The question can be answered at two levels. Firstly, what are the technical qualities of the product, what is it about Saxon as a piece of software that makes it tick? Secondly, what was it about the project that enabled these qualities to be delivered successfully: are there any lessons one can learn about engineering processes, project management, or marketing? As the author will explain, it certainly hasn't been a conventional project.

Michael Kay started the development of Saxon while at ICL, where he had worked for 24 years, designing a series of software products and reaching the rank of ICL Fellow. He had previously gained a Ph.D for work on database management systems at the University of Cambridge. After ICL he joined Software AG for three years, spending most of his time on W3C standards work (and Saxon!) and then left at the start of 2004 to create his own company, Saxonica.

The seminar introduces the topic of early performance validation of software systems and presents our methodology that permits quantitative reasoning on performance aspects at the software architecture level. This approach, differently from other methodologies, does not require the specification of the hardware platform aspects. By filling the knowledge gap between the software and the performance worlds, the approach systematically generates a QN model representing the software architecture ready to be evaluated by performance solvers.

We present an approach to dynamically extending applications based on "plugin" components. Plugins are optional components which can be used to enable the dynamic construction of flexible and complex systems. We present a model of plugin systems and a prototype implementation of a framework for managing them. We show how our model integrates closely with an object-oriented programming language, and requires minimal effort on behalf of the developer to create components that will work with the plugin framework.

In order to ensure the correctness of dynamic systems, some techniques for modelling and analysis are required. We generate models combining the structural and behavioural aspects of prospective system configurations and use model checking to discard those configurations that violate desired behavioural properties. In this way behavioural concerns can be used in choosing between potential configurations. By integrating our modelling and analysis techniques into the reconfiguration process, we can use the analysis that our technique provides to guide self-organisation and produce systems that behave in a predictable way.

Currently, the pertinence of event-based technology to a wider range of applications is becoming increasingly evident. Upcoming applications for distributed event notifications are mobile location-based services (e.g. traveller information systems), publish/subscribe for semantic web content, and integration into meta-software that supports information document repositories. The main challenge in these new applications is the need to flexibly support a variety of non-regular network setups, new information models, and integration with external services.

This talk will introduce our work towards meeting these challenges. We will start from the example of a generic publish/subscribe service for an open meta-software for digital libraries. New ways had to be found for supporting a fragmented network of distributed digital library servers. We will describe the design and usage of a distributed Directory Service and introduce our hybrid approach using two networks and a combination of different distributed routing strategies for event filtering. We will also touch upon the issue of approximative filtering of XML documents and the integration of event-based notification with location-based serices for context-based information delivery.

This talk explores the use of ENS for upcoming applications for information delivery. We discuss the transfer of event notification concepts into new applications, such as the the Semantic Web, change management, and mobile information delivery. This talk also briefly introduces the research carried out in the 'Information Systems and Databases' research group at the University of Waikato, the top-ranked university for computer science research in New Zealand.

In this presentation we show how the policy refinement approach we have developed can be applied to the domain of DiffServ QoS management. We make use of goal elaboration and abductive reasoning to derive strategies that will achieve a given high-level goal. By combining these strategies with events and constraints, we show how policies can be refined, and what tool support can be provided for the refinement process using examples from the QoS management domain.

In this talk, we describe the visualization of software evolution by taking advantage of this logical coupling introduced by modifications and bug fixes over time. We show different views on the evolution of a software system: (a) views based on quantitative analysis of growth and change rates; (b) dependencies introduced by logical couplings and their visualization; (c) feature evolution views; and (d) integrated views that combine several evolution metrics.

As a result, our approach helps to uncover hidden dependencies between software parts and presents them in easy-to-assess visual form. Such visualizations can indicate locations of design erosion in the architectural evolution of a software system. We have applied our approach to several large software systems including Mozilla and its CVS and Bugzilla data to show the effectiveness of our approach.

1. the motivation;
2. failure pattern based testing;
3. various principles that could enforce an even spread of test cases, and the advantages and disadvantages of their corresponding ART implementations; and
4. comparison of random testing and adaptive random testing with respect to various testing effectiveness measures.