With developments in grid computing and Web based data storage the task of orchestrating computations is becoming ever more difficult. Identifying which of the available computation resources and datasets to use is not trivial: it requires reasoning about the problem itself and the cost of moving data to complete the computation efficiently. This paper presents a conceptual notation and performance model that enables e-researchers to reason about their computations and make choices about the best use of resources.

In modern systems data is distributed and replicated. Its ownership is also distributed amongst a variety of stakeholders with differing requirements and expectations. A consequence is applications inevitably find data they need is missing or contains contradictions and inconsistencies from time to time leaving them unable to progress within their domain. Techniques such as transactions can help but are not enough as they rely on being able to impose their own consistency rules on data and this isn't always possible. What is required is an ability for applications to move forward despite the problems in local data by applying higher-level reasoning to that data. This paper describes DataWarp, a technique which empowers applications to make progress in such environments and illustrates its use to specify an efficient personal grid workflow scheduler.

The papers in this special issue paint a representative picture of current research issues in Grid computing, in the form of a selection of papers from the Third International Workshop on Middleware for Grid Computing (MGC) [1].All of the papers have been extended and thoroughly revised from the original workshop versions.Previous special issues on selected papers of [2] and [3] have been published in [4] and [5].The papers collected in this special issue address some current issues in middleware for Grid computing.Paventhan et al. [6] describe CoG toolkits enabling Grid application development using commodity development frameworks.Desertot et al. [7] describe how Grid environments can lead to powerful architectures and show that this is the case for edge computing.Zhao et al. [8] propose SVGrid, a Secure Virtual Grid running environment, to protect sensitive files and networks for Grid computers.Santos et al. [9] analyze three accounting schemes to support the implementation of an autonomous reputation-based allocation mechanism for peer-to-peer Grids.Nascimento et al. [10] present the allocation of application processes to the available processors by employing hybrid scheduling in an EasyGrid AMS environment to improve the performance of Grid MPI applications.Yarmolenko and Sakellariou [11] discuss the extensions to the WS-Agreement specification, and their experiences and conclusions are drawn are in the context of agreement-based job management systems.Vargas et al. [12] discuss the assumption of submitting a huge number of tasks and present an elegant solution to the problem by a hierarchical model that can distribute the submission load.In the remainder of this editorial we would like to take a step back from the current research topics to articulate a vision of what Grid computing might be like in the next decade or two.This 'potential future' is influenced by a middleware perspective (as opposed to a Grid user perspective) and is therefore necessarily biased.In particular, we will lay emphasis on the architecture of the 'lowlevel' Grid infrastructure in terms of computer systems, their interconnectivity, and their system-level software.The motivation for offering this vision is to counterbalance, in a small way, the tendency for Grid research efforts to focus on short-term development.In addition to the pragmatic application development that is indeed important and necessary, the long-term health of Grid computing will require a complementary thread of architectural work not unduly influenced by short-term imperatives.

Mobile code computation has lead to a new paradigm of distributed computation. A mobile process can move from site to site and interact with the resources as a local process. To prevent the misuse of resources, authentication and authorization need to be dealt with. Many modeling languages have been proposed to model distributed computation; Ambient Calculus (Cardelli, 1998) is one of them. Ambient Calculus, a type of process calculus, can be used to model boundary crossing activities in a mathematical notation. SJAN, a modeling language, extends the basic idea of Ambient Calculus, but it has a simple notation, design and representation. SJAN can be verified by J-Ambient, a JAVA implementation, to certify the correctness of the model. In this paper, the authors introduced SJAN notation and J-Ambient. SJAN could be also used to model grid computation and provides the security consideration. Thus, finally, several security scenarios in SJAN were addressed to show its functionality.

Abstract The U.K. e‐Science Programme is a £250 million, five‐year initiative which has funded over 100 projects. These application‐led projects are underpinned by an emerging set of core middleware services that allow the coordinated, collaborative use of distributed resources. This set of middleware services runs on top of the research network and beneath the applications we call the ‘Grid’. Grid middleware is currently in transition from pre‐Web Service versions to a new version based on Web Services. Unfortunately, only a very basic set of Web Services embodied in the Web Services Interoperability proposal, WS‐I, are agreed by most IT companies. IBM and others have submitted proposals for Web Services for Grids—the Web Services ResourceFramework and Web Services Notification specifications—to the OASIS organization for standardization. This process could take up to 12 months from March 2004 and the specifications are subject to debate and potentially significant changes. Since several significant U.K. e‐Science projects come to an end before the end of this process, the U.K. needs to develop a strategy that will protect the U.K.'s investment in Grid middleware by informing the Open Middleware Infrastructure Institute's (OMII) roadmap and U.K. middleware repository in Southampton. This paper sets out an evolutionary roadmap that will allow us to capture generic middleware components from projects in a form that will facilitate migration or interoperability with the emerging Grid Web Services standards and with ongoing OGSA developments. In this paper we therefore define a set of Web Services specifications, which we call ‘WS‐I+’ to reflect the fact that this is a larger set than currently accepted by WS‐I, that we believe will enable us to achieve the twin goals of capturing these components and facilitating migration to future standards. We believe that the extra Web Services specifications we have included in WS‐I+ are both helpful in building e‐Science Grids and likely to be widely accepted. Copyright © 2005 John Wiley & Sons, Ltd.

Many developers who could benefit from building and analysing formal models of their systems are deterred from doing so by the process algebra style input languages of formal modelling languages which they find difficult to read and understand. This barrier to the adoption of formal modelling techniques can be significantly reduced if the process algebra is replaced with a graphical notation supported by a model generation tool. However, whilst having a diagrammatic base for the language appeals to the novice modeller, the diagrams can become cluttered for larger models. In this paper we address the issues of how to add hierarchical features to a graphical language without losing the fundamental benefits and appeal of having the graphical interface to the language. We illustrate these ideas using an existing formal modelling language

With the rise of distributed e-commerce in recent years, demand for automated negotiation has increased. In turn, this has facilitated a demand for ever more complex algorithms to conduct these negotiations. As the complexity of these algorithms increases, our ability to reason about and predict their behaviour in an ever larger and more diverse negotiation environment decreases. In addition, with the proliferation of internet-based negotiation, any algorithm also has to contend with potential reliability issues in the underlying message-passing infrastructure. These factors can create problems for building these algorithms, which need to incorporate methods for survival as well as negotiation. This paper proposes a simple yet effective framework for integrating survivability into negotiators, so they are better able to withstand imperfections in their environment. Results of an experiment are provided which show how the stability of a negotiation community is affected by incorporating an example survival behaviour into negotiators operating in an environment developed to support this framework.

When a new component is added to an existing, distributed system, it has to co-operate with existing components in a way that doesn't interfere badly with the original system. Adding new components to an existing system is simplified if their communication is asynchronous. It allows for looser coupling. Unfortunately, the fact that the communication between components is asynchronous adds to the difficulty of reasoning about their behaviour This paper gives an illustrative example of a simple distributed system with asynchronous behaviour and discusses how its behaviour can be described and reasoned about in terms of goals. This formalises what we believe to be contemporary engineering practice. Experimental support for reasoning, including animation, is particularly appropriate and practical in these circumstances, because the properties which we must reason about are emergent rather than compositional.

There is a continuing need for software engineers to design better-quality systems more quickly. Component-based technologies promise to make this possible, but modern systems are too complex for a full analysis of their behaviour to be practical. We propose that a reasonable alternative is to analyse abstract models of the essential features of a system. Since these models are abstract, they need contain only those details that are relevant to the aspect of the system under consideration. Consequently, they can be small enough to be constructed quickly and analysed thoroughly using formal methods. Tools are required which are accessible to the novice but which remain powerful enough to build models with a formal foundation so that they can be used by system designers who have limited expertise in the use of formal methods. We propose our tool, RolEnact, as a candidate for this role.

A dynamic system is one which changes its configuration as it runs. It is a system into which we can drop new components which then cooperate with the existing ones. Such systems are necessarily built from reusable components, since as soon as the system is reconfigured to use some new components, those new components must reuse the existing, still running, ones. Design of reusable components in this context is an important problem. We suggest three laws which such reusable components might be required to obey, if dynamic systems are to be effective and to be economically built. We illustrate our conjecture that the laws are effective by describing a generic architecture based on the familiar registry services of COM/OLE or CORBA and by describing a simple point of sale system built according to this architecture. We conclude, of course, that some interesting open questions remain. But we suggest that an approach to reuse based on refining the three laws is a promising direction for system architecture to take.

The cost-effective and reliable evolution of systems is a significant software engineering challenge. Our approach is based on a combination of product modelling, process modelling and software metrics. We describe an empirical laboratory study following the evolution of three releases of a publicly available exemplar system. Analysis of the metrics which were collected improves our understanding of how a system evolves. Process metrics can provide information about how the product is put together, and product metrics suggest explanations for the development processes observed.

When trying to describe the behaviour of large systems, such as the business processes of large enterprises, we often adopt diagramming techniques based on derivatives of data flow diagrams. For very complex systems such diagramming techniques suffer from the inability to abstract uniformly from arbitrary subcollections of components. We present an extension to conventional diagramming techniques which solves this problem. We describe how we have applied this technique to some very complex business systems and illustrate its main points with a simple example. While we have used the notation to present models of business processes we conclude that it is applicable to the description of behaviour in any complex system of processes.

A different way to execute pure LISP programs is presented. It delays the evaluation of parameters and list structures without ever having to perform more evaluation steps than the usual method. Although the central idea can be found in earlier work this paper is of interest since it treats a rather well-known language and works out an algorithm which avoids full substitution. A partial correctness proof using Scott-Strachey semantics is sketched in a later section.