Search Results (9)

Breast-conserving surgery followed by external beam Radiotherapy (RT) is a standard approach for early-stage Breast Cancer (BC). This retrospective study aims to determine the risk of RT-induced lung cancer for both standard and hypofractionated treatments. Fifty-eight Sicilian women treated at Humanitas Istituto Clinico Catanese (Misterbianco, Italy) between 2015 and 2021 with standard fractionated 3D-CRT (50 Gy in 2 Gy/fraction) were included. All treatment plans were designed using a hypofractionated schedule (42.56 Gy in 2.66 Gy/fraction). An Eclipse™ plug-in script was developed using the Eclipse Scripting Application Programming Interface (ESAPI) to extract patient and treatment data from the Treatment Planning System and compute Organ At Risk (OAR) volume, Organ Equivalent Dose (OED), Excess Absolute Risk (EAR), and Lifetime Attributable Risk (LAR) using the Schneider Mechanistic Model and reference data from regional populations, A-bomb survivors, and patients with Hodgkin’s Disease (HD). The OED distributions exhibited a statistically significant shift toward higher values in standard fractionated plans (p < 0.01, one-tailed paired Student’s t-test), leading to increased EAR and LAR. These results indicate that hypofractionated treatment may lower the risk of radiation-induced lung cancer. The feasibility of a priori risk estimation was evaluated by integrating the script into the TPS, allowing rapid comparison of SF and HF plans during planning. Full article

Structured concurrency treats multiple tasks running in different threads as a single unit, thereby improving reliability and enhancing observability. The existing IDE (Integrated Development Environment) does not provide sufficient support to leverage such an advanced structure and conduct refactoring automatically. Manual refactoring is tedious and error prone. There is an urgent need to provide adequate support to perform automatic refactoring. To this end, this paper proposes ReStruct, an automatic refactoring approach to transform unstructured concurrency to structured concurrency. ReStruct first employs visitor pattern analysis to acquire the target code for refactoring and then performs a precondition to filter out the code that meets the refactoring criteria. Subsequently, it performs scope analysis to guide the refactoring process. Finally, ReStruct performs refactoring on the AST of the source program. ReStruct is implemented as an Eclipse plugin and is evaluated in seven real-world projects via the number of refactorings and changes to LOCs (lines of code), time, and performance after refactoring. The experimental results illustrate that a total of 82 unstructured codes are refactored, with an average of 27.3 s per project. Furthermore, the performances of these refactored projects are improved by an average of 6.5%, demonstrating its effectiveness. Full article

To address the inherent limitations of Future in asynchronous programming frameworks, JDK 1.8 introduced the CompletableFuture class, which features approximately 50 different methods for composing and executing asynchronous computations and handling exceptions. This paper proposes an automatic refactoring method that integrates multiple static analysis techniques, including visitor pattern analysis, alias analysis, and executor inheritance structure analysis, to conduct precondition checks. Distinct from existing Future refactoring methods, this approach considers custom executor types, thereby extending its applicability. Using this method, the ReFuture automatic refactoring plugin was implemented within the Eclipse JDT framework. The method was evaluated in terms of the number of refactorings, refactoring time, and error introduction, alongside a side-by-side comparison with the existing method. The refactoring outcomes for nine large applications, including ActiveMQ, Hadoop, and Elasticsearch, show that ReFuture successfully refactored 639 out of 813 potential code structures, achieving a refactoring success rate of 64.70% without introducing errors. This tool effectively facilitates the refactoring to CompletableFuture and enhances refactoring efficiency compared to manual methods. Full article

Machine learning (ML) techniques discover knowledge from large amounts of data. Modeling in ML is becoming essential to software systems in practice. The accuracy and efficiency of ML models have been focused on ML research communities, while there is less attention on validating the qualities of ML models. Validating ML applications is a challenging and time-consuming process for developers since prediction accuracy heavily relies on generated models. ML applications are written by relatively more data-driven programming based on the black box of ML frameworks. All of the datasets and the ML application need to be individually investigated. Thus, the ML validation tasks take a lot of time and effort. To address this limitation, we present a novel quality validation technique that increases the reliability for ML models and applications, called MLVal. Our approach helps developers inspect the training data and the generated features for the ML model. A data validation technique is important and beneficial to software quality since the quality of the input data affects speed and accuracy for training and inference. Inspired by software debugging/validation for reproducing the potential reported bugs, MLVal takes as input an ML application and its training datasets to build the ML models, helping ML application developers easily reproduce and understand anomalies in the ML application. We have implemented an Eclipse plugin for MLVal that allows developers to validate the prediction behavior of their ML applications, the ML model, and the training data on the Eclipse IDE. In our evaluation, we used 23,500 documents in the bioengineering research domain. We assessed the ability of the MLVal validation technique to effectively help ML application developers: (1) investigate the connection between the produced features and the labels in the training model, and (2) detect errors early to secure the quality of models from better data. Our approach reduces the cost of engineering efforts to validate problems, improving data-centric workflows of the ML application development. Full article

This article describes TagML, a method to generate collections of XML documents using model-to-model (M2M) transformations. To accomplish this goal, we define the TagML meta-model and the TagML-to-XML model-to-text transformation. While TagML models represent the essential characteristics of collections of XML documents, the TagML-to-XML transformation generates the textual representation of collections of XML documents from TagML models. This approach enables developers to define model-to-model transformations to generate TagML models. These models are turned into text applying the TagML-to-XML transformation. Consequently, developers are able to use declarative languages to define model-to-text transformations that generate XML documents, instead of traditional archetype-based languages to define model-to-text transformations that generate collections of XML documents. The TagML model editor as well as the TagML-to-XML transformation were developed as Eclipse plugins using the Eclipse Modeling Framework. The plugin has been developed following the Object Modeling Group standards to ensure the compatibility with legacy tools. Using TagML, unlike other previous proposals, implies the use of model-to-model transformations to generate XML documents, instead of model-to-text transformations, which results on an improvement of the transformation readability and reliability, as well as a reduction of the transformation maintenance costs. The proposed approach helps developers to define transformations less prone to errors than using the traditional approach. The novelty of this approach is based on the way XML documents are generated using model-to-model transformations instead of traditional model-to-text transformations. Moreover, the simplicity of the proposed approach enables the generation of XML documents without the need for any transformation configuration, which does not penalize the model reuse. To illustrate the features of the proposal, we present the generation of XHTML documents using UML class diagrams as input models. The evaluation section demonstrates that the proposed method is less prone to errors than the traditional one. Full article

Model-driven engineering (MDE) uses models during the application development process. Thus, the MDE is particularly based on model-driven architecture (MDA), which is one of the important variants of the Object Management Group (OMG). MDA aims to generate source code from abstract models through several model transformations between, and inside the different MDA levels: computation independent model (CIM), platform independent model (PIM), and platform specific model (PSM) before code. In this context, several methods and tools were proposed in the literature and in the industry that aim to automatically generate the source code from the MDA levels. However, researchers still meet many constraints—model specifications, transformation automation, and level traceability. In this paper, we present a tool support, the model-driven architecture for web application (MoDAr-WA), that implements our proposed approach, aiming to automate transformations from the highest MDA level (CIM) to the lowest one (code) to ensure traceability. This paper is a continuity of our previous works, where we automate transformation from the CIM level to the PIM level. For this aim, we present a set of meta-models, QVT and Acceleo transformations, as well as the tools used to develop our Eclipse plug-in, MoDAr-WA. In particular, we used QVT rules for transformations between models and Acceleo for generating code from models. Finally, we use MoDAr-WA to apply the proposed approach to the MusicStore system case study and compare the generated code from CIM to the original application code. Full article

The concept of the Internet of Things (IoT) is an important part of the next generation of information. Wireless sensor networks are composed of independent distributed smart sensor nodes and gateways. These discrete sensors constantly gather external physical information, such as temperature, sound, and vibration. Owing to the diversity of sensor devices and the complexity of the sensor sensing environment, the direct modeling of an IoT-aware business process application is particularly difficult. In addition, how to effectively deploy those designed applications to discrete servers in the heterogeneous sensor networks is also a pressing problem. In this paper, we propose a resource-oriented modeling approach and a dynamic consistent hashing (DCH)-based deploying algorithm to solve the above problems. Initially, we extended the graphic and machine-readable model of Business Process Model Notation (BPMN) 2.0 specification, making it able to support the direct modeling of an IoT-aware business process application. Furthermore, we proposed the DCH-based deploying algorithm to solve the problem of dynamic load balancing and access efficiency in the distributed execution environment. Finally, we designed an actual extended BPMN plugin in Eclipse. The approach presented in this paper has been validated to be effective. Full article

Applications are employing Near Field Communication (NFC) technology to interact with physical objects by using NFC tags. The architecture to implement these kinds of applications varies according to non-functional requirements such as the physical environment where the application is running, the flexibility to adapt the information to be manipulated through physical objects, etc. To cope with these challenges, this paper proposes a Model-driven Architecture (MDA) where designers are able to model the configuration of the system according to NFC based system requirements. Through a model-to-text transformation process, the MDA also provides developers with templates of source code for the applications that support the system. The proposed MDA process defines a Platform Independent Model (PIM) which supports a Domain Specific Language (DSL) implemented as an Eclipse platform plugin that provides designers with a graphical model editor, and a model to text transformation, to generate the source code templates using the Acceleo transformation language. The paper also presents the Albacete Photo Gallery case of study to illustrate the modelling process. The main benefit of the proposal is that it allows developers to create mixed environments where the availability and flexibility of NFC based interaction systems can be easily configured, extended and maintained. Full article

Integration of high volume (high penetration) of photovoltaic (PV) generation with power grids consequently leads to some technical challenges that are mainly due to the intermittent nature of solar energy, the volume of data involved in the smart grid architecture, and the impact power electronic-based smart inverters. These challenges include reverse power flow, voltage fluctuations, power quality issues, dynamic stability, big data challenges and others. This paper investigates the existing challenges with the current level of PV penetration and looks into the challenges with high PV penetration in future scenarios such as smart cities, transactive energy, proliferation of plug-in hybrid electric vehicles (PHEVs), possible eclipse events, big data issues and environmental impacts. Within the context of these future scenarios, this paper reviewed the existing solutions and provides insights to new and future solutions that could be explored to ultimately address these issues and improve the smart grid’s security, reliability and resiliency. Full article