SBASCO provides a new programming model for parallel and distributed numerical applications which exploits the combination of software components and skeletons. This paper presents an extension to both the model and implementation of SBASCO, so that the notion of aspect is applied in conjunction with the original paradigms. The objective is to achieve a higher level of modularity and reuse in parallel scientific codes and applications. Our aspects are managed as components which implement the (sequential or parallel) cross-cutting functionality. Aspects interact with the base code by means of connectors that express the cross-cutting nature of the target concerns. The way in which both aspect weaving and advice code execution are managed is critical for preserving the performance of applications. An implementation of the abstractions for distributed memory parallel systems based on MPI is discussed.

The open distributed processing (ODP) computational viewpoint describes the functionality of a system and its environment in terms of a configuration of objects interacting at interfaces, independently of their distribution. Quality of service (QoS) contracts and service level agreements are an integral part of any computational specification, which are specified in ODP in terms of environment contracts. Up until unified modeling language (UML) version 2, both the lack of precision in the UML definition and the semantic gap between the ODP concepts and the UML constructs hindered its application for ODP computational viewpoint modeling. With the advent of UML 2 the situation has changed, because its semantics have been more precisely defined and it now incorporates a whole new set of concepts more apt for modeling the structure and behavior of distributed systems. In this paper, we explore the benefits provided by the new extension mechanisms of UML for modeling the ODP computational specifications and, in particular, we show how ODP environment contracts can be modeled with this approach.

Wireless sensor and actor networks (WSANs) constitute a new pervasive technology. WSANs have two major requirements: coordination mechanisms for both sensor-actor and actor-actor interactions, and real-time communication to perform correct and timely actions. This paper introduces TC-WSANs, a high-level coordination model that addresses these two requirements and facilitates the application programmer task. Our proposal is based on a (hierarchical) architecture of sensor/actor clusters and the use of tuple channels to achieve communication and synchronization among sensors and actors. A tuple channel is a priority queue structure that allows data structures to be communicated both in a one-to-many and many-to-one way, facilitating the data-centric behavior of sensor queries. The characteristics of TC-WSANs and the primitives that it provides for its integration into a computational host language are presented.

Abstract This paper presents a nuclear power plant simulator kernel based on the high‐performance computing‐oriented Common Component Architecture (CCA). The approach takes advantage of both the component‐based software development and the efficient execution of parallel simulation models. The use of components improves the software life cycle and facilitates the development, maintenance and evolution of the simulator kernel, which can be adapted to different execution scenarios. Data dependencies among simulation models are resolved automatically by means of a novel algorithm, releasing the programmer from this tedious task and, as a result, making the development process easier. This work introduces the main features of the simulator kernel, describing concepts and the model on which it is based. Some preliminary results are shown that anticipate the feasibility and suitability of the proposal. Copyright © 2006 John Wiley & Sons, Ltd.

Currently, Web-based applications are no longer monolithic and isolated systems but, rather, distributed applications that need to interoperate with third-party systems, such as external Web services, LDAP repositories or legacy applications. When one component provides a service that the Web application requires, it is often not possible to bind the two systems together if they were not programmed to have compatible collaboration specifications. Modeling the adaptation between a Web application and external assets becomes therefore an essential issue in any realistic model-driven development scenario. However, most of the existing Web Engineering proposals do not take this issue into account, or they simply address it at the implementation level (in a platform-specific way). In this work, we discuss the problems involved in dealing with component adaptation within the context of Model-Driven Web Engineering and show how design patterns can help addressing it. We first identify the major interoperability problems that can happen when integrating third-party application or legacy systems into our Web systems, and then propose the mechanisms that need to be put in place at the design level to generate the appropriate specification of adapters that compensate for the possible mismatches and differences. We base our proposal on well-known design patterns as they are established solutions to recurring problems, and the generation of code from them is normally straightforward.

Abstract The increasing complexity of large‐scale distributed applications is driving the Software Engineering community to adopt new software technologies for the development of distributed systems. In this sense, the emergence of component‐based software engineering represents a significant advance towards assembling applications by plugging in pre‐fabricated components. Additionally, the principle of ‘advanced’ separation of concerns is nowadays widely applied to improve modularity, reusability and adaptability of software components. In this way, the aspect‐oriented software development paradigm separates into a new dimension, named aspect, those properties that crosscut the system ‘objects’ or ‘components’, reducing their dependencies. However, the development of software based on the composition of components and aspects is still in its early stages. Part of the reason for this is the lack of well‐defined development processes and tools that help software developers in the use of existing component and aspect‐based approaches. Therefore, the primary aim of this paper is to propose an integrated development process for deriving applications by the assembly of a set of prefabricated components and aspects. This process supports the development of Component‐Aspect Model/Dynamic Aspect‐Oriented Platform (CAM/DAOP) applications, where CAM/DAOP is a new model and platform based on components and aspects. Our intention is to show how, with the support of the integrated development process presented in this paper, it is possible to use CAM/DAOP as an alternative to current distributed platforms. Copyright © 2006 John Wiley & Sons, Ltd.

Wireless sensor and actor networks (WSANs) constitute an emerging and pervasive technology that is attracting increased interest for a wide range of applications. WSANs have two major requirements: coordination mechanisms for both sensor-actor and actor-actor interactions, and real-time communication to perform correct and timely actions. Additionally, the development of WSAN applications is notoriously difficult, due to the extreme resource limitations of nodes. This paper introduces a framework to facilitate the task of the application programmer taking into account these special characteristics of WSANs. We propose a real-time component model using light-weight components. In addition, a high-level coordination model based on tuple channels is integrated into the framework including high-level constructs that abstract the details of communication and facilitate the data-centric behavior of sensor queries.

Abstract This paper proposes the application of modern component‐oriented technologies to the development of nuclear power plant simulators. On the one hand, as a significant improvement on previous simulators, the new kernel is based on the Common Component Architecture (CCA). The use of such a high‐performance computing oriented component technology, together with a novel algorithm to automatically resolve simulation data dependencies, allows the efficient execution of both parallel and sequential simulation models. On the other hand, RT‐CORBA is employed in the development of the rest of the applications that comprise the simulator. This real‐time communication middleware not only makes the management of communications easier, but also provides the applications with real‐time capabilities. Software components used in these two ways, simulation models integrating the kernel and distributed applications from which the simulator is comprised, improve the evolution and maintenance of the entire system, as well as promoting code reusability in other projects. Copyright © 2006 John Wiley & Sons, Ltd.

Component-based software development (CBSD) represents a significant advance towards assembling systems by plugging in independent and (re)usable components. On the other hand, aspect-oriented software development (AOSD) is presently considered as a possible technology to improve the modularity and adaptability of complex and large-scale distributed systems. Both are complementary technologies, so it would be helpful to have models that combine them to take advantage of all their mutual benefits. Thus recent research has tried to combine CBSD and AOSD by considering aspects as reusable parts that can be woven and then attached to the individual components. Our contribution to the integration of these technologies is CAM, a new component and aspect model that defines components and aspects as first-order entities, together with a non-intrusive composition mechanism to plug aspects into components. The underlying infrastructure supporting CAM is the dynamic aspect-oriented platform (DAOP), a component and aspect platform that provides the usual services of distributed applications, as well as a composition mechanism to perform the plugging of software aspects into components at runtime.

Component-based software development (CBSD) has gained recognition as one of the key technologies for the construction of high-quality, evolvable, large complex systems in a timely and affordable manner. In CBSD, the development effort becomes one of gradual discovery about the components, their capabilities and the incompatibilities that arise when they are used in concert. Thus, trading becomes one of the cornerstones of CBSD. However, most of the existing methods for CBSD do not make effective use of traders. In this paper, we analyze the required features for commercial off-the-shelf (COTS) components traders, and introduce COTStrader, an Internet-based trader for COTS components. In addition, we discuss how the COTStrader can be integrated into a spiral methodology for CBSD, providing partially automated support for building COTS-based systems.

In order to study the security systems, we have developed a methodology for the application to the analysis of cryptographic protocols of the formal analysis techniques commonly used in communication protocols. In particular, we have extended the design and analysis phases with security properties. Our proposal uses a specification notation based on HMSC/MSC, which can be automatically translated into a generic SDL specification.

The usage of object-oriented methodologies in conjunction with formal description techniques has arisen as a promising way of dealing with the increasing complexity of embedded real-time systems. These methodologies are currently well supported by a set of tools that allow the specification, simulation and validation of the functional aspects of these systems. However, most of these methodologies do not take into account non-functional aspects such as hardware interaction and real-time constraints, which are especially important in the context of this kind of system. Based on our experiences in developing embedded real-time systems, we present a new methodology to design them. This methodology is based on a combination of ideas from different existing methodologies (UML, OCTOPUS, etc.) together with the integration of rate-monotonic analysis in the context of the SDL formal description technique development cycle. Additionally, in order to get this integration, a real-time execution model for SDL is presented to allow us to express hard real-time constraints. The methodology pays special attention to the transition from the object model to the task model, taking into account real-time and hardware integration issues. We also illustrate our proposal by applying it to the development of a multi-handset cordless telephone.

Traditional IDLs were defined for describing the services that objects offer, but not those services they require from other objects, nor the relative order in which they expect their methods to be called. Some of the existing proposals try to add protocol information to object interfaces, but most of them fail to do so in a modular way. In this paper we propose an extension of the CORBA IDL that uses a sugared subset of the polyadic /spl pi/-calculus for describing object service protocols, based on the concept of roles. Roles allow the modular specification of the observable behavior of CORBA objects, reducing the complexity of the compatibility tests. Our main aim is the automated checking of protocol interoperability between CORBA objects in open component-based environments, using similar techniques to those used in software architecture description and analysis. In addition, our proposal permits the study of substitutability between CORBA objects, as well as the realization of dynamic compatibility tests during their runtime execution.

Traditional IDLs were defined for describing the services that objects offer, but not those services they require from other objects, nor the relative order in which they expect their methods to be called. In this paper we propose an extension of the Common Object Request Broker Architecture (CORBA) interface description language (IDL) that uses a sugared subset of the polyadic $\pi$-calculus for describing object service protocols, aimed at the automated checking of protocol interoperability between CORBA objects in open component-based environments. In addition, some advantages and disadvantages of our proposal are discussed, as well as some of the practical limitations encountered when trying to implement and use this sort of IDL extension in open systems.

Abstract Component‐based software has become an important alternative for building applications, especially distributed ones, so it is essential to define new software development processes based on components. Within this trend, we propose a complete framework‐based method which guides application developers in exactly determining application requirements. It also guides how to build them using the compositional framework MultiTEL from the collaborative and multimedia applications domain. Although many multimedia frameworks are available, none of them offer a design methodology for understanding and adapting the framework classes or components to each derived application. By applying an architecture description language (ADL) we are able to document the framework and help designers in: constructing; reusing, and connecting components; extending the framework architecture; and adding components to meet user requirements. Tools for the automatic generation of code from the ADL specifications are also described. Copyright © 2001 John Wiley & Sons, Ltd.

Parallel genetic algorithms (PGAs) have been traditionally used to overcome the intense use of CPU and memory that serial GAs need to solve complex problems. Non-parallel GAs can be classified into two classes: panmictic and structured-population algorithms. The difference relies on whether any individual in the population can mate with any other one or not. In this work they both are considered as two reproductive loop types executed in the islands of a parallel distributed GA. Our aim is to extend the existing studies on more conventional sequential islands to other kinds of evolution. A key issue in such a distributed PGA is the migration policy. The paper investigates the influence of the migration frequency and the migrant selection in a ring of islands performing either steady-state or cellular GAs. The study uses different problem types, namely deceptive, multimodal, NP-complete, and epistatic search landscapes, in order to provide a wide spectrum of problem difficulty to sustain the results. Large isolation values and random selection of the migrants are shown to provide a better success rate and a lower number of visited points. Also, some differences are pointed out in the behavior of panmictic and structured populations. Finally, the results show the advantages of an asynchronous migration step in the distributed GA.

This paper analyzes the detection of stagnation states in iterated local search algorithms. This is done considering elements such as the population size, the length of the encoding and the number of observed non-improving iterations. This analysis isolates the features of the target problem within one parameter for which three different estimations are given: two static a priori estimations and a dynamic approach. In the latter case, a stochastic reverse hill climbing algorithm is used to extract information from the fitness landscape. The applicability of these estimations is studied and exemplified on different problems.

This paper analyzes different representations for permutation flowshop problems. This is done using forma analysis to assess the quality of these representations with respect to makespan optimization. Classical recombination operators are studied and empirically evaluated in this context. It is shown that the best operators work on representations in which absolute positions of tasks are relevant. Subsequently, some new operators operating on these representations are proposed. These new operators are designed to exhibit specific properties regarding implicit mutation and forma transmission. Their performance is shown to be competitive with traditional operators.

We present a new coordination model and a small set of programming notations for distributed programming, which can be integrated into very different programming languages (imperative, declarative or object-oriented). Together they allow the development of distributed programs in a compositional way, by assembling different independent pieces of (possibly pre-existing and heterogeneous) code. This approach is similar to many other proposals such an Linda, PCN, CC++, for example, allowing multiparadigm and multilingual integration, and provides a powerful set of concurrent programming techniques, inherited from Concurrent Logic Languages (CLLs), which can be efficiently implemented in distributed systems. The coordination model is based on logic channels; these evolved from the concept of shared logic variables used in CLLs which, with the same expressive power, can be more efficiently implemented in distributed systems. We introduce this coordination model, giving some illustrative examples to show its expressiveness; some implementation issues are also commented on.

A dataflow model to obtain parallelism in the evaluation of Datalog is presented. This model performs query evaluation as a dataflow through a network of communicating concurrent processes capable of solving the query. This process network is based on the intensional database definition, plus the concrete query to be evaluated. A cost model to cope with the load balancing problem is described. A load balancing algorithm is presented and discussed. An algorithm to optimize the evaluation is described which is based on process network rewriting. This utilizes information in the query bindings to be evaluated in order to optimize the dataflow graph.

The high complexity of distributed computer systems requires new methodologies and languages especially designed for the characteristics of these systems. Declarative languages have been proposed as a promising alternative because they provide a way of leaving aside system details. However, the behaviour of reactive systems cannot be described in pure relational or functional terms. We propose a declarative environment for distributed programming based on the concurrent logic language Parlog, which has the capability of expressing concurrence, communication and non-determinism in a very natural way. That is, the intrinsic parallel semantics of the concurrent logic languages make them appropriate for distributed programming. The proposed environment is particularly suitable for loosely coupled systems and it contains mechanisms for distributed process control, and both real-time and object-oriented design. Each of these characteristics is achieved by the integration, in the framework of the underlying concurrent logic language, of real-time and distributed processing control primitives and object-oriented constructions. From this viewpoint, an operational semantics is defined and some implementation issues are discussed.