Modern Astrophysics and Cosmology (A&C) projects produce immense data volumes, necessitating advanced software tools for data access, storage, and analysis. Visualization Interface for the Virtual Observatory (VisIVO) is one such tool enabling multi-dimensional data analysis and knowledge discovery across complex astrophysical datasets. Leveraging containerization and virtualization, VisIVO has been deployed on various distributed computing platforms. Additionally, Blender, an open-source 3D suite, provides robust tools for rendering and processing volumetric data, making it suitable for visualizing complex datasets. At the SPACE Center of Excellence these tools are being adapted for high-performance visualization of cosmological simulations performed with GADGET and ChaNGa on pre-exascale systems. However, implementing high-performance visualization on diverse HPC platforms presents several challenges, including hardware and software compatibility, data management, scalability, performance portability, and efficient resource allocation. This paper outlines strategies to integrate VisIVO with workflow frameworks and streaming platforms to address these challenges. Workflow frameworks enhance portability, scheduling, and reproducibility of visualization workflows on pre-exascale systems used in A&C simulations. We also discuss the use of streaming platforms to enable concurrent (i.e. in-situ) analysis and visualization of simulations, reducing the need to store full simulation data by leveraging distributed databases that stream the output data in real time. Lastly, we present an adaptation of Blender to handle large-scale particle-based astrophysical data, offering high-quality visualization with interactive exploration capabilities.

The analysis of aerial images to detect objects of interest is an active research field as its results can be very useful for planning crops, estimating gains and costs, etc. This paper proposes a novel way to distinguish among some categories of crops in a field, as well as parts representing man-made objects, such as roads and buildings. For this, advanced YOLO models were trained using an accurately labeled data set, then validated and tested to assess the accuracy and precision of the detection. The outcome of the best trained YOLO model shows high precision. Therefore, the trained model can be very useful in scanning areas and systematically detecting the state of crops. Moreover, the high-quality labeled image data set can be used as a reference set to test other approaches.

Modern supply chains still rely on centralized procurement platforms; hence they struggle with inefficiencies, lack of transparency, and limited adaptability to disruptions and market changes. This paper proposes a decentralized e-bidding platform for Business-to-Business (B2B) procurement, integrating blockchain technology and artificial intelligence driven Intelligent Autonomous Agents (IAAs) to ensure trustworthiness and efficiency. Blockchain’s immutable ledger provides transparency and security, while IAAs, powered by large language models (LLMs), automate operational bid evaluation and support strategic supplier selection. Simulations of two supply chain scenarios with varying information sharing levels have demonstrated that higher transparency enhances efficiency. Results confirm the suitability of IAAs for real-time decision-making and blockchain for secure automation in supply chain applications.

A reliable communication system is one of the most crucial component in emergency response. Blockchain technology, known for its distributed and decentralized management, has been extensively used in various contexts, with interest also growing for its applications in the health-care sector. In this paper we propose and evaluate a system incorporating blockchain technology for initial emergency care interventions, i.e. ambulance dispatching. The approach allows a distributed management and coordination of emergency interventions, using smart contracts in place of a central authorithy. The major benefit is the increased ability to trace, and afterward give evidence of, the events occurring when handling emergency calls, without having to rely on a central authority. Moreover, the proposed system combines medical data records storing in the blockchain with additional cryptography to preserve the privacy of healthcare data, while ensuring availability, integrity and persistence.

Land Use Land Cover (LULC) classification plays a crucial role in the optimisation of agricultural lands to cope with global warming and increase crops. Many existing methodologies for LULC classification rely on machine learning algorithms and/or hyperspectral imaging, both of which necessitate extensive annotated datasets and substantial computational resources. Moreover, these methods could yield results that are in some cases inaccurate or lack interpretability. This paper introduces an innovative and effective approach to extract characterising colours from different land types. The proposed solution manages to automatically generate the sets of colours corresponding to categories of land, from a small set of annotated images, in just one iteration. Such colours were then used to classify lands in other images by analysing colour distributions and assessing pixel densities. The results demonstrated the precision and accuracy of our approach, which successfully classifies up to three categories of land across multiple images.

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.

As overpopulated cities spread all over the world, recycling has become crucial. Day by day, waste production is rising while resources are becoming limited, making recycling not only a sensible practice but a necessity. In order to be effective, the recycle process needs to start with the efforts of every single citizen, who is, however, often slightly motivated or forced by a punish-based system. In this paper, we propose a reward-based data-centric solution based on both enabling IoT technologies and cloud architectures to promote waste recycling in urban environments. We extend the consolidated rewarding approaches based on the smart bin model by proposing an incentive system that focuses on door-to-door waste collection. Such a solution assists door-to-door garbage collection by using practical and affordable QR-codes and IoT sensors to accumulate and track all the fundamental data related to garbage, such as waste composition (paper, plastics, glass, etc.), bag weight, etc. As recycling is properly handled by citizens, they can be rewarded with an adequate tax relief. The user is given means to monitor his progress by a smartphone app; whereas the waste management company and municipality can monitor their target amounts for each waste category and e.g. provide citizens with incentive to adjust the growth rate of different materials to be collected.

Forecasting of imminent seismic and/or volcanic events can drastically reduce the loss of human life by evacuating the inhabitants residing in the neighboring areas. An integrated system, called Volcano-Seismic Early Warning (VSEW), is proposed, capable of classifying the alarm scenario in three levels (soft, medium and hard) for the forecast of seismic-volcanic phenomena of medium-high intensity. The system is based on threshold levels, calculated statistically, of some seismic and volcanic precursors (historical and recent earthquakes, volcanic tremor, concentration of magmatic gases, soil temperature). In active volcanic areas, the analysis of satellite images can highlight the soil temperature gradients between adjacent crustal areas, which is a critical criterion for identifying deep thermal anomalies linked to the rise of magmatic bodies. After being processed by a central server, the selected geological data are made available to mobile devices (smartphones, tablets, notebooks) to which they are presented in graphs and tables. An acoustic-luminous alarm will warn the user when the threshold values of one or more geophysical parameters have been reached or exceeded: the intensity of the signal emitted will be proportional to the risk of a potential eruption or earthquake. The implementation of this system aims at providing a valid alert instrument in areas characterized by high volcanic and seismic risk.

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.

Assisting code evolution (refactoring, adaptation, parallelisation, etc.) can be handy for improving code quality and execution speed. Generally, tools assisting developers are tailored to some language, making analyses approaches hard to be applied in practice when using a different language. In this paper, we propose a cross-language framework for implementing analyses on object-oriented code. By separating the logic for computing metrics, or detecting code smells, that lets us identify the need for improvements, from code exploration, we enable developers designing high-level recommendation tools that can be effectively applied on the most common object-oriented languages, such as e.g. Java and C++. Code exploration components will provide inspection and data commonly needed for representing the details of the code, such as control and data dependencies, or object and method lists. These will be language-specific and provided by the framework itself.

This report describes the scope of the VSC track held at the IEEE WETICE 2019 conference. The 2019 edition of WETICE was held in Capri (Naples), Italy, from June, the 12th to 14th. The papers accepted and presented to the VSC track dealt with the analysis of complex systems in order to detect erroneous or unexpected behaviour, especially from the security, and safety perspective.

Generally, when an app runs on an Android device, users are asked to approve accesses to sensitive data or resources that require Android dangerous permissions. Otherwise, for other resources, requiring normal permissions, no approval is asked. Once access to resources has been gained, an app could send confidential data outside of the device, with no obvious abuse of security policies. Hence, users could witness a data leak, and, in general terms, a loss of control on data accessed, and about the ways they have been used. This paper shows the mechanisms that an app could use to gain sensitive data, hence breaching user privacy. Then, in order to preserve privacy, a novel and general defence solution is proposed, protecting data and resources in Android devices. Moreover, users are given the ability to configure which accesses have to be prevented and which are granted. As a proof of concept, our protection solution has been embedded in Wikipedia app, however is general and available for any app.

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.

Modernising applications in order to make them use the current parallel hardware and novel language features can be challenging. Applications should be changed in a way that keeps developers familiar with the code, avoid eroding the software architecture, retain modularity, etc. Moreover, while running more threads should be possible, and not the default choice, code should not become more complex. This paper proposes a solution for balancing all such concerns, when dealing with parallel execution, based on pattern Decorator.

The work of decomposing long methods into smaller ones is commonly assisted by the Extract Method refactoring technique. However, local variable usages can make code extraction difficult. Therefore, Replace Method with Method Object refactoring technique lets the developer create a field for each variable, and then code extractions can be performed without worrying about variable dependences. However, this can lead to classes having many fields used by a few of its methods. Moreover, the considered fields may not correctly describe the actual object state, making the class harder to understand. This paper proposes a data dependence analysis approach for guiding the Replace Method with Method Object refactoring technique, with the aim of reducing the set of variables becoming fields while properly handling data dependence. The resulting class is easier to understand, having less fields holding the state, while using local variables and parameters to confine all the other data dependence details.

Embedded systems that realize specific functions are usually hardware constrained systems running dedicated software. These embedded systems rarely take into account the possibility to change functions after their release. As a result, it would be difficult to change some function from outside an embedded system in its operational environment. In order to keep up with the need of quickly reacting to changes affecting requirements and environments, it is paramount to find a way to update the functions of these systems. We constructed a programming framework for updating functions based on the MAPE loop mechanism, which is generally used to develop self-adaptive systems. We regard MAPE loop as a set of independent components that make it easy to separate the updating functions from other functions. We apply our framework to a web application and an embedded system. The proposed framework is independent of the target embedded system and makes it possible to easily inject new functions into it.

This paper proposes an approach that identifies the flows of people from collected GPS data. This in turn enables us to compute significant parameters, such as people average speed, amount of travelling people, etc. A proper solution for data filtering and analysis has been implemented and tested against real data, which reduces as much as possible running time by lowering the number of needed comparisons. The ability to gain insights on people flows can have many outcomes in the area of smart transportation, e.g. the efficacy of transportation means can be assessed, then potential improvements can be suggested on public transportation means, infrastructures, etc.

The following topics are dealt with: cloud computing; security of data; business data processing; groupware; Internet of Things; quality of service; data privacy; graph theory; data analysis; data mining.

Modularity of a software system can be assessed once responsibilities of each method and class have been determined. Generally, developers attribute responsibilities to methods and classes manually. This can be problematic given that it relies on developers judgement and effort. This paper proposes an approach to automatically attribute concern tags to each instructions. The approach is based on taint analysis to determine which code lines are related to each other by data dependence. Moreover, Java APIs provide the tags used to mark code lines. The automatic concern tagging that we bring about is used to find out how responsibilities are spread in the code, and then to suggest refactoring activities in case tangling occurs.

This report describes the VSC track dealing with security and validation of software systems, within the IEEE WETICE 2017 conference. This year the conference and its tracks were held in Poznan, Poland, in June 21st to 23rd, 2017. The papers accepted and presented to the track dealt with malware detection and platform dependences.

Code portability is a desirable non-functional requirement. The most established metric evaluating it consists of counting the number of instructions that use platform specific APIs. Generally, instructions using APIs are preceded or followed by related code that e.g. prepares some input for a call or analyses the return value. This paper proposes a taint analysis approach to identify code portions that are related by means of data dependence and are connected to a given platform. By considering both direct calls to platform APIs and the data dependence, we provide a more precise and realistic indication of the code that should be considered in case of platform migration. The proposed approach has been used to analyse an industrial application, and gathered results have been examined to show the validity of our proposal.

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.

This report provides an introduction to the papers accepted for the VSC track at IEEE WETICE 2016, held in Paris (France), from June 13th to 15th, 2016.

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.

Nowadays the effective and fast detection of fruit defects is one of the main concerns for fruit selling companies.This paper presents a new approach that classifies fruit surface defects in color and texture using Radial Basis Probabilistic Neural Networks (RBPNN).The texture and gray features of defect area are extracted by computing a gray level co-occurrence matrix and then defect areas are classified by the applied RBPNN solution.

This work presents a new adaptive technique for image compression based on Discrete Wavelet Transform (DWT) and Radial Basis Function Neural Networks (RBFNN). The technique can be employed both for lossless and lossy (higher) compression and has been devised in order to deal effectively with a large variety of images. Proposed solution performs well both in terms of computing time and memory. Its generality, flexibility and efficiency make it attractive for storage and transmission in the field of vision and multimedia systems.

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.

This report provides an introduction to the papers accepted for the VSC track at IEEE WETICE 2015, held in Larnaca Cyprus, from June 15th to 17th, 2015. The VSC track is the third IEEE WETICE event dedicated to systems validation techniques in the context of safety critical applications. Along the previous years the VSC track has provided reasearchers with a venue oriented to exchange results and ideas on the general context of software verification. Some papers have addressed issues related to hardware and software verification. This year we have received a significant number of contributions under the general theme of the track and for ensuring a high quality, by means of an independent reviewing process, we have selected three contributions for the presentation at the VSC track 2015. We thank all the anonymous reviewers and the programme committee members for their dedicated work. We express our gratitude to the WETICE General Chair, Program Chairs and Steering Committee for the opportunity given us to contribute with the VSC track to the lively and friendly research forum provided by the WETICE community.

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.

We present a study on a significantly large and varied set of freely available Java virtual machines implementations. The aim of the study is to assess their level of conformity to the structural constraints of the Java language specification. In order to do that we set up a refined framework for the automated generation of a conformance checking test suite. In the framework, the test cases are generated by model checking the Java language specifications in order to target each a specific constraint. Complete coverage of all the modeled constraints within a limited number of tests is obtained by means of a combinatorial covering technique. Results obtained from the test suite application are presented and discussed and proved the efficacy and validity of the underlying approach to validation.

This report provides an introduction to the papers accepted for the VSC track at IEEE WETICE 2014.

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.

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.

We present a technique to fully automate the conformance testing of a Java virtual machine (JVM) implementation to the structural constraints it must satisfy to enforce type safety of program execution. The approach is based on formal modeling of the JVM as a finite state machine, ruled by the Java standard specifications. The model is used to derive a test suite and corresponding oracle that systematically explores the space of illegal states reachable by a JVM implementation under test. Also, a degree of conformance to the JVM specifications (i.e., too strict or too coarse) can be assessed by counting the number of false positives. Despite the huge test space, the entire proposed process need not human supervision. The technique is black box, fully automated, and can be applied for validating final products or during development i.e. for debugging purposes.

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.

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.

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.

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.

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.