As C/C++ has been widely used for several decades, a huge amount of C/C++ code is available. However, when using a modern processor having several cores, legacy code needs to be adapted for it to achieve the best performances. Modifying C/C++ code manually or automatically is not an easy task, given the complexity of the language. Moreover, it is paramount to check that the modified version keeps the emerging behaviour of the old one, except for the better performances. This paper proposes an automatic approach and the resulting tools to transform existing legacy C/C++ code for achieving parallel execution. The approach includes the automatic generation of test cases, customised for the code that has been converted into a parallel version. Test cases are auto-evaluating, hence a completely automatic cycle of code transformation, test generation, behavioural checking, has been achieved.

A large amount of test cases is very useful to check the correctness of a software system while it is developed. Often a considerable time is dedicated by human programmers to designing effective test cases. This paper proposes an approach for automatically generating test cases tailored to the characteristics of the code under test. For this, the classes of a software system to be tested are characterised by a static code analysis aiming at summarising and representing their behaviour. As test cases check the behaviour of code, classes that exhibit a close behaviour may be checked using similar test cases. Therefore, in the approach proposed, for classes having a comparable behaviour, test cases are generated by taking as a template the test cases available for one of the classes among the similar ones. The approach has been assessed on a few open source projects and has proved to be viable for generating applicable and effective test cases for the classes.

Large software systems need to be evolved to cope with their changing environment, e.g. to incorporate new functionalities, or to better use the underlying hardware. This paper proposes an approach to reveal which parts of a system can be isolated in a module, and which parts can potentially run in parallel. We use a graph representation for the data extracted from a target software system and for the queries that express our desired analyses. Then we employ a matching framework performing queries on the target graph. The data representation is highly flexible and supports several analyses, shown in our experiments.

Some support is needed in order to shun the possibility that sensitive data handled by applications are sent to improper destinations. Although apps running on Android OS declare the accessed services, once the user accepts, the application receives complete permissions and may use sensitive data improperly. Some tools have emerged to check data access and flow, however such tools are either based on static analysis or dynamic tracking. The former brings no overhead at run-time, but is less precise, the latter can bring a costly overhead during execution, having to monitor any access to sensitive data and all destinations. Our approach is innovative in that it takes advantage of static analysis and then monitors at run-time only data paths that potentially give sensitive data out. The correspondent tool is tailored to Android environment, tool-chain, libraries, and typical requirements that applications have to satisfy.

Physical surveys in many fields use segmented detectors to sense some physical quantities. In many cases, physical phenomena produce raw data with a rate higher than that possible to identify interesting events and organize data when using a single host. This paper proposes a distributed and parallel processing system that greatly reduces the time needed for identifying events and organizing data. Moreover, our solution can be scaled according to the experiment at hand. This opens the possibility to analyse a wider range of physical phenomena, increases the accuracy of observations, and makes it possible to organize widely distributed experiments involving different laboratories or facilities at the same time. The proposed solution consists of a parallel algorithm able to quickly process patterns sensed by a segmented detector, hence achieving identification and data cataloguing. Moreover, a distributed software architecture properly taps into cloud-based resources to handle the massive amount of raw data generated by an experiment. The results in terms of performances for the proposed distributed and parallel solution have shown a relevant speed up for the required processing.

Advanced smart grids have several power sources that contribute with their own irregular dynamic to the power production, while load nodes have another dynamic. Several factors have to be considered when using the owned power sources for satisfying the demand, i.e., production rate, battery charge and status, variable cost of externally bought energy, and so on. The objective of this paper is to develop appropriate neural network architectures that automatically and continuously govern power production and dispatch, in order to maximize the overall benefit over a long time. Such a control will improve the fundamental work of a smart grid. For this, status data of several components have to be gathered, and then an estimate of future power production and demand is needed. Hence, the neural network-driven forecasts are apt in this paper for renewable nonprogrammable energy sources. Then, the produced energy as well as the stored one can be supplied to consumers inside a smart grid, by means of digital technology. Among the sought benefits, reduced costs and increasing reliability and transparency are paramount.

In this work, we propose an algorithm, called E-Learning Ontology Enrichment (ELOE), to derive a global representation from the personal ontologies of different agents present in an e-Learning MAS. Using ELOE, each agent of a MAS-based e-Learning system can autonomously enrich its own ontology by using semantic negotiation and, at the same time, it can access to the global ontology to have a view of the terms used by all the other agents. Each term of the global ontology is associated with a set of meanings, and each meaning is associated with the set of agents that have used it. This way an agent, having to send a message to an interlocutor, is able of choosing from the global ontology the most suitable term with the most appropriate meaning. Only if the agent does not find in the global ontology the appropriate term, it will use a personal term that probably will lead to a new semantic negotiation process. This way, the use of the onerous task of the semantic negotiation will be limited to only the strictly necessary situations, and consequently the whole communication cost is decreased.

Thematic groups are gaining a lot of attention and high centrality in OSNs, as users share opinions and/or mutually collaborate for reaching their targets. Since users can be affiliated with groups belonging to different social networks, they can be supported by personal software agents able to perform activities aimed at supporting relationships and mutual cooperation among heterogeneous OSNs thematic groups. Basically software agents can encode users profiles with detailed information to be related with specific groups. This work discusses a multi-agent framework whose structure focuses on the role of software agents and the use of a common, shared dictionary for each group. Personal software agents are associated to OSN users to share knowledge for a specific theme for a number of groups related to that topic. Group agents are defined to support each group on each OSN by interacting with personal agents to manage group affiliation and enrich the common dictionaries of their own groups. The common dictionary of the group is a key element to provide knowledge sharing and interoperability between personal and group agents. In the proposed approach each user agent is able to personalize its own dictionary and enrich that of its own groups by means of selected categories.

In this paper a novel approach to automatic medical signal diagnosis is proposed. The authors propose a solution based on the application of Computational Intelligence (CI) to assist classification procedure based on Neural Network (NN) attempt. Experiments have been performed with the proposed CI solution applied on retrieved digital signals of various heart actions to help in missing or incomplete data gathering. Then this knowledge was applied as a training set in proposed NN classifier used to recognize potential dangers and therefore work as Decision Support System (DSS) designed for medical purposes.

Learning software agents are able to assist Cloud providers in taking decisions about resource management at any level, as they are able to collect knowledge and improve their performances over time by means of learning strategies. On the other hand Cloud Federations allow providers to share computational infrastructures in order to build a distributed, interoperable multi-cloud context. In this work we present an evolutionary approach based on agent cloning, i.e. a mechanism of agent reproduction allowing providers to substitute an "unsatisfactory" agent acting in a "cloud context" with a clone of an existing agent having a suitable knowledge and a good reputation in the multi-cloud context. By this approach, cloud agents performances can be improved because they are substituted with agent clones that have shown a better behaviour.

Cloud Computing is a versatile computing paradigm capable of attracting a wide variety of applications. However, the necessity to provide a wide range of complex services led providers to establish mutual agreements to provide large-scale distributed multi-cloud environments. Providers gain the opportunity to compose service workflows that are effective and efficient, taking resources of their own competitors, and the capability to satisfy unexpected workload peaks. In this paper, we propose a reputation-based model aiming at supporting the service composition by considering measures of QoS collected by the measuring systems, and reputation measures collected with the customers by means of users feedback.

Summary The main responsibilities of a web server are to listen from the communication channel and to prepare replies to requests. Additional responsibilities include adapting processing activities, for example, through scheduling or request filtering, so as to satisfy Quality of Service (QoS) requirements. Typical QoS‐related concerns address behavioural constraints (e.g. response time bounds, satisfiable by scheduling the most urgent requests first) and resource monitoring, for optimal use. Although such concerns are spread across several web server components, they should be handled separately from communication‐related ones, for the sake of modularity. For this purpose, we advocate recourse to aspect‐oriented programming and illustrate it by showing how a QoS‐related layer can be smoothly superimposed on top of a well‐known, unmodified, web server Jigsaw. As part of the provided support, requests are assessed and partitioned into those that can be appropriately handled by using local resources and those needing further resources. For the latter requests, cloud‐based resources are gathered. Aspect‐orientation enables new QoS‐related code to be separated from web server modules so as to keep existing code unaltered, while runtime behaviour is modified with the measures needed to handle QoS concerns. Copyright © 2013 John Wiley & Sons, Ltd.

Cloud Computing is the reference model for IT specialists offering high quality services in a pay-per-use fashion. Architectures and protocols for Cloud Federations have been designed to meet emerging requirements of Cloud infrastructure. In such a context IT providers can mutually rent virtual resources and exchange metadata in order to get more opportunity. In this paper we define VST - Virtual machine Software Tracking - as the process of extracting detailed information about software running in virtual machines in a transparent manner. Coupling VST data with those of resource consumption can help IaaS providers to be more precise when assigning resources to VMs. Moreover, sharing VST information across the cloud federation can help IaaS providers to get decision about VM placement in time. For this aim we provide an agent based architecture for collecting and sharing VST data in a Cloud Federation, together with a skeleton implementation by which the architecture has been tested.

This paper proposes a trust model for a competitive federation of Cloud computing systems. The reference scenario is a large-scale environment in which different Cloud providers compete in offering their pay-per-use XaaS (Anything as a Service) resources to the various users. In this context, to obtain the assignment of a user request, providers may state to possess more resources than the amount really available: the result could be the provisioning of a services with a lower QoS than expected. A trust model is thus mandatory to help the requester to properly choose the adequate provider on the basis of (i) the reliability shown in the past in providing services, and (ii) the reputation the provider has to other users. In this sense, the paper presents an extension to the RRAF model, which has been suitably adapted to a large-scale environment by means of the introduction of a multi-dimensional approach which fits the various reliability issues, typical of Cloud computing systems.

A Java Card Virtual Machine applet running on smart cards may be subject to tampering. We protect existing applets by encoding additional lists representing specific instructions which may be the targets of a variety of attacks. The lists are specifically encoded to be a viable solution in limited smart cards hardware. Our modified virtual machine before executing a fetched instruction checks the lists to verify that it has not been modified, blocking the execution if a modification is detected.

In an agent-based cloud scenario, when two agents, provided with different ontologies exchange messages to negotiate a Service Level Agreement for a cloud service, they could fail to understand both the correct meaning of their messages and the offered service quality, due to the differences present in their ontologies. In all these cases, a semantic negotiation is required to reciprocally making understandable the messages exchanged about the cloud service characteristics. In this work we propose a protocol for supporting the SLA negotiation process, involving semantic issues, which do not require the use of a common global agent ontology sharing knowledge in advance. In detail, this protocol considers that each agent is able to partition the other agents based on both their expertise in cloud services and similarity with their own ontologies.

The BitTorrent mechanism effectively spreads file fragments by copying the rarest fragments first. We propose to apply a mathematical model for the diffusion of fragments on a P2P in order to take into account both the effects of peer distances and the changing availability of peers while time goes on. Moreover, we manage to provide a forecast on the availability of a torrent thanks to a neural network that models the behaviour of peers on the P2P system. The combination of the mathematical model and the neural network provides a solution for choosing file fragments that need to be copied first, in order to ensure their continuous availability, counteracting possible disconnections by some peers.

For improving the modularity of a large software system, metrics can be valuable to help finding refactoring opportunities for classes. We define a novel metric that is intended to suggest how closely connected are the elements of a class. The metric characterises the strength of the coupling between methods of a class, based on invocations and the size of the parameters involved, as well as attribute accesses. The assessment of the strength of interactions turns out to be valuable in providing an indication on the possible changes that classes need to become more modular and prone to be reused. According to the computed metric and the assessment of system-wide relationships between classes, we are able to suggest Extract Class refactoring opportunities. The capability of the proposed approach to evaluate object-oriented systems is demonstrated by analysing a large software system.

This paper describes GCS (GPU-aware ComplexSim), a simulation framework for complex systems which is capable of executing on GPUs exploiting the CUDA programming model. GCS is based on an architecture similar to a previous work, ComplexSim, which provides simulation functionalities on symmetric multiprocessing (SMP) systems. With the current architecture of GCS, the simulation of the complex system run on GPUs, while tasks related to graph analysis still run on the host, by exploiting the embedded multi-thread engine of ComplexSim. The user code can be provided as a behaviour function, without taking into account issues related to task parallelisation, which are managed by the engine of GCS. In GCS, network data -" as links and mailboxes -" are organised as SoA (Structure of Array) to deal with the constraints and optimisation issues related to GPU architecture and the CUDA programming model. Moreover nodes attributes are defined by the user as in the case of ComplexSim, but GCS automatically organises them into SoA. GCS exhibits a significant improvement, in terms of simulation times, if compared to ComplexSim running on a SMP system.

For large software systems, refactoring activities can be a challenging task, since for keeping component complexity under control the overall architecture as well as many details of each component have to be considered. Product metrics are therefore often used to quantify several parameters related to the modularity of a software system. This paper devises an approach for automatically suggesting refactoring opportunities on large software systems. We show that by assessing metrics for all components, move methods refactoring can be suggested in such a way to improve modularity of several components at once, without hindering any other. However, computing metrics for large software systems, comprising thousands of classes or more, can be a time consuming task when performed on a single CPU. For this, we propose a solution that computes metrics by resorting to GPU, hence greatly shortening computation time. Thanks to our approach precise knowledge on several properties of the system can be continuously gathered while the system evolves, hence assisting developers to quickly assess several solutions for reducing modularity issues.

This paper describes Complex Sim, a C-based simulation framework aiming at providing a simple and powerful support to the study of complex networks and P2P protocols evolution by means of simulations on symmetric multiprocessing (SMP) systems. The lower architectural layer of complex Sim, the Parallel Simulation Kernel, includes a complete support for multi-threading which allows to gain a speedup when running simulations on SMP systems. The Parallel Simulation Kernel allows to define and schedule (parallel) tasks and events with a simple API, without dealing with the management of threads, which are hidden by the simulation kernel itself. The Complex Network Data & Runtime is the architectural upper layer. It allows to define a complex network or P2P system model as a graph of entities with user-defined attributes and runtime behavior. By means of the API of Complex Sim, the user code is able to simulate the evolution of its own model by focusing only on the run-time behavior of the network and the nodes, without necessary dealing with aspects such as graph management, message exchange between nodes, event management, task/thread scheduling.

Design patterns are an invaluable resource for developers. Yet, for some of them the implementation of an application concern and the code needed to enforce the design pattern solution can be tangled within the same class. This potent ially makes classes more complex, more prone to changes and less reusable. In order to keep the complexity of classes under manageable levels, this paper proposes a solution based on aspect-orientation. Our solution makes aspects and application classes independent of each other, while connecting code is used to concisely express the role played by classes within design patterns. Developers needing to modify the role of an application class should only update such connecting code, thus keeping changes to application code to a minimum. The performance overhead of such an approach is evaluated and compared with the standard implementation.

While updating a software system, it is paramount to safeguard the consistency of execution and let as many operations as possible execute undisturbed in order to minimise disruption. This paper proposes a framework that supports transparent dynamic updates of distributed systems consisting of Java classes. This framework aims at: (i) ensuring the consistency of the execution flow, and (ii) handling coordination issues concerning the update of the distributed parts. The operations of the framework are transparent with respect to the system to be updated, thanks to appropriate selective rewriting of bytecode performed at load-time. Consistency of the execution flow has been obtained by devising appropriate means to check and selectively block execution on components of the running system.

This paper presents a novel approach for resource finding and job allocation in a computational Grid. The technique proposed, called HYGRA for HYperspace-based Grid Resource Allocation, organises Grid nodes in a peer-to-peer architecture by building an overlay network in which each node is virtually connected to one or more neighbours. HYGRA is strongly based on spatial computing concepts: the available amount of each resource type is used as a geometric coordinate in a virtual Euclidean hyperspace. Therefore each Grid node is represented as a point in the hyperspace, on the basis of the amount of its free resources. A job request is also represented as a point in this hyperspace, according to the resource amounts needed for job execution. Thus, in this model, finding a Grid node suitable for execution of a job request means navigating the said resource hyperspace. Node search goes from neighbour to neighbour, following the overlay links trying to minimize the Euclidean distance between the current node and the target point representing the job, until the node nearest to it is found. The paper describes the algorithms for overlay construction and resource finding and assesses their validity and performances by means of simulation.

Abstract Developing a distributed application in a Grid context is likely to require considerable effort, whether to evolve existing code or to upgrade programmers' skills, for the sake of adapting to Grid‐specific communication technologies. As a solution, targeted to the Java technology, this paper proposes HiC, a high‐level communication infrastructure, which hides the low‐level data transfer mechanisms and hides concerns about them from applications. HiC adheres to a service‐aware, connection‐oriented, object stream paradigm. It can easily cater for a new data‐transfer technology, without any impact on the application built on top of it and, furthermore, without undergoing much adaptation itself. Architecturally, HiC consists of two layers. The upper layer allows software to obtain remote services through simple but powerful abstractions, while the lower layer provides the upper layer with uniform access to a specific underlying data‐transfer technology, such as GridRPC and XIO. The performance of HiC has been evaluated, and found to be acceptable even for relatively small amounts of data and the faster XIO data transfer. A standard interfacing architecture is also proposed, whereby all dependencies on HiC of user software can be confined within just an ‘intermediary’ pair per service. Furthermore, HiC has proven useful as a communication infrastructure for our ReD reflective framework for transparent distributed object allocation. The combination of HiC and ReD affords an advantageous synergy, which frees developers from the concerns of retargeting ReD to specific transfer technologies, and implementing the intermediaries between an application and HiC. Copyright © 2006 John Wiley & Sons, Ltd.

The aims of this research are to introduce a new transparent control paradigm and to consolidate Grid resources by a statistical approach based on Agents and on Queuing Theory. These goals are obtained through the creation of a new category of Agents called "Prophet Agents" with an agent-based peer-to-peer framework named JADE, created using the Java programming language. The goal of Prophet Agents inside a Grid is to estimate workload and completion time of a given job class in a specific class of servers. Moreover, agents are used to automate the "matchmaking" process and to consolidate Grid resources by adding new computing servers if necessary.

Abstract The dynamics of resource request rates in a Grid system can be wide ranging, to the point that request peaks for a single resource can be difficult to handle and end up greatly increasing the response time. Once a request has been submitted by a client, this has to cope with the potential overload arising. However, it is impractical to cure overload once it takes place by negotiating a different service or finding an equivalent resource, since the client would then bear the delay due to negotiation and re‐submission. Instead, in order to effectively exploit Grid resources, it is crucial that applications perform reservation of resources before using them. Reservation allows a management system to consider application needs in advance and take suitable action to improve resource availability. In particular, this enables additional resources to be secured beforehand in the background when appropriate to avoid a potential overload, rather than paying the involved costs when overload arises. This paper proposes a software architecture that integrates applications with Globus services to conveniently handle resource reservation and allocation. Within the architecture, the computational reflection technology transparently connects applications with components that take care of advance reservation, as they dynamically sense the applications' resource needs. This dynamic information augments static knowledge gathered offline from static program code analysis. Copyright © 2005 John Wiley & Sons, Ltd.

Abstract Agent Communication Contexts (ACCs) are virtual environments where agents may live and interact. In this way, as in a human society, interactions may be subject to conventions and laws depending on the context where they occur. For this to be possible, an ACC should embed the communication laws relevant to the intended class of agent applications and enforce them, as interactions among agents take place. Although context is a communication aspect relevant for all the agents of an application, its modelling should be, in principle, an orthogonal concern with respect to the design of the activities of each agent. Consistently with this view, this work advocates the separate development of, respectively, agent behaviour, and the interaction aspects constituting the context. The latter is first abstractly specified as a set of communication laws, then automatically implemented by a tool that generates the necessary ACC management and checking code from the specification. The appropriate portions of this code should be activated whenever an interaction between agents takes place, so as to ensure that (i) the constraints specified by the laws are respected by the interaction, and (ii) the actions some of the laws require are carried out before the interaction actually occurs. Moreover, this work proposes an infrastructure whereby ACC code is triggered at runtime, whenever agents interact with each other. No source code modification or recompilation is required for this. All is seamlessly accomplished by means of computational reflection, which transparently changes the meaning of the communication primitives normally used by agent programmers. Copyright © 2005 John Wiley & Sons, Ltd.

The capability to evolve an application dynamically consists in activating new portions of code while the application runs. This can be considered particularly useful when applications need to adapt to fluctuating conditions of their environment. This paper aims at providing a general infrastructure that allows object-oriented applications to dynamically modify the way they work, without stopping. This infrastructure has a twofold objective: deciding which application activities best fit the current conditions, e.g. to exploit the increased availability or loss of resources; taking into account that new classes could have been developed and force the application to incorporate them while it runs. Computational reflection is used as a means to connect the proposed infrastructure with applications, for its interception mechanism provides the ability to intervene into the application operations in order to seamlessly introduce the desired changes.

To provide IP mobility for wireless users several micro-mobility protocols are currently available. These are capable for supporting this feature inside the scope of a LAN, by means of performing handovers between adjacent WiFi radio-access cells in order to follow users' movements. Also, it is possible to achieve wireless mobility in a larger extent, i.e. across whole network domains. But, in order to do it these protocols have to be used in conjunction with a macro-mobility protocol, like mobile IP. In this context, a problem arises if such domains are so far away from each other that wireless-access gaps exist between them. In fact, this prevents wireless IP users from experiencing access continuity while traveling across these domains. In this paper we describe a solution, which was designed and implemented to cope with the above problem. Starting from the cellular IP protocol, we developed a new mobility framework that extends it to seamlessly manage roaming into the GPRS access network, whenever the mobile host is out of range from any WiFi domain. Also, management of inter-domain macro-mobility is integrated in our framework, eliminating the need to externally rely on mobile IP.

Assistant agents are software systems that help users during activities by carrying out some task as a reaction to events in their environment. This paper proposes a software architecture that allows assistant agents to extend applications by autonomously giving users suggestions and activating useful application functionalities. The connection between applications and assistant agents is realised by means of computational reflection, which allows applications to evolve essentially without changes to their source code. The proposed approach is general in that it does not depend on a specific application nor platform. Its application is demonstrated by two examples of reflective assistant agents for a Web browser supporting data presentation and e-shopping respectively.

Developing distributed software systems is a complex activity that involves facing not only the problems of a specific application, but also those typical of distribution. Computational reflection supplies a means to handle different concerns with distinct components and a framework in which the latter can interact smoothly. We propose a reflective software architecture that encapsulates distribution concerns within components that are separated from and independent of those addressing functional concerns. The proposed architecture achieves a thorough management of distribution and in particular provides a means to dynamically adapt allocation policies to the characteristics of application objects, available hosts and changes of the distributed environment. The proposed approach is helpful for achieving the incremental development of easy to evolve software systems. In particular, we discuss the benefits of applying it to existing Web and e-commerce applications.

Abstract This paper studies the correctness of distributed systems made up of replicated processes that communicate by message passing. Processes are described within the divergence model of CSP. The notion of correctness introduced is based on a relation that formally expresses the conformance of an implementation process with the target process it is intended to implement. A weak and a strong version of the relation are introduced, aimed at treating acyclic and cyclic process networks respectively. Both allow the study of (total) correctness and may cope with non-deterministic targets and implementations. We then show how a target process may be implemented (in the formal sense introduced) by replicating it in a set of copies, a majority of which is non-faulty.

The authors present a novel formal approach to proving the correctness of distributed systems of replicated processes that communicate by message passing. The notion of correctness introduced is based on the consistency of the replicated system with its nonreplicated counterpart. The formal framework of CSP (communicating sequential processes) allows the proof of partial correctness and deadlock-freedom properties of the systems of replicated processes. The authors also discuss how a replicated process may be implemented by N-base copies, a majority of which are non-faulty, and point out the necessity of coordinating the copies and the requirements they should satisfy.>

Replicated synchronous programs executed by a set of possibly faulty processors find a natural application in the fault-tolerance technique known as N-Modular Redundancy (NMR). We present an axiomatic approach to correctness proofs for replicated synchronous programs and illustrate its application by studying an agreement protocol for NMR distributed computing.

An issue of current interest in the Open Systems Interconnection (OSI) field is the choice of a language well suited to specification and verification. For this purpose, two languages based on Milner's communication calculi are proposed, respectively intended for the specification of asynchronous and synchronous OSI systems. A formal verification method, relying upon the algebraic foundations of the two languages, is introduced and illustrated by means of examples based on nontrivial protocols and services.

The Language for temporal ordering specification (LOTOS) is a formal description technique whose development is under way within ISO, the International Organization for standardization, mainly for application to open systems interconnection (OSI) standards. The paper presents a LOTOS specification of the PROWAY interface for process control applicatioins, defined by IEC, the International Electrotechnical Commision. LOTOS is shown to be tailored for the specification of asynchronous systems. In particular, it proves suitable for the specification both of the services which define an interface and of the protocols which implement it. The paper shows how LOTOS supports formal reasoning aimed at establishing consistency between service and protocol specifications. Two examples of such a verification are developed that are related to the PROWAY interface. Finally, advantages and limitations of this approach are outlined.