Mobile edge systems require efficient resource synchronization to support coordination in dynamic, infrastructure-less environments, where traditional cloud-based approaches incur high overhead and limited robustness. We present PrudentCaster, a tunable decentralized broadcast gossip framework that improves synchronization efficiency by minimizing redundant transmissions. The key idea is to guide forwarding using a local, MLST-inspired structure, enabling selective dissemination while preserving high coverage without global coordination. We further introduce a unified metric that captures trade-offs among coverage, redundancy, latency, and bandwidth. Evaluation in both simulation and a small-scale robotic testbed shows that PrudentCaster improves synchronization efficiency by up to 1.6 × in real deployments and up to 6 × in large-scale scenarios.

Web of Things (WoT) technology standardizes the integration of various IoT devices deployed in daily environments, promoting the capability of applications to automatically sense and regulate the physical environment.Meanwhile, the complex nature of such a ubiquitous software system, where heterogeneous applications, user activities, and environment states collectively influence device behaviors, poses risks of unexpected or even hazardous safety and security violations caused by improper device operations.Existing works on WoT violation identification primarily focus on the sole analysis of software applications, however, lacking consideration of the multi-source violations stemming from the human-cyberphysical ternary spaces, as well as the intricate interplay between environment and devices.Furthermore, the investigation into users' preferences for violation resolution remains unexplored.To address these limitations, we introduce EnvGuard, an environment-centric approach for customizing safety and security properties, identifying violations, and executing resolutions in the WoT environment.Our evaluation in two real-world WoT systems shows that Env-Guard outperforms previous state-of-the-art works, and confirms its usability, effectiveness, and runtime efficiency. CCS Concepts•

Mobile apps are ubiquitous, and have become an indispensable part of our daily life. It is crucial to ensure the correctness, security and performance of these apps through automated GUI modeling. UI Transition Graph (UTG) is an important way of app abstract and modeling. While there have been considerable research efforts on constructing UTG through static or dynamic analysis, obtaining a relatively accurate and complete UTG is challenging. To this end, we present an approach and tool RLDroid that synergistically combines static analysis, dynamic exploration and reinforcement learning techniques to construct UTGs for Android apps. Specifically, RLDroid first extracts a seed UTG through static analysis, and uses this UTG with a depth-first strategy to guide the dynamic exploration. Then, RLDroid provides a Q-learning-based strategy initialized with the generated partial UTG to enhance dynamic exploration and outputs the final UTG. Our experiments on 29 Android apps show that RLDroid identified a total of 871 nodes (i.e., UI pages) and 2726 edges (i.e., transitions) without any false positives, which significantly outperforms the state-of-the-art GUI modeling techniques. Our two exploration strategies, the seed-UTGguided exploration and the Q-learning-enhanced exploration, make positive contributions to improving the completeness of UTG. Furthermore, the UTGs generated by RLDroid are highly useful for automated GUI testing, resulting in a 60 % increase in code coverage and the discovery of 52 additional crashes.

Automated test generation plays a crucial role in ensuring software security. It heavily relies on formal specifications to validate the correctness of the system behavior. However, the main approach to defining these formal specifications is through manual analysis of software documents, which requires a significant amount of engineering effort from experienced researchers and engineers. Meanwhile, system update further increases the human labor cost to maintain a corresponding formal specification, making the manual analysis approach a time-consuming and error-prone task. Recent advances in Large Language Models (LLMs) have demonstrated promising capabilities in natural language understanding. Yet, the feasibility of using LLMs to automate the extraction of formal specifications from software documents remains unexplored. We conduct an empirical study by constructing a comprehensive dataset comprising 603 specifications from 37 documents across three representative open-source software. We then evaluate the most recent LLMs' capabilities in extracting formal specifications from documents in an end-to-end fashion, including GPT-4o, Claude, and Llama. Our study demonstrates the application of LLMs in formal specification extraction tasks while identifying two major limitations: specification oversimplification and specification fabrication. We attribute these deficiencies to the LLMs' inherent limitations in processing and expressive capabilities, as well as their tendency to fabricate fictional information. Inspired by human cognitive processes, we propose a novel two-stage method, annotation-then-conversion, to address these challenges. Our method decomposes the task into sentence annotation and temporal logic conversion, reducing the demands on LLMs' processing and expressive capabilities for each subtask. Furthermore, by generating verifiable sentence-specification pairs, our method enables effective fact-checking, thereby mitigating hallucination effects. Our method demonstrates significant improvements over the end-to-end method, with a 29.2 % increase in the number of correctly extracted specifications and a 14.0 % improvement in average accuracy. In particular, our best-performing LLM achieves an accuracy of$\mathbf{7 1. 6 \%}$.

Large-scale scenarios, such as drone-based search and rescue, often require seamless access to devices distributed across hierarchical edge clusters. However, existing multi-cluster communication solutions designed for cloud environments cannot be directly applied to edge environments due to resource constraints, network limitations, and privacy concerns. To address these challenges, this paper introduces EdgeConnector, a lightweight middleware specifically designed to enable seamless and efficient cross-cluster device access in edge environments. EdgeConnector consists of components deployed across superior and subordinate clusters and employs a compact mechanism leveraging eXpress Data Path (XDP) for highly efficient device communication between clusters. The middleware was evaluated in both real-world and simulated environments. A real-world case study demonstrates its practicality and usability, while experimental results from the simulated environment highlight its superior performance. Specifically, EdgeConnector achieves an 80% reduction in latency and a 90% reduction in CPU usage under high-load conditions compared to the leading existing solution for cross-cluster service access.

Trigger-Action Programming (TAP) is a popular end-user programming paradigm for constructing automation applications to orchestrate smart device collaboration. Existing TAP platforms employ a device-centric approach to programming and executing TAP rules, which suffers limited flexibility and reusability when a same automation requirement is effective in different location. To this end, we develop a tool named laTAPE to support location-aware trigger-action programming and executing. laTAPE supports users to specify triggers, condition states and actions involving locations which refer to either runtime user location or a predefined location. During runtime, laTAPE achieves the rule execution by leveraging corresponding environment devices determined by the user location obtained from smartphone. Our evaluation on real-world case study demonstrates usability and feasibility of laTAPE in rule programming and executing.

Program synthesis aims to automatically generate an executable program that conforms to the given specification. Recent advancements have demonstrated that deep neural methodologies and large-scale pretrained language models are highly proficient in capturing program semantics. For robot programming, prior works have facilitated program synthesis by incorporating global environments. However, the assumption of acquiring a comprehensive understanding of the entire environment is often excessively challenging to achieve. In this work, we present a framework that learns to synthesize a program by rectifying potentially erroneous code segments, with the aid of partially observed environments. To tackle the issue of inadequate attention to partial observations, we propose to first learn an environment embedding space that can implicitly evaluate the impacts of each program token based on the precondition. Furthermore, by employing a graph structure, the model can aggregate both environmental and syntactic information flow and furnish smooth program rectification guidance. Extensive experimental evaluations and ablation studies on the partially observed VizDoom domain authenticate that our method offers superior generalization capability across various tasks and greater robustness when encountering noises.

The physical world we live in is accelerating digitalization with the vigorous development of Internet of Things (IoT). Following this trend, Web of Things (WoT) further enables fast and efficient creation of various applications that perceive and act on the physical world using standard Web technologies. A popular way for creating WoT applications is Trigger-Action Programming (TAP), which allows users to orchestrate the capabilities of IoT devices in the form of “if trigger, then action”. However, existing TAP approaches don’t support scenario-centric WoT applications which involve abstract modeling of physical environments and complex spatio-temporal dependencies between events and actions. In this paper, we propose an approach called SCTAP which supports Scenario-Centric Trigger-Action Programming based on software-defined physical environments. SCTAP defines a structured and conceptual representation for physical environments, which provides the required programming abstractions for WoT applications. Based on the representation, SCTAP defines a grammar for specifying scenario-centric WoT applications with spatio-temporal dependencies. Furthermore, we design a service-based architecture for SCTAP which supports the integration of device access, event perception, environment representation, and rule execution in a loosely-coupled and extensible way. We implement SCTAP as a WoT infrastructure and evaluate it with two case studies including a smart laboratory and a smart coffee house. The results confirm the usability, feasibility and efficiency of SCTAP and its implementation.

Myriad of heterogeneous resources are widely distributed in the cyber, physical and social spaces. These resources are integrated by software to form diverse Cyber-Physical-Social Systems (CPSSs). Among them, the CPSSs in the form of resource choreography is receiving more attention. Traditional software development methods may not be suitable for constructing and executing CPSS applications (CPSS-Apps) with the characteristics of loosely-coupled resource collaboration and spatial-temporal constraints sensitive. In this paper we propose a comprehensive framework to support resource choreography from the perspectives of representation, modeling and execution. In the framework, a CPSS-App is represented by an application model conforming to a meta-model. An application model is generated by a multi-scene storyboard modeling tool. The model is further used to customize the capability units acting as the abstract unit of the resources providing the same service. An architecture following the microservice style is applied to achieve the choreography of the capability units by asynchronous message communication while a resource is determined by application-level service discovery. The framework is evaluated through a human experiment. The results show that the application construction and execution by the framework is feasible. The modeling tool is usable and the execution architecture is scalable in different environment settings.

Android apps are event-driven, and their execution is often interrupted by external events. This interruption can cause data loss issues that annoy users. For instance, when the screen is rotated, the current app page will be destroyed and recreated. If the app state is improperly preserved, user data will be lost. In this work, we present an approach and tool iFixDataloss that automatically detects and fixes data loss issues in Android apps. To achieve this, we identify scenarios in which data loss issues may occur, develop strategies to reveal data loss issues, and design patch templates to fix them. Our experiments on 66 Android apps show iFixDataloss detected 374 data loss issues (284 of them were previously unknown) and successfully generated patches for 188 of the 374 issues. Out of 20 submitted patches, 16 have been accepted by developers. In comparison with state-of-the-art techniques, iFixDataloss performed significantly better in terms of the number of detected data loss issues and the quality of generated patches.

Android apps are event-driven, and their execution is often interrupted by external events. This interruption can cause data loss issues that annoy users. For instance, when the screen is rotated, the current app page will be destroyed and recreated. If the app state is improperly preserved, user data will be lost. In this work, we present a tool iFixDataloss that automatically detects and fixes data loss issues in Android apps. To achieve this, we identify scenarios in which data loss issues may occur by analyzing the Android life cycle, developing strategies to reveal data loss issues, and designing patch templates to fix them. Our experiments on 66 Android apps show iFixDataloss detected 374 data loss issues (284 of them were previously unknown) and successfully generated patches for 188 of the 374 issues. Out of 20 submitted patches, 16 have been accepted by developers. In comparison with state-of-the-art techniques, iFixDataloss performed significantly better in terms of the number of detected data loss issues and the quality of generated patches. Video Link: https://www.youtube.com/watch?v=MAPsCo-dRKs Github Link: https://github.com/iFixDataLoss/iFixDataloss22

Exploring GUIs of Android apps plays a key role in many important scenarios such as functional testing (e.g., finding crash errors), security analysis (e.g., identifying malicious behav-iors) and competitive analysis (e.g., storyboarding app features). To automate GUI exploration, existing techniques often try to visit as many GUI pages as possible via specific strategies, e.g., random (like Monkey) or heuristic (like Stoat, A3E). However, their effectiveness is still unclear and much under-explored. To this end, we conducted the first study in this paper to understand and characterize their limitations by carefully analyzing the coverage reports from a set of real-world, open-source apps. Through this study, we identified three key limitations due to the lack of dependency knowledge during exploration, i.e., widget-page dependency, widget-widget dependency and system-event dependency. To overcome them, we introduce dependency-informed exploration, an automated approach that leverages static dependency analysis to effectively improve GUI exploration performance. Given an app, our approach first constructs a GUI page transition model that captures the dependencies between GUI widgets, and then guides GUI exploration during a depth-first traversal. We realized our approach as a tool named Gesda, and evaluated it on 70 open-source Android apps. The results show Gesda outperforms existing state-of-the-art GUI exploration techniques, i.e., Monkey and Stoat. Additionally, Gesda uncovers 4 previously unknown crashes in 4 apps as a by-product of GUI exploration due to the benefit of dependency knowledge, while Monkey and Stoat have not discovered them.

Humans are social creatures which enjoy participating in group activities. Existing platforms such as event-based social networks and social-matching applications empower people to organize and participate in different kinds of interest-based activities. However, credibility issues are inevitable since the participants’ commitment to participate in activities on time can hardly be guaranteed. As a result, many activities are canceled due to lack of participation, which impairs people’s will for attending activities and increases the difficulty of coalescing activity groups.

Deprecation is commonly leveraged to preserve the backwards compatibility in API clients during API evolution. Client developers then usually encounter migration tasks when relying on a new version of API. Manually migrating a deprecated API to its replacement may be tedious and time-consuming. Existing research has focused on the requirements of automated migration however has limitations on the consistency and granularity of the generated migration pathway. In this paper, we propose an approach for migrating deprecated APIs to their replacements which are explicitly documented in the code documentation. A migration pattern including the migration type and the migration strategy is first introduced to describe the difference and the code change from a deprecated API to its replacement. An automated process is then designed and implemented to construct the pattern for a specific deprecated API by reviewing the code documentation and analyzing the API source code. Based on the patterns, a tool named DAAMT is developed to locate deprecated APIs and to provide migration suggestions for API clients. An experimental study on open-source Java projects and a user study is performing utilizing the approach. The results show that three-fourth of the deprecated APIs with documented replacements involved in the projects can be automatically migrated. In addition, the DAAMT tool can improve the efficiency and accuracy of the tasks compared with the manual migration.

When performing software maintenance tasks, developers often need to understand a series of background knowledge based on information distributed in different software repositories such as source codes, version control systems and bug tracking systems. An effective way to support developers to understand such knowledge is to provide an integrated knowledge base and allow them to ask questions using natural language. Existing approaches cannot well support natural language questions that involve a series of conceptual relationships and are phrased in a flexible way. In this paper, we propose an interactive approach for understanding developers' natural language queries. The approach can understand a developer's natural language questions phrased in different ways by generating a set of ranked and human-readable candidate questions and getting feedback from the developer. Based on the candidate question confirmed by the developer, the approach can then synthesize an answer by constructing and executing a structural query to the knowledge base. We have implemented a tool following the proposed approach and conducted a user study using the tool. The results show that our approach can help developers get the desired answers more easily and accurately.

In this paper, we address the optimization problem of SLA-constrained service composition. Focusing on the main drawbacks of traditional approaches surveyed:1) the difficulties in preference definition and weight assignment, 2) the limitation of linear utility function for identifying preferred skyline solutions, and 3) the poor efficiency and scalability of algorithms, we present a systematic approach of combining the weighted Tchebycheff distance with skyline computation to cope with this optimization problem. More specifically, we first propose a fuzzy linguistic preference model that can help service composer elicit, represent and establish consistent preference relations upon QoS dimensions. Then we present a weighting procedure to transform the preference relations into numeric weights that are used in the Tchebycheff distance as quantified measurement of preference for skyline solutions. Finally we propose a hybrid evolutionary algorithm to heuristically find preferred skyline solutions in an efficient way. The algorithm is further evaluated by a set of experimental studies.

Running with static requirements and design decisions, a software system cannot always perform optimally in a highly uncertain and rapidly changing environment. Quality-driven self-adaptation, which enables a software system to continually adapt its structure and behavior to improve the overall quality satisfaction, thus becomes a promising capability of software systems. Existing researches on self-adaptive systems, although having proposed effective methods and techniques on requirements-driven self-adaptation and reflective components, do not well address the gap between requirements and runtime architecture. In this paper, we propose a quality-driven self-adaptation approach, which incorporates both requirements- and architecture-level adaptations. At the requirements level, value-based quality tradeoff decisions are made with the aim of maximizing system-level value propositions. At the architecture level, component-based architecture adaptations are conducted. To bridge the gap between requirements and runtime architecture, design decisions capturing alternative design options and their rationales are introduced to help map requirements adaptations and context changes to adaptation operations on the runtime architecture. To validate the effectiveness, we implement the approach based on a reflective component model and conduct an experimental study on it. The results show that the approach leads to better performance compared with traditional software and the overall quality satisfaction is kept maintained. Furthermore, the development effort is affordable but the approach still has shortage in extensibility.

Self-adaptive systems are now facing the anticipation of mass customization. Therefore, the Software Product Line (SPL) engineering for developing Self-Adaptive systems (SPL4SA) can be an effective way. At the first sight, SPL4SA is the straightforward combination of the two methodologies of SPL engineering and self-adaptive systems. However, the direct and unsystematic combination will bring difficulty in the domain requirements analysis and in the customization process. In this paper, in order to give a solution to the practical problems, we propose a domain requirements meta-model in SPL4SA. It is described with different point of views and the variability binding constraints inside are emphasized. Based on it, a guidance is concluded to support the consistent customization towards the domain model. In addition, an experimental study about a web-based business product line involving self-adaptation capability is conducted to evaluate the model.

It is common in practice that a Software Product Line (SPL) is constructed by reengineering a set of existing variant products. To alleviate the problems of high risks of failures and the limitations of resources and cost, incremental reengineering towards a SPL is a natural choice in many cases. However, several problems remain unaddressed properly, such as how to define increments, how to satisfy regular product delivery in parallel with reengineering, and how to achieve early successes. In this paper, we report an industrial case study on a successful SPL-targeted reengineering project conducted in Alcatel-Lucent. In this project, the project team applied the principles of agile development in the process of SPL reengineering. The key practices of the project include value-based increment definition, domain-driven responsibility alignment, iterative component refactoring and integration. We analyze the reengineering process of a major component qualitatively and quantitatively, with the focus on initial investment required, trend of investment, returns on investment and quality improvement. Our case study shows that incremental and iterative approach with stakeholder-value considerations can help to achieve steady and successful SPL reengineering in a cost-effective manner. We also find that SPL adoption can be regarded as an emergent result of the reconstruction and improvement of existing product assets.

In the long-term evolution of a Software Product Line (SPL), how to ensure the alignment between the reference and application architectures is a critical problem. Existing ad-hoc methods for architecture synchronization cannot ensure the completeness. In this paper, we propose a model-driven method for synchronized SPL architecture evolution using bidirectional transformation, a well-developed technique with solid mathematical foundation. Based on the model-based architecture representation, we capture the variability-intensive consistency relations between reference and application architectures and specify them with Beanbag, a declarative language supporting operation-based synchronization. Then, with the generated synchronizer and additional mechanisms, we can achieve coordinated architecture evolution through periodic synchronizations.

The coordination-policy that components interactions satisfied often determines the properties of nowadays component-based information systems, e.g. safety, liveness and fairness etc. Therefore, how to derive coordination-policy satisfying behavior all out of such system to achieve better system properties is of a significant problem that needs to be solved. Aim to this problem, we propose an optimistic policy- satisfying behavior derivation approach in this paper. The main idea of the approach is to automatically construct a Coordination Environment (CE) for such composed system that system components can work together in a deadlock-free and policy-satisfying manner, and so as to obtain desired system properties. In this approach, component-based information system is modeled by interface automaton network (IAN), and component coordination-policies are specified by LTL. To explain the correctness and validity of this approach, we give a corresponding example certification.

Dynamic evolution has been an essential requirement for more and more business systems which attempt to provide 7(days) x 24(hours) availability and flexible adaptability on the changing business environment. Therefore, these systems are expected to be self-adaptable at run-time with little user intervention. CBSD provides an architectural way for self-adaptation, in which adaptation can be performed on the macro level of architecture and easier to control. However, the big gap between the problem space (business goal and environment) and the solution space (software architecture and components), and the runtime decision-making for adaptation are two difficulties for the implementation of business-oriented self-adaptation. In this paper, we propose an approach of decision support for dynamic adaptation of business systems based on feature binding analysis. In the method, feature model is introduced to represent the business policy and bridge the gap. So, dynamic adaptation can first be performed on feature binding analysis. The other characteristic of the method is CBR (case based reasoning) based adaptation decision on environment factors captured by all kinds of sensors.