Large language models suffer from hallucinations when performing scientific computing, motivating the use of AI agents such as IronClaw that offload computation to specialized tools. IronClaw invokes tools implemented as WebAssembly (Wasm) plugins for security and extensibility, but the stack-based Wasm bytecode is mismatched with register-based processors (x86, ARM), causing runtime overhead. We propose PAWS, a native Wasm coprocessor that directly executes Wasm bytecode in hardware. PAWS features: (1) full support for all five Wasm instruction types; (2) dual digital stack circuits (operand stack and control stack) replacing register files to minimize memory access latency; (3) dedicated control logic for block-based branching; and (4) a sliding-window instruction fetch unit that decodes variable-length Wasm instructions. Evaluated on the PolyBench suite, PAWS achieves average execution latencies 28.6× lower than an Intel Xeon processor and 40.6× lower than an Nvidia Jetson TX2, making it highly suitable for IronClaw’s compute-intensive scientific applications. The design is available at https://github.com/Iris-WQP/PAWS_FPGA_softcore.

Running LLMs on devices like smartphones has become a key catalyst towards privacy-preserving mobile AI. In state-of-the-art frameworks, the attention operator falls back from the dedicated NPU to the public CPU/GPU due to its sensitivity to quantization. Such a fallback leads to hampered user experience and extra system scheduling complexity. To realize NPU-centric LLM inference, this paper presents shadowNPU, a system-algorithm codesigned sparse attention module with minimal reliance on CPU/GPU by only sparsely computing a very small number of tokens. The key idea is to hide the overhead of estimating the important tokens by offloading it to NPU. On top of this, it further incorporates insightful techniques including NPU compute graph bucketing, head-wise NPU-CPU/GPU pipeline and per-head fine-grained sparsity ratio to achieve high accuracy and efficiency. Compared to design alternatives, shadowNPU achieves the best performance with strictly limited CPU/GPU resource; it requires much less CPU/GPU resource to achieve on-par performance of SoTA frameworks.

Vision Language Models (VLMs) are foundational for low-latency, privacy-preserving on-device AI in real-time applications like UI agents and VQA. The VLM prefilling phase, which processes the entire visual-textual input, faces the critical challenge of a long Time-to-First-Token (TTFT). One promising approach to reduce TTFT is to exploit the temporal locality by reusing block-level computations across consecutive frames. Unfortunately, current Transformer-based VLMs break the spatial invariance of CNNs and invalidate the strict-prefix KV-cache mechanism of decoder-only LLMs; in practice, even a single-pixel mismatch can prevent reuse.

Developers’ technical expertise is crucial for numerous tasks within open-source communities, such as identifying suitable developers and maintainers. Despite its significance, GitHub, the world’s largest open-source code hosting platform, does not explicitly display developers’ technical expertise. Existing methods fall short in capturing the multi-faceted and dynamic nature of developers’ skills and knowledge. To address this gap, we propose a novel approach that leverages graph neural networks (GNNs) to express developers’ technical expertise. Our method constructs a comprehensive GitHub social network that integrates various social and development activities. We then employ a GNN model to learn a low-dimensional representation vector for each developer, encapsulating their technical expertise across different dimensions. We assess the effectiveness of our model by comparing it against five baselines on three GitHub social relationship recommendation tasks, including SimDeveloper, ContributionRepo, and RepoMaintainer. Our proposed method outperforms these baselines, achieving improvements of 5.6–9.5% on Hit Ratio@10 and 3.4–11.1% on F1 score. These results demonstrate promising performance in predicting technical preferences for both repositories and developers. This research contributes to a more nuanced understanding of developer expertise in open-source communities and has potential implications for improving collaboration and project management on platforms like GitHub.

WebAssembly (Wasm) is an emerging binary format that serves as a compilation target for over 40 programming languages. Wasm runtimes provide execution environments that enhance portability by abstracting away operating systems and hardware details. A key component in these runtimes is the WebAssembly System Interface (WASI), which manages interactions with operating systems, like file operations. Considering the critical role of Wasm runtimes, the community has aimed to detect their implementation bugs. However, no work has focused on WASI-specific bugs that can affect the original functionalities of running Wasm binaries and cause unexpected results. To fill the void, we present DrWASI , the first general-purpose differential testing framework for WASI implementations. Our approach uses a large language model to generate seeds and applies variant and environment mutation strategies to expand and enrich the test case corpus. We then perform differential testing across major Wasm runtimes. By leveraging dynamic and static information collected during and after the execution, DrWASI can identify bugs. Our evaluation shows that DrWASI uncovered 33 unique bugs, with all confirmed and 7 fixed by developers. This research represents a pioneering step in exploring a promising yet under-explored area of the Wasm ecosystem, providing valuable insights for stakeholders.

Currently, there are various scientific and technological resource retrieval databases in the world. The resources stored in these databases may be identified by different identification systems. How to determine whether scientific and technological resources identified by different identification systems are the same resource is an urgent problem to be solved. This paper proposes a software service that leverages BERT and large language models to perform semantic analysis and similarity matching of scientific and technological resource content, and then maps the resources to their respective identifiers. The service effectively solves the problem of how to quickly retrieve the same resource from a large number of scientific and technological resources with diverse identification types, and improves the efficiency and quality of the retrieval. Implemented as a Chrome plugin, the service facilitates seamless mapping heterogeneous scientific and technological resources to their identifiers. We conduct a series of experiments. Their results demonstrate the effectiveness, scalability and stability of the service. To the best of our knowledge, we are the first to propose the service integrating BERT with large language models to extract and identify the key content of scientific and technological resources from web pages.

Kaibo Liu, Zhenpeng Chen, Yiyang Liu, Jie M. Zhang, Mark Harman, Yudong Han, Yun Ma, Yihong Dong, Ge Li, Gang Huang. Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers). 2025.

On-device inference for Large Language Models (LLMs), driven by increasing privacy concerns and advancements of mobile-sized models, has gained significant interest. However, even mobile-sized LLMs (e.g., Gemma-2B) encounter unacceptably high inference latency, often bottlenecked by the prefill stage in tasks like screen UI understanding.

Logs record essential information about system operations and serve as a critical source for anomaly detection, which has generated growing research interest. Utilizing large language models (LLMs) within a retrieval-augmented generation (RAG) framework for log-based anomaly detection is an effective approach due to its strong generalization capabilities and efficient few-shot performance. However, the effectiveness of this method hinges on the quality of the knowledge source, which can be impacted by noise and changes within the software systems. Facing these problems, in this paper, we propose a novel log-based anomaly detection method named EagerLog, employing active learning to choose the logs for humans to label, thereby adding them to the knowledge source, thus enhancing the knowledge source and maintaining its quality. Our experiments on three open datasets (BGL, Thunderbird, Zookeeper) and one industrial dataset demonstrate that EagerLog can achieve 93.65% F1 score with approximately 10 labeled log sequences, surpassing existing methods by 15.32%.

Accurately diagnosing the fault that causes the failure is crucial for maintaining the reliability of a microservice system after a failure occurs. Mainstream fault diagnosis approaches are data-driven and mainly rely on three modalities of runtime data: traces, logs, and metrics. Diagnosing faults with multiple modalities of data in microservice systems has been a clear trend in recent years because different types of faults and corresponding failures tend to manifest in data of various modalities. Accurately diagnosing faults by fully leveraging multiple modalities of data is confronted with two challenges: 1) how to minimize information loss when extracting features for data of each modality; 2) how to correctly capture and utilize the relationships among data of different modalities. To address these challenges, we propose FAMOS, a Fault diagnosis Approach for MicrOservice Systems through effective multi-modal data fusion. On the one hand, FAMOS employs independent feature extractors to preserve the intrinsic features for each modality. On the other hand, FAMOS introduces a new Gaussian-attention mechanism to accurately correlate data of different modalities and then captures the inter-modality relationship with a crossattention mechanism. We evaluated FAMOS on two datasets constructed by injecting comprehensive and abundant faults into an open-source microservice system and a real-world industrial microservice system. Experimental results demonstrate the FAMOS's effectiveness in fault diagnosis, achieving significant improvements in F1 scores compared to state-of-the-art (SOTA) methods, with an increase of 20.33 %.

Log-based anomaly detection is essential for maintaining software availability. However, existing log-based anomaly detection approaches heavily rely on fine-grained exact labels of log entries which are very hard to obtain in real-world systems. This brings a key problem that anomaly detection models require supervision signals while labeled log entries are unavailable. Facing this problem, we propose a new labeling strategy called inexact labeling that instead of labeling an log entry, system experts can label a bag of log entries in a time span. Furthermore, we propose MIDLog, a weakly supervised log-based anomaly detection approach with inexact labels. We leverage the multiinstance learning paradigm to achieve explicit separation of anomalous log entries from the inexact labeled anomalous log set so as to deduce exact anomalous log labels from inexact labeled log sets. Extensive evaluation on three public datasets shows that our approach achieves an F1 score of over 85% with inexact labels.

Log-based anomaly detection is an important task in ensuring the stability and reliability of software systems. One of the key problems in this task is the lack of labeled logs. Existing works usually leverage large-scale labeled logs from mature systems to train an anomaly detection model of a target system based on the idea of transfer learning. However, these works still require a certain number of labeled logs from the target system. In this paper, we take a step forward and study a valuable yet underexplored setting: zero-label cross-system log-based anomaly detection, that is, no labeled logs are available in the target system. Specifically, we propose ZeroLog, a system-agnostic representation meta-learning method that enables cross-system log-based anomaly detection under zero-label conditions. To achieve this, we leverage unsupervised domain adaptation to perform adversarial training between the source and target domains, aiming to learn system-agnostic general feature representations. By employing meta-learning, the learned representations are further generalized to the target system without any target labels. Experimental results on three public log datasets from different systems show that ZeroLog reaches over $\mathbf{8 0 \%}$ F1-score without labels, comparable to state-of-the-art cross-system methods trained with labeled logs, and outperforms existing methods under zero-label conditions.

Log-based anomaly detection is a essential task for ensuring the reliability and performance of software systems. However, the performance of existing anomaly detection methods heavily relies on labeling, while labeling a large volume of logs is highly challenging. To address this issue, many approaches based on transfer learning and active learning have been proposed. Nevertheless, their effectiveness is hindered by issues such as the gap between source and target system data distributions and cold-start problems. In this paper, we propose LogAction, a novel log-based anomaly detection model based on active domain adaptation. LogAction integrates transfer learning and active learning techniques. On one hand, it uses labeled data from a mature system to train a base model, mitigating the cold-start issue in active learning. On the other hand, LogAction utilize free energy-based sampling and uncertainty-based sampling to select logs located at the distribution boundaries for manual labeling, thus addresses the data distribution gap in transfer learning with minimal human labeling efforts. Experimental results on six different combinations of datasets demonstrate that LogAction achieves an average 93.01% F1 score with only 2% of manual labels, outperforming some state-of-the-art methods by 26.28%. Website: https://logaction.github.io

Log-based fault diagnosis is essential for maintaining software system availability. However, existing fault diagnosis methods are built using a task-independent manner, which fails to bridge the gap between anomaly detection and root cause localization in terms of data form and diagnostic objectives, resulting in three major issues: 1) Diagnostic bias accumulates in the system; 2) System deployment relies on expensive monitoring data; 3) The collaborative relationship between diagnostic tasks is overlooked. Facing this problems, we propose a novel end-to-end log-based fault diagnosis method, Chimera, whose key idea is to achieve end-to-end fault diagnosis through bidirectional interaction and knowledge transfer between anomaly detection and root cause localization. Chimera is based on interactive multitask learning, carefully designing interaction strategies between anomaly detection and root cause localization at the data, feature, and diagnostic result levels, thereby achieving both sub-tasks interactively within a unified end-to-end framework. Evaluation on two public datasets and one industrial dataset shows that Chimera outperforms existing methods in both anomaly detection and root cause localization, achieving improvements of over 2.92%~5.00% and 19.01% ~ 37.09%, respectively. It has been successfully deployed in production, serving an industrial cloud platform.

Log-based software reliability maintenance systems are crucial for sustaining stable customer experience. However, existing deep learning-based methods represent a black box for service providers, making it impossible for providers to understand how these methods detect anomalies, thereby hindering trust and deployment in real production environments. To address this issue, this paper defines a trustworthiness metric—diagnostic faithfulness—for models to gain service providers’ trust, based on surveys of SREs at a major cloud provider. We design two evaluation tasks: attention-based root cause localization and event perturbation. Empirical studies demonstrate that existing methods perform poorly in diagnostic faithfulness. Consequently, we propose FaithLog, a faithful log-based anomaly detection system, which achieves faithfulness through a carefully designed causality-guided attention mechanism and adversarial consistency learning. Evaluation results on two public datasets and one industrial dataset demonstrate that the proposed method achieves state-of-the-art performance in diagnostic faithfulness.

Frequent software updates lead to log evolution, posing generalization challenges for current log anomaly detection. Traditional log anomaly detection research focuses on using small deep learning models (SMs), but these models inherently lack generalization due to their closed-world assumption. Large language models (LLMs) exhibit strong semantic understanding and generalization capabilities, making them promising for log anomaly detection. However, they suffer from computational inefficiencies. To balance efficiency and generalization, we propose a collaborative log anomaly detection scheme (CoorLog) that uses an adaptive coordinator to integrate SM and LLM. The coordinator determines if incoming logs have evolved. Non-evolved logs are routed to the SM, while evolved logs are directed to the LLM for detailed inference using the constructed Evol-CoT. To gradually adapt to evolution, we introduce the adaptive evolution mechanism (AEM), which updates the coordinator to redirect evolved logs identified by the LLM to the SM. Simultaneously, the SM is fine-tuned to inherit the LLM’s judgment on these logs. Extensive experiments on real-world datasets demonstrate that CoorLog achieves superior F1-scores in both intra-version and inter-version anomaly detection. Additionally, CoorLog reduces processing time by 91.63% and token consumption by 85.59% compared to using an LLM alone.

On-device Large Language Models (LLMs) are transforming mobile AI, catalyzing applications like UI automation without privacy concerns. Nowadays the common practice is to deploy a single yet powerful LLM as a general task solver for multiple requests. We identify a key system challenge in this paradigm: current LLMs lack the elasticity to serve requests that have diversified Service-Level Objectives (SLOs) on inference latency. To tackle this, we present ElastiLM, an on-device LLM service that elasticizes both the model and the prompt dimension of a full LLM. It incorporates (1) a one-shot neuron-reordering method, which leverages the intrinsic permutation consistency in transformer models to generate high-quality elasticized sub-models with minimal runtime switching overhead; (2) a dual-head tiny language model, which efficiently and effectively refines the prompt and orchestrates the elastification between model and prompt. We implement such an elastic on-device LLM service on multiple COTS smartphones, and evaluate ElastiLM on both standalone NLP/mobile-agent datasets and end-to-end synthesized traces. On diverse SLOs, ElastiLM outperforms 7 strong baselines in (absolute) accuracy by up to 14.83% and 10.45% on average, with <1% TTFT switching overhead, on-par memory consumption and <100 offline GPU hours.

The development of effective diagnostic methodolo-gies for software system failures is of paramount importance. Traditional methods, which rely on specialized terminology and intricate reasoning, require users to have a technical background, resulting in reduced flexibility and decreased user-friendliness. With the rise of generative large language models, optimizing human-computer interaction has become a critical area of focus. Additionally, the inherent intelligence and extensive knowledge of large language models make them both easy and effective to employ for fault diagnosis assistance. We introduce IFKG, an advanced tool for diagnosing software system failures. IFKG integrates generative large language models with knowledge graphs, employing natural language interactions to implement fault detection and deliver solutions. IFKG enables users to upload descriptive problems, retrieve pertinent information from the knowledge graph, and present diagnostic results in natural language. Our accuracy assessments across diverse software system failures indicate that the IFKG provides targeted and actionable recommendations, effectively assisting users in ad-dressing a range of software system issues. The tool is available on GitHub at https://github.com/mako-xxlIFKG, and the demo video can be found on YouTube: https://youtu.belDie2vgZm2hk.

Workflow decision making is critical to performing many practical applications of scientific principles and data. Scheduling in edge-cloud environments can address the high complexity of workflow applications, while decreasing the data transmission delay between the cloud and end devices. However, due to the heterogeneous resources in edge-cloud environments and the complicated data dependencies between the tasks in a workflow, significant challenges for workflow scheduling remain, including the selection of an optimal tasks-servers solution from the possible numerous combinations. Existing studies are mainly done subject to rigorous conditions without fluctuations, ignoring the fact that workflow scheduling is typically present in uncertain environments. In this study, we focus on reducing the execution cost of multiple workflow applications mainly caused by data transmission and task computation, while satisfying the required deadline constraints. Triangular fuzzy numbers are employed to represent the computing performance of servers and transmission bandwidth in fuzzy edge-cloud environments. A cost-driven scheduling strategy for multiple Poisson-arrived workflow applications using partial critical paths is proposed. It firstly merges cut edges through preprocess to reduce the workflow scale, then uniformly schedules all tasks on each partial critical path to avoid data transmission between dependent tasks and reduce the data transmission cost. The experimental results show that our strategy can obtain the optimal feasible scheduling scheme and have better robustness and real-time performance with different deadline constraints, compared with other benchmark strategies. Note to Practitioners—Vehicle identification is one of the workflow decision making systems in transportation environments, whose core technology is Deep Neural Networks (DNN). Traffic cameras with limited process capacity periodically record the images of on-road vehicles, and usually fail to complete the applications within their deadlines. Workflow decision making is one of the key issues to performance DNNs in vehicle identification applications. The uncertain environments have a great impact on the system latency for such problems, which can easily lead to the misjudgement of the optimal scheduling. In addition, it is difficult to select an optimal layers-servers solution from the numerous combinations. Therefore, we can employ the scheduling strategy (i.e., SWPCP) to make intelligent and faster workflow decisions for vehicle identification applications, which can reduce the execution cost mainly caused by layer computation and data transmission between layers within their deadlines, even in uncertain edge-cloud environments. Complex DNN layers (tasks) in vehicle identification applications can be scheduled to the cloud for execution, while simple ones are processed on the edge. The cloud and edge platforms collaborate with each other and execute the DNN layers with low system cost and latency.

Companies such as CrowdStrike now offer cloud-based services for provenance analysis, which collects low-level system events from a customer's device and compiles them onto a centralized platform to detect APT attacks. Despite the effectiveness of such solutions, their privacy implications remain unclear. To assess the privacy implications of system provenance analysis, we employ the Website Fingerprinting (WF) of The Onion Router (Tor) browsers as the real-world attack scenario. In contrast to conventional, network traffic-based WF techniques, we have designed ProvAudit, a fully automated solution that audits the web browsing history of Tor browsers based on system provenance data. We conduct the first systematic case study to demonstrate the feasibility of inferring the websites visited by Tor browsers solely based on the collected system provenance data, particularly system call traces. The evaluation results show that our approach achieves a precision of 0.74 in the open-world scenario, higher than the state-of-the-art robust WF technique. In practice, ProvAudit consumes approximately 23 MB of memory and 4% CPU to audit system provenance data. Our approach is more robust against simple adversarial methods, more accurate, and less expensive than existing solutions. Overall, our case study reveals that provenance data is susceptible to privacy breaches, potentially exposing more high-level information than anticipated.

The recent emergence of Low Earth Orbit (LEO) mega-constellations, designed for high-speed broadband connections with low latency, has introduced new deployment challenges. Efficient launch sequence planning is crucial for rapid service rollout, performance enhancement, and service promotion. However, existing research predominantly focuses on the design and performance analysis of fully-deployed constellations and overlooks the evolving process from a partially-deployed constellation to a fully-deployed one. This paper explores the launch sequence optimization problem for mega-constellations, tailored to expedite service delivery and adapt to changing performance demands. To this end, (1) we identify critical network performance metrics for the constellation evolving process and construct a simulation toolchain capable of simulating and evaluating these metrics for any potential partially-deployed constellation. (2) Drawing upon three key observations on network availability, the number of visible satellites, and latency, we propose an algorithm that can construct a launch sequence for an arbitrary mega-constellation topology. Evaluation results show that this algorithm enables the early provision of services and maximizes network performance gains at each launch batch while catering to different user demands. For instance, our algorithm can achieve network performance nearly equivalent to that of Starlink when it initiated its service, without losing redundancy, while using 55% fewer satellites.

WebAssembly (abbreviated as Wasm) was initially introduced for the Web and quickly extended its reach into various domains beyond the Web. To create Wasm applications, developers can compile high-level programming languages into Wasm binaries or manually write the textual format of Wasm and translate it into Wasm binaries by the toolchain. Regardless of whether it is utilized within or outside the Web, the execution of Wasm binaries is supported by the Wasm runtime. Such a runtime provides a secure, memory-efficient, and sandboxed execution environment to execute Wasm binaries. This article provides a comprehensive survey of research on Wasm runtimes with 103 collected research papers related to Wasm runtimes following the traditional systematic literature review process. It characterizes existing studies from two different angles, including the internal research of Wasm runtimes (Wasm runtime design, testing, and analysis) and the external research (applying Wasm runtimes to various domains). This article also proposes future research directions about Wasm runtimes.

Federated learning (FL) is an emerging promising paradigm of privacy-preserving machine learning (ML). An important type of FL is cross-silo FL, which enables a moderate number of organizations to cooperatively train a shared model by keeping confidential data locally and aggregating gradients on a central parameter server. However, the central server may be vulnerable to malicious attacks or software failures in practice. To address this issue, in this paper, we propose$\mathtt{DegaFL} $, a novel decentralized gradient aggregation approach for cross-silo FL.$\mathtt{DegaFL} $eliminates the central server by aggregating gradients on each participant, and maintains and synchronizes gradients of only the current training round. Besides, we propose$\mathtt{AdaAgg} $to adaptively aggregate correct gradients from honest nodes and use HotStuff to ensure the consistency of the training round number and gradients among all nodes. Experimental results show that$\mathtt{DegaFL} $defends against common threat models with minimal accuracy loss, and achieves up to$50\times$reduction in storage overhead and up to$13\times$reduction in network overhead, compared to state-of-the-art decentralized FL approaches.

Intelligent applications rely significantly on the live machine learning pipeline, a couple of deep neural network (DNN) inference services, executed on mobile devices to meet functional requirements while ensuring user data privacy. However, executing these DNN services on resource-constrained mobile devices presents a considerable challenge: low throughput and high energy consumption of inference tasks. To address this issue, we proposeNiagara+, a novel system designed to enhance throughput by jointly scheduling DNN inference services across heterogeneous processors on mobile devices and offloading services to powerful edge servers. To achieve this,Niagara+encounters two critical challenges: unpredictable workload dynamics and high scheduling complexity. To effectively tackle these challenges,Niagara+employs a predictive model to forecast incoming workload patterns and orchestrates service allocation across device heterogeneous processors and edge servers through a combination of two-step offline scheduling optimization and online service dispatching strategies. We implementedNiagara+and conducted comprehensive experiments, demonstrating its superiority over state-of-the-art approaches, reducing DNN service latency by up to 2.6× under high-bandwidth networks and 9.1× under low-bandwidth networks, while consistently meeting stringent inference latency requirements.

N owadays, software service design is increasingly oriented toward addressing human needs, aiming to extract users' needs and behavioral patterns from open-source data. GitHub's massive open-source repositories have emerged as a crucial data source for software service researchers seeking to extract valuable insights and develop software services tailored for developers. Both GitHub and researchers are making efforts to help researchers and developers better utilize GitHub data. In 2017, GitHub launched “topics”, enabling developers to assign keywords to repositories. This feature fosters linkages between repositories, aiding in their discovery by other developers. For software development, topics offer two significant values. First, topics provide researchers with new insights to better mine GitHub data and provide enhanced support for developers. Second, developers utilizing topics to annotate their repositories may enhance their visibility and engagement within the community, potentially bolstering their repository's popularity. Despite the increasing number of topics, no research has systematically analyzed their content and potential value. Therefore, we conduct the first empirical study on topics, providing valuable conclusions for future researchers and developers. We conduct a case study encompassing 900 repositories to analyze the information explicitly presented in the topic content, and three experiments to verify whether topics have the potential to be used as repository features and user features in GitHub-related studies. Furthermore, we delve into the correlation between topics and repository popularity, by analyzing the number of stars repositories received. Our findings cover the composition of topic content, the potential value of topics for GitHub-related research, and the impact of topics on repository popularity.

SoC-Cluster, a novel server architecture composed of massive mobile system-on-chips (SoCs), is gaining popularity in industrial edge computing due to its energy efficiency and compatibility with existing mobile applications. However, we observe that the deployed SoC-Cluster servers are not fully utilized, because the hosted workloads are mostly user-triggered and have significant tidal phenomena. To harvest the free cycles, we propose to co-locate deep learning tasks on them.

In the traditional Service-Oriented Architecture (SOA), Web service providers register their service descriptions in the registry for service clients to perform service discovery and invocation. Although this architecture provides loose service invocation, it lacks a dispute resolution mechanism to guarantee the trusted service invocation between untrustworthy service providers and clients. Blockchain technology has unparalleled advantages in decentralization and tamper-resistance, and can be employed in the SOA to solve the untrustworthiness of service invocation. Combining the SOA architecture and blockchain technology, this paper proposes a blockchain-based trust framework for SOA, where the blockchain is used as an evidence recorder and a service registration proxy. To ensure the service traceability, each service invocation is signed by both the service provider and client involved as a trusted credential on the blockchain. The trusted credentials on the blockchain will be retrieved for verification when a service dispute occurs. Moreover, the input parameters and results of a service are encrypted during constructing trusted credentials to ensure the privacy of service data. The experimental results show that the proposed framework can correctly handle the service disputes between service providers and clients in the case of all independent malicious behaviors and most of the combined malicious behaviors, compared with traditional methods. It also could realize the automatic conversion from Web services to trusted services, and complete the trusted service invocation within 2.Ss.

Log-based anomaly detection is an essential task in maintaining software reliability. Existing log-based anomaly detection approaches often consist of three key phases: log parsing, event embedding, and model construction. Event embedding efficiently extracts semantic information from log events and produces vector representations of log events. However, existing event embedding methods suffer from two key problems. First, semantic noises are buried in log events leading to inevitable gaps between the obtained semantics from log events and their essential meanings. Second, there exists a gap between general semantic embedding and the specific embedding requirement of anomaly detection tasks. To mitigate these problems and improve the quality of representations of log events, we propose a novel anomaly detection approach named LLMeLog. It leverages the capabilities of large language models (LLMs) to enrich the contents of log events with in-context learning techniques. Then it utilizes the enriched log events to fine-tune a pre-trained BERT model. At last, it trains a transformer-based anomaly detection model with the event representations produced by the pre-trained BERT model. Evaluation results on three public log datasets show that LLMeLog achieves the best performance across all datasets, boasting F1-scores exceeding 99%. Besides, when using only 10% of labeled data as training data, our approach can still achieve over 90% F1-scores.

Log-based anomaly detection plays a crucial role in maintaining the reliability of software systems. Unsupervised models are more suitable for real-world usage because they do not rely on huge data labeling efforts. However, their effectiveness is limited because of the lack of supervision of data labels. To balance model effectiveness and labeling efforts, existing approaches enhance model capabilities by incorporating relatively few but key human labels as a golden signal, thereby improving the model ability with acceptable labeling efforts. However, these methods still face limitations of complex human labels and insufficient utilization of human knowledge. In this paper, we introduce LogCAE, a two-stage log anomaly detection approach based on active learning and contrastive learning. It utilizes an unsupervised model to learn from unlabeled log data without human labels and incorporates human knowledge through active learning during online optimization. We employ contrastive learning to optimize the representation of log samples in feature space for more efficient usage of human labels. We conducted experiments on three distinct public log datasets (Thunderbird, BGL, and Zookeeper). The results show that our method improves 12.93% F1-score on average with 6.06% labeled data samples. Besides, our approach is more effective in utilizing human labels than state-of-the-art approaches.

Developers' technical expertise is crucial for various tasks within open-source communities, such as identifying suitable maintainers or reviewers. However, GitHub, the world's largest open-source code hosting platform, does not explicitly display developers' technical expertise. Existing methods fail to fully capture the multifaceted and dynamic nature of their skills and knowledge. To address this problem, we propose a novel approach to derive developers' technical expertise using graph neural networks (GNN). We construct a GitHub social network to integrate social and development activities and employ a GNN model to learn low-dimensional embedding for developers' technical expertise. We verify the effectiveness of our model on four GitHub social relationship recommendation tasks. The results demonstrate that our approach performs well in predicting technical preference for repositories and developers.

We call a program that passes existing tests but still contains bugs as a buggy plausible program. Bugs in such a program can bypass the testing environment and enter the production environment, causing unpredictable consequences. Therefore, discovering and fixing such bugs is a fundamental and critical problem. However, no existing bug dataset is purposed to collect this kind of bug, posing significant obstacles to relevant research. To address this gap, we introduce TrickyBugs, a bug dataset with 3,043 buggy plausible programs sourced from human-written submissions of 324 real-world competition coding tasks. We identified the buggy plausible programs from approximately 400,000 submissions, and all the bugs in TrickyBugs were not previously detected. We hope that TrickyBugs can effectively facilitate research in the fields of automated program repair, fault localization, test generation, and test adequacy.

On-device training Neural Networks (NNs) has been a crucial catalyst towards privacy-preserving and personalized mobile intelligence. Recently, a novel training paradigm, namely Parameter-Efficient Training (PET), is attracting attention in both the machine learning and system community. In our preliminary measurements, we find PET well-suited for on-device scenarios; yet, its parameter efficiency does not translate coequal to time efficiency on resource-constrained devices, as the training time is dominated by the frozen layers.

In the realm of industrial edge computing, a novel server architecture known as SoC-Cluster, characterized by its aggregation of numerous mobile systems-on-chips (SoCs), has emerged as a promising solution owing to its enhanced energy efficiency and seamless integration with prevalent mobile applications. Despite its advantages, the utilization of SoC-Cluster servers remains unsatisfactory, primarily attributed to the tidal patterns of user-initiated workloads. To address such inefficiency, we introduceSoCFlow+, a pioneering framework designed to facilitate the co-location of deep learning training tasks on SoC-Cluster servers, thereby optimizing resource utilization.SoCFlow+incorporates three novel techniques tailored to mitigate the inherent limitations of commercial SoC-Cluster servers. First, it employs group-wise parallelism complemented by delayed aggregation, a strategy engineered to enhance the training efficiency and scalability of deep learning models, effectively circumventing network bottlenecks. Second, it integrates a data-parallel mixed-precision training algorithm, optimized to exploit the heterogeneous processing capabilities inherent to mobile SoCs fully. Third,SoCFlow+employs an underclocking-aware workload re-balanacing mechanism to tackle the training performance degradation caused by the thermal control of mobile SoCs. Through rigorous experimental validation,SoCFlow+achieves a convergence speedup ranging from 1.6× to 740× across 32 SoCs, compared to conventional benchmarks. Furthermore, when juxtaposed with commodity GPU servers (e.g., NVIDIA V100) under identical power constraints,SoCFlow+not only exhibits comparable training speed but also achieves a remarkable reduction in energy consumption by a factor of 2.31× to 10.23×, all while preserving convergence accuracy.

Federated learning (FL) becomes a promising machine learning paradigm. The impact of heterogeneous hardware specifications and dynamic states on the FL process has not yet been studied systematically. This paper presents the first large-scale study of this impact based on real-world data collected from 136k smartphones. We conducted extensive experiments on our proposed heterogeneity-aware FL platform namelyFLASH, to systematically explore the performance of state-of-the-art FL algorithms and key FL configurations in heterogeneity-aware and -unaware settings, finding the following. (1) Heterogeneity causes accuracy to drop by up to 9.2% and convergence time to increase by 2.32×. (2) Heterogeneity negatively impacts popular aggregation algorithms, e.g., the accuracy variance reduction brought byq-FedAvgdrops by 17.5%. (3) Heterogeneity does not worsen the accuracy loss caused by gradient-compression algorithms significantly, but it compromises the convergence time by up to 2.5×. (4) Heterogeneity hinders client-selection algorithms from selecting wanted clients, thus reducing effectiveness. e.g., the accuracy increase brought by the state-of-the-art client-selection algorithm drops by 73.9%. (5) Heterogeneity causes the optimal FL hyper-parameters to drift significantly. More specifically, the heterogeneity-unaware setting favors looser deadline and higher reporting fraction to achieve better training performance. (6) Heterogeneity results in non-trivial failed clients (more than 10%) and leads to participation bias (the top 30% of clients contribute 86% of computations). Our FLASH platform and data have been publicly open sourced.

WebAssembly (abbreviated WASM) has emerged as a promising language of the Web and also been used for a wide spectrum of software applications such as mobile applications and desktop applications. These applications, named WASM applications, commonly run in WASM runtimes. Bugs in WASM runtimes are frequently reported by developers and cause the crash of WASM applications. However, these bugs have not been well studied. To fill in the knowledge gap, we present a systematic study to characterize and detect bugs in WASM runtimes. We first harvest a dataset of 311 real-world bugs from hundreds of related posts on GitHub. Based on the collected high-quality bug reports, we distill 31 bug categories of WASM runtimes and summarize their common fix strategies. Furthermore, we develop a pattern-based bug detection framework to automatically detect bugs in WASM runtimes. We apply the detection framework to seven popular WASM runtimes and successfully uncover 60 bugs that have never been reported previously, among which 13 have been confirmed and 9 have been fixed by runtime developers.

Satellite edge computing can incur dramatically increased energy demand onboard, which is met by satellite batteries during eclipses. Excessive energy usage during regular operations accelerates battery wear. Therefore, it is important and timely to optimize the energy consumption onboard to extend satellite batteries life. This paper investigates battery-aware energy optimization for satellite edge computing under energy harvesting dynamics and wireless environment uncertainty. Inspired by the periodical energy harvesting and satellite-ground connection, we develop a pattern-aware online energy scheduling algorithm within an online convex optimization framework. This learning algorithm achieves theoretical guarantees of no regret and gradually zeroing constraint violations. We further exploit inter-satellites collaboration to extend the average battery life in a whole constellation where satellites have different battery capacity degradation. Trace-driven simulations show that our algorithm can significantly extend the battery life by 1.32× and effectively adapt to the energy harvesting dynamics and wireless environment uncertainty.

This paper proposes ElasticFlow, an elastic serverless training platform for distributed deep learning. ElasticFlow provides a serverless interface with two distinct features: (i) users specify only the deep neural network (DNN) model and hyperparameters for a job, but not the number of GPUs; (ii) users specify the deadline for a job, but not the amount of time to occupy GPUs. In contrast to existing server-centric platforms, ElasticFlow provides performance guarantees in terms of meeting deadlines while alleviating tedious, low-level, and manual resource management for deep learning developers. The characteristics of distributed training introduce two challenges. First, the training throughput scales non-linearly with the number of GPUs. Second, the scaling efficiency is affected by worker placement. To address these challenges, we propose Minimum Satisfactory Share to capture the resource usage of training jobs to meet deadlines, and ElasticFlow performs admission control based on it. We develop a greedy algorithm that dynamically allocates resources to admitted jobs based on diminishing returns. We apply buddy allocation to worker placement to eliminate the effect of topology. Evaluation results on a cluster of 128 GPUs show that ElasticFlow increases the number of jobs that can meet their deadlines by 1.46–7.65× compared to existing solutions.

RAID (Redundant Array of Independent Disks) has been widely adopted for decades, as it provides enhanced throughput and redundancy beyond what a single disk can offer. Today, enabled by fast datacenter networks, accessing remote block devices with acceptable overhead (i.e. disaggregated storage) becomes a reality (e.g., for serverless applications). Combining RAID with remote storage can provide the same benefits while creating better fault tolerance and flexibility than its monolithic counterparts. The key challenge of disaggregated RAID is to handle extra network traffic generated by RAID, which can consume a vast amount of NIC bandwidth. We present dRAID, a disaggregated RAID system that achieves near-optimal read and write throughput. dRAID exploits peer-to-peer disaggregated data access to reduce bandwidth consumption in both normal and degraded states. It employs non-blocking multi-stage writes to maximize inter-node parallelism, and applies pipelined I/O processing to maximize inter-device parallelism. We introduce bandwidth-aware reconstruction for better load balancing. We show that dRAID provides up to 3× bandwidth improvement. The results on a lightweight object store show that dRAID brings 1.5×-2.35× throughput improvement on various workloads.

Log-based anomaly detection is an essential aspect of maintaining software reliability, particularly in the context of microservice systems. However, existing log-based anomaly detection approaches rely on historical anomalous labeled data or require huge labeling efforts. This makes existing log-based anomaly detection approaches inefficient. In this paper, we propose AcLog, a novel anomaly detection approach that incorporates human knowledge to enhance model ability based on the framework of deep active learning. It incorporates an unsupervised model to learn from normal log data rather than historical anomalous labeled data and leverages active learning to incorporate human knowledge as a golden signal to augment the quality of training log data. Experiment results on three open log datasets and one log dataset collected from a real-world microservice system show that our approach improves over 7% F1-score with 5% labeled training data on average.

Before software developers actually start coding, an essential requirement is to be proficient in a programming language. However, as an important learning resource, programming language textbooks usually contain much about syntax and semantics of a programming language, but little about pragmatics, which is highly relevant with practical skills in solving real-world problems using programming languages. This makes it difficult for learners to transfer knowledge from textbooks to practice.To solve this problem, this paper proposes a programming language learning service, utilizing abundant development knowledge in Stack Overflow (SO) Q&A posts as the pragmatics knowledge of programming languages to make up for the shortage of pragmatics knowledge in textbooks. To link SO Q&A posts with textbooks, this paper first proposes a deep learning classification model to recognize SO posts containing development knowledge. Second, to align filtered SO posts with programming language learning processes, this paper proposes a weakly supervised link approach to matching SO posts with chapters and sections of textbooks. The feature of weak supervision ensures that the approach can be easily extended to other textbooks. Based on these modules above, this paper implements the programming language learning service in the form of a Chrome plugin. We conduct experiments and user study. Their results demonstrate the effectiveness, scalability and stability of the service.

Log-based anomaly detection is becoming more and more important for maintaining the availability of modern microservice systems. Existing supervised/semi-supervised log anomaly detection models require a large amount of human-labeled logs for training which are hard to collect in real-world systems. Unsupervised models often perform poorly without explicit anomaly labels. To improve the performance of unsupervised models, in this paper, we first make an empirical study of existing unsupervised models to tackle the reason why they often produce unsatisfied results. We find that anomaly detection results produced by existing unsupervised models are significantly affected by two key problems including Not-Cover (NC) problem and Suspicious-Noise (SN) problem. To solve these problems, we propose a novel augmentation framework called AFALog. AFALog leverages the idea of active learning to incorporate human knowledge so as to augment data quality. It can support almost all existing unsupervised models and improve their performance. Our experiments on two open datasets and one dataset collected from a real-world microservice system demonstrate that DALog improves the F1-score by an average of 6.61%, with only 5.9% labeled training data.

Online Judge platforms play a pivotal role in education, competitive programming, recruitment, career training, and large language model training. They rely on predefined test suites to judge the correctness of submitted solutions. It is therefore important that the solution judgement is reliable and free from potentially misleading false positives (i.e., incorrect solutions that are judged as correct). In this paper, we conduct an empirical study of 939 coding problems with 541,552 solutions, all of which are judged to be correct according to the test suites used by the platform, finding that 43.4% of the problems include false positive solutions (3,440 bugs are revealed in total). We also find that test suites are, nevertheless, of high quality according to widely-studied test effectiveness measurements: 88.2% of false positives have perfect (100%) line coverage, 78.9% have perfect branch coverage, and 32.5% have a perfect mutation score. Our findings indicate that more work is required to weed out false positive solutions and to further improve test suite effectiveness. We have released the detected false positive solutions and the generated test inputs to facilitate future research.

Serverless computing provides fine-grained resource elasticity for data analytics---a job can flexibly scale its resources for each stage, instead of sticking to a fixed pool of resources throughout its lifetime. Due to different data dependencies and different shuffling overheads caused by intra- and inter-server communication, the best degree of parallelism (DoP) for each stage varies based on runtime conditions.

IoT blockchain suffers heavy performance issues because of the massive transactions generated by various IoT nodes. By dividing nodes into different shards, sharding can produce blocks in parallel and hence improve the throughput of the blockchain system. Unlike the traditional blockchain system, IoT blockchain mainly consists of smart devices and the transactions are usually generated from the real world, such as the sensor data, photos taken by cameras, and so on. In IoT blockchain, closer nodes usually share a lower network latency and the transactions they generate are more related. Therefore, location-based sharding is an effective approach to improve the performance of IoT blockchain. Traditionally, IoT nodes are di-vided into different shards based on geographical locations or the connected edge server. However, the key challenge of sharding in IoT blockchain is how to guarantee the equality of shards division as to the unpredictable distribution and the dynamic behavior of IoT nodes. On one hand, shards can not be pre-divided because we can not predict the number or the distribution of the IoT nodes. On the other hand, nodes continuously joining or quitting shards will also break the equality of the shards division. In this paper, we propose Fission, a sharding mechanism designed for IoT blockchain. Fission divide shards based on the Voronoi diagram without any preknowledge about the nodes distribution, and support dynamic, autonomous sharding adjustment based on distributed Delaunay Triangulation. In addition, Fission uses a new diffusion-based consensus algorithm to achieve the linear scalability of throughput. The experimental results show that Fission can construct and adjust shards at a very low cost and can execute in a decentralized manner. The throughput can reach 1900tps in 500 nodes with only 5M bps bandwidth, and can scale linearly as the nodes increase.

With the increasing complexity of modern software systems, it is essential yet hard to detect anomalies and diagnose problems precisely. Existing log-based anomaly detection approaches rely on a few key assumptions on system logs and perform well in some experimental systems. However, real-world industrial systems are often with poor logging quality, in which system logs are noisy and often violate the assumptions of existing approaches. This makes these approaches inefficient. This paper first conducts a comprehensive study on the system logs of three large-scale industrial software systems. Through the study, we identify four typical anti-patterns that affect the detection results the most. Based on these patterns, we propose HiLog, an effective human-in-the-loop log-based anomaly detection approach that integrates human knowledge to augment anomaly detection models. With little human labeling effort, our approach can significantly improve the effectiveness of existing models. Experiment results on three large-scale industrial software systems show that our method improves over 50% precision rate on average.

This paper proposes Mandheling, the first system that enables highly resource-efficient on-device training by orchestrating mixed-precision training with on-chip Digital Signal Processor (DSP) offloading. Mandheling fully explores the advantages of DSP in integer-based numerical calculations using four novel techniques: (1) a CPU-DSP co-scheduling scheme to situationally mitigate the overhead from DSP-unfriendly operators; (2) a self-adaptive rescaling algorithm to reduce the overhead of dynamic rescaling in backward propagation; (3) a batch-splitting algorithm to improve DSP cache efficiency; (4) a DSP compute subgraph-reusing mechanism to eliminate the preparation overhead on DSP. We have fully implemented Mandheling and demonstrated its effectiveness through extensive experiments. The results show that, compared to the state-of-the-art DNN engines from TFLite and MNN, Mandheling reduces per-batch training time by 5.5X and energy consumption by 8.9X on average. In end-to-end training tasks, Mandheling reduces convergence time by up to 10.7X and energy consumption by 13.1X, with only 1.9%--2.7% accuracy loss compared to the FP32 precision setting.

On-device learning is a promising technique for emerging privacy-preserving machine learning paradigms. However, through quantitative experiments, we find that commodity mobile devices cannot well support state-of-the-art DNN training with a large enough batch size, due to the limited local memory capacity. To fill the gap, we propose Melon, a memory-friendly on-device learning framework that enables the training tasks with large batch size beyond the physical memory capacity. Melon judiciously retrofits existing memory saving techniques to fit into resource-constrained mobile devices, i.e., recomputation and micro-batch. Melon further incorporates novel techniques to deal with the high memory fragmentation and memory adaptation. We implement and evaluate Melon with various typical DNN models on commodity mobile devices. The results show that Melon can achieve up to 4.33× larger batch size under the same memory budget. Given the same batch size, Melon achieves 1.89× on average (up to 4.01×) higher training throughput, and saves up to 49.43% energy compared to competitive alternatives. Furthermore, Melon reduces 78.59% computation on average in terms of memory budget adaptation.

User mobility prediction is widely considered by the research community. Many studies have explored various algorithms to predict where a user is likely to visit based on their contexts and trajectories. Most of existing studies focus on specific targets of predictions. While successful cases are often reported, few discussions have been done on what happens if the prediction targets vary: whether coarser locations are easier to be predicted, and whether predicting the immediate next location on the trajectory is easier than predicting the destination. On the other hand, while spatiotemporal tags and content information are commonly used in current prediction tasks, few have utilized the finer grained, on-device user behavioral data, which are supposed to be more informative and indicative of user intentions. In this paper, we conduct a systematic study on the mobility prediction using a large-scale real-world dataset that contains plentiful contextual information. Based on a series of learning models, including a Markov model, two recurrent neural network models, and a multi-modal learning method, we perform extensive experiments to comprehensively investigate the predictability of different types of granularities of targets and the effectiveness of different types of signals. The results provide insightful knowledge on what can be predicted along with how, which sheds light on the real-world mobility prediction from a relatively general perspective.

Modern mobile OSes support to display Web pages in the native apps, which we call embedded Web pages. In this paper, we conduct, to the best of our knowledge, the first measurement study on browsing embedded Web pages on Android. Our study on 22,521 popular Android apps shows that 57.9% and 73.8% of apps embed Web pages on two popular app markets: Google Play and Wandoujia, respectively. To analyze the embedded Web browsing performance at scale, we design and implement EWProfiler, a tool that can automatically search for embedded Web pages inside apps, trigger page loads, and retrieve performance metrics. Based on 445 embedded Web pages obtained by EWProfiler in 99 popular apps from the two app markets, we investigate the characteristics and performance of embedded Web pages, and find that embedded Web pages significantly impede the app user experience. To optimize the performance of embedded Web browsing, we investigate the effectiveness of three techniques, i.e., separating the browser kernel to a different process, loading pages from local storage, and pre-rendering. We believe that our findings could draw attentions to Web developers, browser vendors, app developers, and mobile OS vendors together towards better performance of embedded Web browsing.

Edge Computing has emerged as a new computing paradigm dedicated for mobile performance enhancement and energy efficiency purposes. Specifically, it benefits today’s interactive applications on power-constrained devices by offloading compute-intensive tasks to the edge nodes in close proximity. Meanwhile, FPGA is well known for its excellence in accelerating (domain-specific) compute-intensive tasks such as deep learning algorithms in a high performance and energy-efficient manner due to its hardware-customizable nature. In this paper, we make the first attempt to leverage and combine the advantages of these two, and proposed a new network-assisted computing model, namely FPGA-based edge computing. As a case study, we choose three computer vision (CV)-based mobile interactive applications, and implement their back-end computation engines on FPGA. By deploying such application-customized accelerator modules for computation offloading at the network edge, we experimentally demonstrate that this approach can effectively reduce response time for the applications and energy consumption for the entire system in comparison with traditional CPU-based edge/cloud offloading approach.

Change impact analysis (CIA) is a specialized process of program comprehension that investigates the ripple effects of a code change in a software system. In this paper, we present a boosting way for change impact analysis via mapping the historical change-patterns to current CIA task in a cross-project scenario. The change-patterns reflect the coupling dependencies between changed entities in a change set. A traditional CIA tool (such as ImpactMiner) outputs an initial impact set for a starting entity. To boost the traditional CIA tool, our approach retrieves an equivalent entity from various historical change sets for the starting entity. Then, the change-patterns between the equivalent entity and the rest of entities in the change set are mapped to the CIA task at hand. For current CIA task, if an entity in the initial impact set involves the similar change-pattern with the starting entity when comparing with the mapped change-pattern, we will reward the impacted confidence of the entity. Accuracy improvements are observed in the experiments when applying our boosting method to three famous CIA tools, i.e., ImpactMiner, JRipples and ROSE.

Open source is an important way for developers to collaborate on software development. More and more developers begin contributing to open-source projects. When a developer begins to contribute to an existing open source project, the first thing to do is to read and understand the project code. However, most current open source projects only provide API documentation, not project design documents for new developers. Developers can only understand the code based on scattered comments in the code, which are difficult for new comers. Therefore, developers need to find a learning path, which helps them understand the project and finish their contribution tasks quickly. In order to help developers find the learning path easily and quickly, this paper puts forward a method to automatically recommend learning paths of open source projects. It uses multiple data sources in an open source community to extract knowledge data and build knowledge graphs for open source projects. After that, based on a deep-learning-based knowledge graph embedding model and a path recommendation algorithm, the method recommends proper learning paths for developers. We select three well-known open source projects, including Lua, Memcached and TensorFlow, according to language, scope and community activity, as cases to verify our method, and do comparative experiments between the learning paths found by real developers and recommended by the method. Experiment results show that our method saves developers a lot of time while ensuring the accuracy of the recommended learning path.

It is widely recognized that patches generated by program repair tools have to be correct to be useful. However, it is fundamentally difficult to ensure the correctness of the patches. Many tools generate only the patches that are highly likely to be correct by taking conservative strategies which inevitably limit the recall of APR approaches. While the recall of APR can potentially be improved by relaxing the requirement on precision, more incorrect patches may also be generated. In this paper, we conjecture that reviewing incorrect patches also helps developers to understand the bug, and with proper tool support, reviewing incorrect patches would at least not reduce the repair performance. To evaluate this, we propose an interactive patch filtering approach to facilitate developers in the patch review process via effectively filtering out groups of incorrect patches. We implemented the approach as an Eclipse plugin, InPaFer, and evaluated the effectiveness and usefulness with a mixed-method evaluation. The results show that our approach improves the repair performance of developers, with 62.5% more successfully repaired bugs and 25.3% less debugging time. In particular, even if all generated patches are incorrect, the performance of developers would not be significantly reduced, and could still be improved. Our work provides a new way of thinking for the APR research.

Software development kits (SDKs) including application programming interfaces (APIs) are always required by developers who need to learn how to use the APIs. However, inexperienced developers may face two problems when learning APIs. Firstly, API-related learning resources cannot be easily obtained. Secondly, inexperienced developers often cannot find proper learning entries and paths to learn APIs, either. To solve these problems, we design an API learning service for inexperienced developers. Firstly, we propose an API link method to find learning resources about APIs in Stack Overflow (SO). Secondly, we construct an API knowledge graph which contains APIs and API-related Q&A threads from SO. Thirdly, by mining how APIs are discussed together in SO, we propose a learning entry recommendation method. At last, we propose an API learning service using the methods above to help inexperienced developers learn APIs. We conduct experiments and results demonstrate the feasibility of our methods and service.

Serverless computing is an emerging paradigm for cloud computing, gaining traction in a wide range of applications such as video processing and machine learning. This new paradigm allows developers to focus on the development of the logic of serverless computing based applications (abbreviated as serverless-based applications) in the granularity of function, thereby freeing developers from tedious and error-prone infrastructure management. Meanwhile, it also introduces new challenges on the design, implementation, and deployment of serverless-based applications, and current serverless computing platforms are far away from satisfactory. However, to the best of our knowledge, these challenges have not been well studied. To fill this knowledge gap, this paper presents the first comprehensive study on understanding the challenges in developing serverless-based applications from the developers’ perspective. We mine and analyze 22,731 relevant questions from Stack Overflow (a popular Q&A website for developers), and show the increasing popularity trend and the high difficulty level of serverless computing for developers. Through manual inspection of 619 sampled questions, we construct a taxonomy of challenges that developers encounter, and report a series of findings and actionable implications. Stakeholders including application developers, researchers, and cloud providers can leverage these findings and implications to better understand and further explore the serverless computing paradigm.

Big data has become valuable property for enterprises and enabled various intelligent applications. Today, it is common to host data in big data platforms (e.g., Spark), where developers can submit scripts to process the original and intermediate data tables. Meanwhile, it is highly desirable to manage the data to comply with various privacy requirements. To enable flexible and automated privacy policy enforcement, we propose TaintStream, a fine-grained taint tracking framework for Spark-like big data platforms. TaintStream works by automatically injecting taint tracking logic into the data processing scripts, and the injected scripts are dynamically translated to maintain a taint tag for each cell during execution. The dynamic translation rules are carefully designed to guarantee non-interference in the original data operation. By defining different semantics of taint tags, TaintStream can enable various data management applications such as access control, data retention, and user data erasure. Our experiments on a self-crafted benchmarksuite show that TaintStream is able to achieve accurate cell-level taint tracking with a precision of 93.0% and less than 15% overhead. We also demonstrate the usefulness of TaintStream through several real-world use cases of privacy policy enforcement.

Summary With the increasing popularity of blockchain technologies in recent years, blockchain‐based decentralized applications (DApps for short in this paper) have been rapidly developed and widely adopted in many areas, being a hot topic in both academia and industry. Despite of the importance of DApps, we still have quite little understanding of DApps along with its ecosystem. To bridge the knowledge gap, this paper presents the first comprehensive empirical study of blockchain‐based DApps to date, based on an extensive dataset of 995 Ethereum DApps and 29,846,075 transaction logs over them. We make a descriptive analysis of the popularity of DApps, summarize the patterns of how DApps use smart contracts to access the underlying blockchain, and explore the worth‐addressing issues of deploying and operating DApps. Based on the findings, we propose some implications for DApp users to select proper DApps, for DApp developers to improve the efficiency of DApps, and for blockchain vendors to enhance the support of DApps.

The past decades witnessed the fast and wide deployment of Internet. The Internet has bred the ubiquitous computing environment that is spanning the cloud, edge, mobile devices, and IoT. Software running over such a ubiquitous computing environment environment is eating the world. A recently emerging trend of Internet-based software systems is “ resource adaptive ,” i.e., software systems should be robust and intelligent enough to the changes of heterogeneous resources, both physical and logical, provided by their running environment. To keep pace of such a trend, we argue that some considerations should be taken into account for the future operating system design and implementation. From the structural perspective, rather than the “monolithic OS” that manages the aggregated resources on the single machine, the OS should be dynamically composed over the distributed resources and flexibly adapt to the resource and environment changes. Meanwhile, the OS should leverage advanced machine/deep learning techniques to derive configurations and policies and automatically learn to tune itself and schedule resources. This article envisions our recent thinking of the new OS abstraction, namely, ServiceOS , for future resource-adaptive intelligent software systems. The idea of ServiceOS is inspired by the delivery model of “ Software-as-a-Service ” that is supported by the Service-Oriented Architecture (SOA). The key principle of ServiceOS is based on resource disaggregation, resource provisioning as a service, and learning-based resource scheduling and allocation. The major goal of this article is not providing an immediately deployable OS. Instead, we aim to summarize the challenges and potentially promising opportunities and try to provide some practical implications for researchers and practitioners.

Conventional road signs convey very concise and static visual information to human drivers, and bear retroreflective coating for better visibility at night. This paper introduces RetroI2V - a novel infrastructure-to-vehicle (I2V) communication and networking system that renovates conventional road signs to convey additional and dynamic information to vehicles while keeping intact their original functionality. In particular, RetroI2V exploits the retroreflective coating of road signs and establishes visible light backscattering communication (VLBC), and further coordinates multiple concurrent VLBC sessions among road signs and approaching vehicles. RetroI2V features a suite of novel VLBC designs including late-polarization, complementary optical signaling and polarization-based differential reception which are crucial to avoid flickering and achieve long VLBC range, as well as a decentralized MAC protocol that make practical multiple access in highly mobile and transient I2V settings. Experimental results from our prototyped system show that RetroI2V supports up to 101 m communication range and efficient multiple access at scale.

Low-cost wireless cameras are growing rapidly. With the help of advanced machine learning models (e.g., CNNs), those videos exhibit high business and social values, e.g., for retailing planning [18], wildlife study [21], and traffic monitoring [19, 25]. However, with high compute need, traditional video analytics systems [14, 15, 26, 27] require all videos to be uploaded to a backend server, which stresses the scarce network bandwidth between cameras and servers.

Elf is a runtime for an energy-constrained camera to continuously summarize video scenes as approximate object counts. Elf's novelty centers on planning the camera's count actions under energy constraint. (1) Elf explores the rich action space spanned by the number of sample image frames and the choice of per-frame object counters; it unifies errors from both sources into one single bounded error. (2) To decide count actions at run time, Elf employs a learning-based planner, jointly optimizing for past and future videos without delaying result materialization. Tested with more than 1,000 hours of videos and under realistic energy constraints, Elf continuously generates object counts within only 11% of the true counts on average. Alongside the counts, Elf presents narrow errors shown to be bounded and up to 3.4X smaller than competitive baselines. At a higher level, Elf makes a case for advancing the geographic frontier of video analytics.

In dynamic, open, and service-oriented computing environments, e.g., e-commerce and crowdsourcing, service consumers must choose one of the services or items to complete their tasks. Due to the scale and dynamic characteristics of these environments, service consumers may have little or no experience with the available services. To this end, reputation systems are proposed and have played a crucial role in the success of online service-oriented transactions. In this paper, we study the current reputation systems used in commercial environments. In these rating-based reputation systems, we found they are not only resilient to the changes (time lag) but also vulnerable to unfair ratings. To address the problems in parallel, we propose an adaptive reputation model (ARM). ARM can dynamically adjust its model parameters to adapt the latest changes in a service. To tackle time lag, the proposed model generalizes the fixed sliding window, used in current commercial platforms, into a dynamic sliding window mechanism. Thus, the model can completely mitigate the influence of obsolete ratings. To detect unfair ratings, our model implements a statistical strategy based on hypothesis testing after transforming the ratings in the linear window into residuals. Experiments not only validate the effectiveness of the proposed model but also show that it outperforms the existing reputation system by 45% on average based on five test cases. The results also show that the proposed model can asymptotically converge to the underlying reputation value as ratings begin to accumulate.Note to Practitioners—The reputation models adopted by current commercial platforms, such as Amazon, eBay, and Taobao, not only suffer heavily from unfair rating but also resilient to the changes in services. To address the problems simultaneously, we design and implement a hybrid model that continuously monitors received ratings and aggregates the reputation value in a self-adaptive way. Our model first fits received fair ratings using the Bayesian linear regression approach and captures the distribution of fair ratings; it then filters out unfair ratings leveraging hypothesis testing. Finally, to sensitively respond the dynamic service changes, the dynamic sliding window algorithm in our model shifts the rating collection window into a new one and discards outdated ratings, reputation value is aggregated in the new window to mitigate the influence of obsolete ratings. Extensive experiments are conducted on widely used scenarios to demonstrate the efficiency and the effectiveness of our proposed model.

With the explosion of “big data” in the past decade, exploring and mining the value hidden in the data has already generated a lot of innovative applications, especially the recent advances of AI applications. The data governance, including activities of data creation, sharing, exchange, management, analytics, tracing, and accounting, has drawn a lot of attentions. Services computing establishes the foundation of current data governance, typically in a centralized fashion, e.g., the cloud-based storage services and analytic services. However, the potential values of big data distributed on the Internet are far away from being adequately explored. Considering the infrastructure revolution made by the blockchain, in this position article, we try to rethink a new data governance fashion that is built upon the blockchain-based decentralized services computing paradigm. The core principle is that data owners are able to publish their data as a set of services that can be deployed independently from the application systems where the data were born. Meanwhile, data owners can define service rules/policies where their data should be stored and how the data can be shared, and keep governing the whole lifecycle record of how their data are actually used. Similar to existing services computing paradigm, data users can search, discover, integrate, and analyze the data in a decentralized fashion. With this perspective, we try to discuss some key insights and enumerate several related new technologies and open challenges, in terms of programmability, interoperability, and intelligence.

Smartphone applications (a.k.a., apps) have become indispensable in our everyday life and work. In practice, accomplishing a task on smartphones may require the user to navigate among various apps. Unlike Web pages that are inherently interconnected through hyperlinks, apps are usually isolated building blocks, and the lack of direct links between apps has compromised the efficiency of task completion and user experience. In this article, we present the first in-depth empirical study of page-level access behaviors of smartphone users based on a comprehensive dataset collected through an extensive user study. We propose a model to distinguish informational pages and transitional pages , based on which we can extract page-level inter-app navigation. Surprisingly, the transitional pages account for quite substantial time cost and manual actions when navigating from the current informational page to the desirable informational page. We reveal that developing “ tunnels ” between “isolated” apps under specific usage scenarios has a huge potential to reduce the cost of navigation. Our analysis provides some practical implications on how to improve app-navigation experience from both the operating system’s perspective and the developer’s<?brk?> perspective.

Exploring and mining the explosive burst of "big data" has already generated a lot of innovative applications, especially the recent advances of AI applications, and thus produced big values to the human society and civilization. However, due to the centralized patterns of data governance activities, including creation, sharing, exchange, management, analytics, tracing, and accounting, the potential values of big data distributed on the Internet are far away from being adequately explored. The recent announcement of data protection policies/laws such as GDPR makes the problem even more challenging. We are now at a moment of truth where the data governance infrastructure should be reconsidered and redesigned. In this paper, we propose a software-defined infrastructure design in a decentralized fashion: data owners are able to implement and deploy their own rules to the application systems where the data are produced for further governance activities. Such a fashion is quite similar to the popular software-defined networking where users are allowed to deploy rules of switches and customize the use. Our principled infrastructure design can radically reform the current data governance activities into a decentralized topology. On the one hand, data can be separated from the application that generates the data, and data owners can have the full rights to decide where their data should be stored and how the data can be shared. On the other hand, data users can search, discover, integrate, and analyze the data from various data sources according to their application requirements and scenarios. As a result, we argue that our infrastructure can establish a new generation of responsive decentralized data governance that can promote the innovation of linking data to better adapt the open environment and diverse user requirements. With this perspective, we briefly discuss some key insights and enumerate several related new technologies and open challenges.

The increasing popularity of cloud storage is leading many organizations to move their data into the cloud. However, putting all data in one cloud causes problems such as vendor lock-in, increased service costs, and data availability. In this paper, we introduce DCStore, a Cloud-of-Clouds storage service designed for an organization to outsource their data into the clouds. To achieve the goal of cost-efficient and high-available, we combine three key techniques. First, DCStore eliminates the redundant data at client-side to save storage cost via application-aware chunking method. Second, DCStore uses an inner-chunk based erasure coding scheme to distribute unique chunks across multiple clouds for high availability. Finally, a container-based share management strategy is used for performance optimization. Our experimental evaluations show that DCStore can improve the performance and cost efficiency significantly, compared with existing Cloud-of-Clouds storage systems.

Bugs are inevitable in software development and maintenance processes. Recently a lot of research efforts have been devoted to automatic program repair, aiming to reduce the efforts of debugging. However, since it is difficult to ensure that the generated patches meet all quality requirements such as correctness, developers still need to review the patch. In addition, current techniques produce only patches without explanation, making it difficult for the developers to understand the patch. Therefore, we believe a more desirable approach should generate not only the patch but also an explanation of the patch. To generate a patch explanation, it is important to first understand how patches were explained. In this paper, we explored how developers explain their patches by manually analyzing 300 merged bug-fixing pull requests from six projects on GitHub. Our contribution is twofold. First, we build a patch explanation model, which summarizes the elements in a patch explanation, and corresponding expressive forms. Second, we conducted a quantitative analysis to understand the distributions of elements, and the correlation between elements and their expressive forms.

Summary In the presence of scale, dynamism, uncertainty, and elasticity, cloud engineers face several challenges when allocating resources for cloud‐based software services. They should allocate appropriate resources in order to guarantee good quality of services as well as low cost of resources. Self‐adaptive ability is needed in this process because engineers' intervention is difficult. Traditional self‐adaptive resource allocation methods are policy‐driven. Thus, cloud engineers usually have to develop separate sets of rules for each systems in order to allocate resources effectively, which leads to high administrative cost and implementation complexity. Machine learning has made great achievements in many fields, and it can be also applied to resource allocation. In this paper, we present a self‐learning and self‐adaptive approach to resource allocation for cloud‐based software services. For a given cloud‐based software service, its QoS model is firstly trained on history data, which is capable to predict the QoS value as output by using the information on workload and allocated resources as inputs. Then, on‐line decision‐making on resource allocation can be carried out automatically based on genetic algorithm, which is aimed to search reasonable resource allocation plan by using the QoS model. We evaluate our approach on RUBiS benchmark, demonstrating the accuracy of the QoS model over 90% and the improvement of resource utilization by 10%‐30%.

Mobile Web applications (a.k.a., Web apps) stand for an important trend for next-generation Internet-based software. Currently popular mobile Web apps need to be adapted to various and ever-changing contexts and personalized user requirements. Based on our over-decade research experiences and practice on the Internetware paradigm, this position article describes an Internetware-oriented approach to designing, developing, and deploying situational mobile Web apps, by synthesizing the resources and services of mobile and cloud. Guided by a novelService-Model-View-Controller(SMVC) software model, a mobile Web app is organized into a well-defined structure that facilitates adaptation including online/offline data access, computation offloading, user interface optimization, hybrid composition, etc. We provide efficient runtime support spanning mobile and cloud to make mobile Web apps more flexibly adaptive. The proof-of-concept evaluation demonstrates that our approach can benefit end-users with optimized user experience of mobile Web apps.

In enterprise organizations, the Bring-Your-Own-Device (BYOD) requirement has become prevalent as employees use their own mobile devices to process the workflow-oriented tasks. Consequently, it calls for approaches that can quickly develop and integrate mobile user interactions into existing business processes, and adapt to various contexts. However, designing, developing, and deploying adaptive and mobile-oriented user interfaces for existing process engines are non-trivial, and require significant systematic efforts. To address this issue, we present a novel middleware-based approach, called MUIT, to developing and deploying the Mobility, User Interactions and Tasks into WS-BPEL engines. MUIT provides a Domain-Specific Language (DSL) that provides some intuitive facilities to support the declarative development of adaptive, mobile-oriented, and Web-based user interfaces in WS-BPEL. The DSL can significantly reduce developers' manual efforts of developing user interactions by preventing arbitrarily mixed code, and its runtime supports satisfactory user experiences. Additionally, MUIT can be seamlessly integrated into WS-BPEL without intrusions of existing process instances. We implement a proof-of-concept prototype by integrating MUIT into the commodity WS-BPEL-based Apusic Platform, and evaluate the performance and usability of MUIT platform.

Test-based automatic program repair has attracted a lot of attention in recent years. However, the test suites in practice are often too weak to guarantee correctness and existing approaches often generate a large number of incorrect patches.

prevalent smartphones have become the major entrance to accessing services on the Internet. On smartphones, users can have two options as the clients, i.e., native apps and Web apps. There have been several debates about native apps and Web apps. However, major service providers such as Google, Amazon, and Facebook provide both native apps and Web apps to end-users. Essentially, the performance differences between these two types of apps haven't been addressed. Indeed, the performance differences make non-trivial impacts on apps development, deployment, and distribution. In this article, we conduct a measurement study on the performance of native apps and Web apps on Android smartphones. Specifically, we want to explore given the same functionalities, do Web apps always perform poorly compared to native apps. We select 328 services from some popular providers, covering various domains such as e-commerce, map, social networking, and entertainment. With HTTP-level trace analysis, we demystify the workflows on how native apps and Web apps deliver services on mobile devices, respectively. Then, we characterize the performance differences between native apps and Web apps with the metrics including the number of requests, response time, data drain, and energy consumption. We find that the performance of Web apps is better than native apps in more than 31 percent cases. Our derived knowledge can suggest some recommendations to improve the performance for mobile apps.

Web browsing is always a key requirement of Internet users. Current mobile Web apps can contain computation-intensive JavaScript logics and thus affect browsing performance. Learning from our over-decade research and development experiences of the Internetware paradigm, we present the novel and generic i - Jacob approach to improving the performance of mobile Web browsing with effective JavaScript-code offloading. Our approach proposes a programming abstraction to make mobile Web situational and adaptive to contexts, by specifying the computation-intensive and “ offloadable ” code, and develops a platform-independent lightweight runtime spanning the mobile devices and the cloud. We demonstrate the efficiency of i - Jacob with some typical computation-intensive tasks over various combinations of hardware, operating systems, browsers, and network connections. The improvements can reach up to 49× speed-up in response time and 90% saving in energy.

Collaborative work supported by mobile applications has become more and more popular. Mobile collaboration in some cases needs to be conducted in an interactive way to allow the sharing of the requester screen with the collaborator. Existing interactive screen sharing techniques, however, may cause heavy network traffic and high latency and lack fine-grained control of the scope of collaboration. In this paper, we propose CollaDroid, a lightweight and UI Description based technique for interactive collaboration of Android applications. CollaDroid can automatically transform an Android application to a collaboration augmented application with which a requester can interactively collaborate with a remote collaborator by synchronizing UI (User Interface) content and events. The results of our experimental study show that CollaDroid is applicable for a large part of applications in the Android Market and can provide an efficient collaboration mechanism with low network traffic and latency. And the results of our user study show that the collaboration mechanism implemented by CollaDroid is well accepted by users.

Due to the difficulty of repairing defect, many research efforts have been devoted into automatic defect repair. Given a buggy program that fails some test cases, a typical automatic repair technique tries to modify the program to make all tests pass. However, since the test suites in real world projects are usually insufficient, aiming at passing the test suites often leads to incorrect patches. This problem is known as weak test suites or overfitting. In this paper we aim to produce precise patches, that is, any patch we produce has a relatively high probability to be correct. More concretely, we focus on condition synthesis, which was shown to be able to repair more than half of the defects in existing approaches. Our key insight is threefold. First, it is important to know what variables in a local context should be used in an "if" condition, and we propose a sorting method based on the dependency relations between variables. Second, we observe that the API document can be used to guide the repair process, and propose document analysis technique to further filter the variables. Third, it is important to know what predicates should be performed on the set of variables, and we propose to mine a set of frequently used predicates in similar contexts from existing projects. Based on the insight, we develop a novel program repair system, ACS, that could generate precise conditions at faulty locations. Furthermore, given the generated conditions are very precise, we can perform a repair operation that is previously deemed to be too overfitting: directly returning the test oracle to repair the defect. Using our approach, we successfully repaired 18 defects on four projects of Defects4J, which is the largest number of fully automatically repaired defects reported on the dataset so far. More importantly, the precision of our approach in the evaluation is 78.3%, which is significantly higher than previous approaches, which are usually less than 40%.

The prevalence of mobile platforms, especially the large market share of Android, has promoted the popularity of mobile applications (a.k.a. apps). In developing the apps, logging acts as a crucial tool to help developers debug their app before publishing. In this paper, we present an empirical study on how logging is used in current popular Android apps and reveal the security risks of deactivating the log call instead of removing the call and its associated instructions. To this end, we propose a static analysis scheme to remove the logging call as well as those associated instructions that construct the parameters for the call. We then implement the scheme as a tool called LogPruner and evaluate it with a set of 10 top apps collected from Google Play and Wandoujia. The results show that LogPruner can outperform the naive logging removal approach by 11.8% to 512.5% on pruned instructions in the collected apps.

The internet of things (IoT) attracts great interest in many application domains concerned with monitoring and control of physical phenomena. IoT applications try to provide more and more functionality and then they inevitably become so complex as to make the limits of devices worse, which may lead to poor performance of applications. Computation offloading is a promising way to improve the performance of an IoT application by executing some parts of the application on remote devices or servers. However, supporting such capability is not easy for application developers due to (1) adaptability: IoT applications often face changes of runtime environments so that the adaptation on offloading is needed. (2) effectiveness: when the device context changes, it needs to dynamically decide the deployment plan of computation tasks, and the reduced execution time must be greater than the network delay and extra overheads caused by offloading. This paper proposes a framework which supports IoT applications with adaptive computation offloading capability. First, a design pattern is proposed to enable an application to be computation offloaded on-demand. Second, an estimation model is presented to automatically decide the deployment plan for offloading. Third, a framework is implemented to support the design pattern and the estimation model. A thorough evaluation on the real-world application is proposed, and the results show that our approach can help reduce execution time by over 45% in most scenarios.

With the rapid development of wearable devices such as smartwatches, we are brought to a new era of wearable computing. Due to limited computational capability, storage, and battery capacity, wearable devices can hardly execute computation-intensive tasks. The mainstream approach to overcoming these limitations is computation offloading, i.e., offloading the tasks to mobile devices or the remote cloud servers. However, computation offloading cannot improve performance or save power consumption under all conditions. For example, offloading may not be worth in the case of very poor network conditions. To address the issue, in this paper, we propose AgileRabbit, a feedback-driven middleware of computation offloading for smartwatch apps. We design an offloading decision algorithm using the feedback data with a given objective i.e., minimizing the task completion time, or minimizing the total power consumption of smartwatches and mobile devices. With the assistance of AgileRabbit, computation-intensive tasks in smartwatch apps can be well scheduled and assigned to the proper computation node. We implement a speech recognition application on Android Wear platform and deploy it on AgileRabbit to validate the effectiveness of our approach. Evaluation results show that AgileRabbit can significantly improve the performance and save power consumption while incurring small overheads.

Numerous complains have been made by Android users who severely suffer from the sluggish response when interacting with their devices. However, very few studies have been conducted to understand the user-perceived latency or mitigate the UI-lagging problem. In this paper, we conduct the first systematic measurement study to quantify the user-perceived latency using typical interaction-intensive Android apps in running with and without background workloads. We reveal the insufficiency of Android system in ensuring the performance of foreground apps and therefore design a new system to address the insufficiency accordingly. We develop a lightweight tracker to accurately identify all delay-critical threads that contribute to the slow response of user interactions. We then build a resource manager that can efficiently schedule various system resources including CPU, I/O, and GPU, for optimizing the performance of these threads. We implement the proposed system on commercial smartphones and conduct comprehensive experiments to evaluate our implementation. Evaluation results show that our system is able to significantly reduce the user-perceived latency of foreground apps in running with aggressive background workloads, up to 10x, while incurring negligible system overhead of less than 3.1 percent CPU and 7 MB memory.

Redundant transfer of resources is a critical issue for compromising the performance of mobile Web applications (a.k.a., apps) in terms of data traffic, load time, and even energy consumption. Evidence demonstrates that the current cache mechanisms are far from satisfactory. With lessons learned from how native apps manage their resources, in this article, we present the ReWAP approach to fundamentally reducing redundant transfers by restructuring the resource loading of mobile Web apps. ReWAP is based on an efficient resource-packaging mechanism where stable resources are encapsulated and maintained into a package, and such a package shall be loaded always from the local storage and updated by explicitly refreshing. By retrieving and analyzing the update of resources, ReWAP maintains resource packages that can accurately identify which resources can be loaded from the local storage for a considerably long period. ReWAP also provides a wrapper for mobile Web apps to enable loading and updating resource packages in the local storage as well as loading resources from resource packages. ReWAP can be easily and seamlessly deployed into existing mobile Web architectures with minimal modifications, and is transparent to end-users. We evaluate ReWAP based on continuous 15day access traces of 50 mobile Web apps randomly chosen from Alexa top 500 ranking list. Compared to the original mobile Web apps with cache enabled, ReWAP can significantly reduce the data traffic, with the median saving up to 51 percent. In addition, ReWAP can incur only very minor runtime overhead of the client-side browsers and thus does not compromise user experiences.

Imperfect Web resource loading prevents mobile Web browsing from providing satisfactory user experience. In this article, we design and implement the SWAROVsky system to address three main issues of current inefficient Web resource loading: (1) on-demand and thus slow loading of sub-resources of webpages; (2) duplicated loading of resources with different URLs but the same content; and (3) redundant loading of the same resource due to improper cache configurations. SWAROVsky employs a dual-proxy architecture that comprises a remote cloud-side proxy and a local proxy on mobile devices. The remote proxy proactively loads webpages from their original Web servers and maintains a resource loading graph for every single webpage. Based on the graph, the remote proxy is capable of deciding which resources are “really” needed for the webpage and their loading orders, and thus can synchronize these needed resources with the local proxy of a client efficiently and timely. The local proxy also runs an intelligent and light-weight algorithm to identify resources with different URLs but the same content, and thus can avoid duplicated downloading of the same content via network. Our system can be used with existing Web browsers and Web servers, and does not break the normal semantics of a webpage. Evaluations with 50 websites show that on average our system can reduce the page load time by 43.1 percent and the network data transmission by 57.6 percent, while imposing marginal system overhead.

App marketplaces host millions of mobile apps that are downloaded billions of times. Investigating how people manage mobile apps in their everyday lives creates a unique opportunity to understand the behavior and preferences of mobile device users, infer the quality of apps, and improve user experience. Existing literature provides very limited knowledge about app management activities, due to the lack of app usage data at scale. This article takes the initiative to analyze a very large app management log collected through a leading Android app marketplace. The dataset covers 5 months of detailed downloading, updating, and uninstallation activities, which involve 17 million anonymized users and 1 million apps. We present a surprising finding that the metrics commonly used to rank apps in app stores do not truly reflect the users’ real attitudes. We then identify behavioral patterns from the app management activities that more accurately indicate user preferences of an app even when no explicit rating is available. A systematic statistical analysis is designed to evaluate machine learning models that are trained to predict user preferences using these behavioral patterns, which features an inverse probability weighting method to correct the selection biases in the training process.

Emojis have been widely used to simplify emotional expression and enrich user experience. As an interesting practice of ubiquitous computing, emojis are adopted by Internet users from many different countries, on many devices (particularly popular on smartphones), and in many applications. The "ubiquitous" usage of emojis enables us to study and compare user behaviors and preferences across countries and cultures. We present an analysis on how smartphone users use emojis based on a very large data set collected from a popular emoji keyboard. The data set contains a complete month of emoji usage of 3.88 million active users from 212 countries and regions. We demonstrate that the categories and frequencies of emojis used by these users provide rich signals for the identification and the understanding of cultural differences of smartphone users. Users from different countries present significantly different preferences on emojis, which complies with the well-known Hofstede's cultural dimensions model.

Selecting and prioritizing major device models are critical for mobile app developers to select testbeds and optimize resources such as marketing and quality-assurance resources. The heavily fragmented distribution of Android devices makes it challenging to select a few major device models out of thousands of models available on the market. Currently app developers usually rely on some reported or estimated general market share of device models. However, these estimates can be quite inaccurate, and more problematically, can be irrelevant to the particular app under consideration. To address this issue, we propose PRADA, the first approach to prioritizing Android device models for individual apps, based on mining large-scale usage data. PRADA adapts the concept of operational profiling (popularly used in software reliability engineering) for mobile apps -- the usage of an app on a specific device model reflects the importance of that device model for the app. PRADA includes a collaborative filtering technique to predict the usage of an app on different device models, even if the app is entirely new (without its actual usage in the market yet), based on the usage data of a large collection of apps. We empirically demonstrate the effectiveness of PRADA over two popular app categories, i.e., Game and Media, covering over 3.86 million users and 14,000 device models collected through a leading Android management app in China.

Cloud computing has emerged as a new paradigm for services delivering over the Internet. In this growing market, PaaS (Platform-as-a-Service) cloud has been an important model allowing a simple and flexible deployment of applications, without the need for dedicated networks, servers, storage and other services. Many PaaS services have been provided in the past few years and it is required to use hybrid PaaS services in order to satisfy management requirements such as legacy system integration and dynamic resource scaling. However, there are various management interfaces and different management mechanisms among PaaS clouds, which cause great difficulty and high complexity to application deployment in a hybrid cloud. In this paper, we present a runtime model based approach to using hybrid PaaS services. First, the manageability of PaaS services is abstracted as runtime models that are automatically connected with the corresponding systems. Second, we provide a unified model of PaaS services, according to the domain knowledge of current PaaS clouds. Third, the synchronization between the unified model and runtime models is ensured through model transformation. Thus, administrators are able to use hybrid PaaS services in a unified manner and management logic can be also carried out by executing programs on the unified model, which decreases the difficulty and complexity of hybrid cloud management.

Approaches to making cloud operation more efficient, for example through scheduling and power management, largely assume that the workload offered from mobile, user-facing applications is a given and that the cloud must simply adapt to it. We flip this assumption 180 degrees and ask to what extent can we instead shape the user-centric workload into a form that would benefit such approaches. Using a toolchain hat allows us to interpose on frontend/backend interactions in popular Android applications, we add the ability to introduce delays and collect information about user satisfaction. We conduct an "in the wild" user study using this capability, and report on its results. Delays of up to 750 ms can be introduced with little effect on most users, although this is very much user and application dependent. Finally, given our study results, we consider reshaping the application requests by selective delays to have exponential interarrival times (Poisson arrivals), and find that we are often able to do so without exceeding the user's delay tolerance.

The accuracy of the floating-point calculation is critical to many applications and different methods have been proposed around floating-point accuracies, such as detecting the errors in the program, verifying the accuracy of the program, and optimizing the program to produce more accurate results. These approaches need a specification of the program to understand the ideal calculation performed by the program, which is usually approached by interpreting the program in a precision-unspecific way.

Smartphone users have adopted an explosive number of mobile applications (a.k.a., apps) in the recent years. App marketplaces for iOS, Android and Windows Phone platforms host millions of apps which have been downloaded for more than 100 billion times. Investigating how people manage mobile apps in their everyday lives creates a unique opportunity to understand the behavior and preferences of mobile users, to infer the quality of apps, and to improve the user experience. Existing literature provides very limited knowledge about app management activities, due to the lack of user behavioral data at scale. This paper takes the initiative to analyze a very large app management log collected through a leading Android app marketplace. The data set covers five months of detailed downloading, updating, and uninstallation activities, involving 17 million anonymized users and one million apps. We present a surprising finding that the metrics commonly used by app stores to rank apps do not truly reflect the users' real attitudes towards the apps. We then identify useful patterns from the app management activities that much more accurately predict the user preferences of an app even when no user rating is available.

The web browser is one of the most significant applications on mobile devices such as smartphones. However, the user experience of mobile web browsing is undesirable because of the slow resource loading. To improve the performance of web resource loading, client-side cache has been adopted as a key mechanism. However, the existing passive measurement studies cannot comprehensively characterize the “client-side” cache performance of mobile web browsing. For example, most of these studies mainly focus on client-side implementations but not server-side configurations, suffer from biased user behaviors, and fail to study “miscached” resources. To address these issues, in this article, we present a proactive approach to making a comprehensive measurement study on client-side cache performance. The key idea of our approach is to proactively crawl resources from hundreds of websites periodically with a fine-grained time interval. Thus, we are able to uncover the resource update history and cache configurations at the server side, and analyze the cache performance in various time granularities. Based on our collected data, we build a new cache analysis model and study the upper bound of how high percentage of resources could potentially be cached and how effectively the caching works in practice. We report detailed analysis results of different websites and various types of web resources, and identify the problems caused by unsatisfactory cache performance. In particular, we identify two major problems - Redundant Transfer and Miscached Resource, which lead to unsatisfactory cache performance. We investigate three main root causes: Same Content, Heuristic Expiration, and Conservative Expiration Time, and discuss what mobile web developers can do to mitigate those problems.

The burst of Web-based Restful services brings us a number of facilities in our life and work. We are used to take smartphones to access these Web services, like location-based services, weather search, mapping, social networking, et al. On smartphones, we have two options of service consumers, a.k.a, Native apps and Web apps. Despite the platform-independence, Web apps are claimed to provide the same features and comparable user experiences with native apps. However, one fact is that more and more people prefer native apps rather than Web apps. In this paper, we make an empirical study on characterizing the performance disparity of native apps and Web apps. Given the same functionalities provided by the same service providers, we explore the Restful Web services that are used by native apps and Web apps. With HTTP-level trace analysis, we demystify the workflows on how native apps and Web apps use Web services and summarize different service usage patterns from architectural style perspective. Then we characterize the performance differences between native apps and Web apps on realizing Restful Web services including GET, DELETE, PUT & POST, in terms of number of network connections, response time, and data drain, given the same functional features. Our observations reveal that Web apps do not always perform worse than native apps using Restful Web services under the same context. We further propose some implications to improve both native apps and Web apps on smartphones.

Mobile devices with 3G/4G networking often waste energy in the so-called "tail time" during which the radio is kept on even though no communication is occurring. Prior work has proposed policies to reduce this energy waste by batching network requests. However, this work is challenging to apply in practice due to a lack of mechanisms. In response, we have developed DelayDroid, a framework that allows a developer to add the needed policy to existing, unmodified Android applications (apps) with no human effort. This allows such prior work (as well as our own policies) to be readily deployed and evaluated. The DelayDroid compile-time uses static analysis and bytecode refactoring to identify method calls that send network requests and modify such calls to detour them to the DelayDroid run-time. The run-time then applies a policy to batch them, avoiding the tail time energy waste. DelayDroid also includes a cross-app communication mechanism that supports policies that optimize across multiple apps running together, and we propose a policy that does so. We evaluated the correctness and universality of the DelayDroid mechanisms on 14 popular Android apps chosen from the Google App Store. To evaluate our proposed policy, we studied three DelayDroid-enabled apps (weather forecasting, email client, and news client) running together, finding that the DelayDroid mechanisms combined with our policy can reduce 3G/4G tail time energy waste by 36%.

Service computing promotes a large number of web-delivered services, including web services, APIs and data feeds. Composing data, functionalities and even UI from these web-delivered services into a single web application, usually called service mashup, becomes a popular web development paradigm. The web-delivered services can be modeled as mashup components, while the development of mashup actually yields a set of inter-connected mashup components. The growing popularity of mashup components enriches functionality and user experiences, while the possible connections among components are complex and difficult to mashup developers, who might be non-professional programmers or even end-users, as actions over one component may have potential impacts on another. This paper proposes a novel approach for recommending developers in terms of navigation and completion of mashup components with a large-scale components repository. From data-driven perspective, we model the relationships between mashup components by a generic layered-graph model. Developers are allowed to select some initial components as starting point, while a graph-based algorithm recommends how to navigate to potentially relevant mashup components and complete the relevant mashup application. We experimentally demonstrate the efficiency and effectiveness of our approach for rapid mashup construction.

The convergence of Services Computing and Web 2.0 gains a large space of opportunities to compose “situational” web applications from web-delivered services. However, the large number of services and the complexity of composition constraints make manual composition difficult to application developers, who might be non-professional programmers or even end-users. This paper presents a systematic data-driven approach to assisting situational application development. We first propose a technique to extract useful information from multiple sources to abstract service capabilities with a set tags. This supports intuitive expression of user's desired composition goals by simple queries, without having to know underlying technical details. A planning technique then exploits composition solutions which can constitute the desired goals, even with some potential new interesting composition opportunities. A browser-based tool facilitates visual and iterative refinement of composition solutions, to finally come up with the satisfying outputs. A series of experiments demonstrate the efficiency and effectiveness of our approach.

Online education plays a more and more important role in the era of Internet and cloud computing, but two problems remain unsolved including MOOCs. First, most of existing online education platforms only provide teaching materials in format of ppt, pdf, video, and they seldom support education based on graphical Web applications. Second, some online education platforms may provide self-governed chatting tools or whiteboards, but they are not combined with teaching materials closely. As a result, they cannot satisfy the need for the real-time interactions based on complex teaching materials. To solve the problems above, we put forward an online education approach using Web operation record and replay techniques, and implement online synchronized education and real-time interactions between teachers and students. Moreover, we develop a supporting tool OSEP for the approach. In the case study, we describe three education scenarios, which verify that the approach supports not only personal learning by tutorials and wizards, but also online in-class real-time collaborative learning.

Fault tolerance (FT) is one of the most important ways to achieve high availability (HA). However, as for cloud, with diverse user requirements, heterogeneous cloud providers, complex FT implementation as well as error-prone configuration, it is a real challenge. To cope with it, we proposed a model defined FT approach which automatically deploys FT mechanisms following a high-level model. With the help of FT model, the existing FT mechanisms will be optimized by reusability. We implemented a prototype of our approach and evaluated it on a popular IaaS cloud - CloudStack.

With the rapid development of Cloud computing technologies, a large number of Cloud management systems have emerged in recent years, such as Amazon EC2, Eucalyptus, CloudStack and OpenStack. To the best of our knowledge, all of these systems treat virtual machines (VMs) independent with each other and ignore the relationships between them. However, the relationship information between VMs can greatly impact the resource utilization, application performance and so on. Therefore, in this paper, we present SmartRelationship – a relationship detection framework for Cloud management. The framework detects the relationship between VMs in Cloud, which can be used to optimize Cloud management services such as VM dynamic placement, fault detection and security inspection.

Managing computation resources in a cost-effective way has become the core competence for a Cloud provider to win over the market because of the "pay-as-you-go" business model. Therefore, VM placement has become more and more important in the research and practices of VM management by determining at what condition and on which physical server a VM should be placed so that the SLA can be guaranteed and servers' utilization can be improved. Much existing work simply formulates the above issue to be a bin-packing problem, which does not take the VM relationships into account. However, the relationship information can greatly impact the SLA of the Cloud system and the resource utilization. Therefore, in this paper, we propose a relationship-based VM placement framework, SmartCRS, to optimize the VM placement procedure. SmartCRS reveals the relationships between VMs automatically. Then by using such information and based on a constraint library, it gives a proper VM placement plan. Finally, the plan is carried out by SmartCRS automatically or by Cloud administrators manually to improve the server utilization and guarantee the required SLA. Two case studies are conducted to demonstrate the effectiveness and efficiency of the proposed framework at the end of this paper.

Although there are many management systems, Cloud management still faces with great challenges, due to the diversity of Cloud resources and ever-changing management requirements. Integration and adaptation become important for constructing a cloud management system, because a redevelopment solution based on existing systems is usually more practicable than developing the management system from scratch. However, the workload of redevelopment is also very high. As the runtime model is causally connected with the corresponding running system automatically, constructing an integrated Cloud management system based on runtime models can benefit from the model-specific natures to reduce the development workload. Therefore, in this paper, we present a runtime model based approach to constructing cloud management system. First, we construct the runtime model of each Cloud resource based on its own management interfaces. Second, we construct a composite model reflecting integration management requirements through merging the distributed runtime models. Third, we make Cloud management meet the adaptation requirements through model transformation from the composite model to the customized models specific to different administrators. Such architecture-level integrated management brings many advantages related to the interoperability, reusability and simplicity. The experiment on a real-world cloud demonstrates the feasibility, effectiveness and benefits of the new approach to integrated management of Cloud resources.

Benefitting from advanced web technologies like JavaScript, CSS3 and HTML5, current web applications can provide ever richer functionalities and user experiences, on both PC and mobile devices like tablet computers and smartphones. Furthermore, they can perform complex computations which are usually resource-intensive and consuming, e.g., data analytic application and augmented reality games. Mobile devices might suffer from their limited computing capabilities and resources. As mobile devices now are gaining access through excellent connectivity with much more powerful cloud-side services, and offloading can be a potential solution. This paper presents the design and implementation of the AppMobiCloud system for improving mobile web applications by leveraging the mobile-cloud convergence. At development time, AppMobiCloud employs a combination of profiling and points-to analysis. This facilitates application developers to find the computation-intensive code fragments, and specifies whether they can be offloaded with some constraints. At runtime, AppMobiCloud migrates the chosen JavaScript code fragments from the mobile devices for remote execution. It synchronizes client-side application runtime context and constructs the "cloned" context at server, executing the codes there and re-integrating the result back to the mobile device. We evaluate our approach on three well-known JavaScript benchmarks, Dromaeo, V8 and Kraken, and a typical computation-intensive AI game. The evaluation demonstrates that our work can reduce JavaScript application's execution time and energy consumption respectively on mobile devices up to 98% and 83%.

Many programs access external data sources through generic APIs. The class hierarchy of such a generic API does not reflect the schema of any particular data source, and thus it is hard to clarify what data an API client accesses and how it obtains them. This makes it difficult to maintain the API clients. In this paper, we show that the data access of an API client can be recovered through static analysis on the client's source code. We provide a formal and intuitive way to represent the data access, as a graph of so-called summoning snippets. Each snippet stands for a type of data accessed by the client, and carries the code slice from the client about how to obtain the data via the API. We provide an automated approach to inferring a complete and well-simplified set of summoning snippets from the client source code, based on points-to analysis and code slicing. We implement this approach as a development assistant tool, and evaluate it on eight open source data processing programs, with average precision and recall of 89% and 95%, respectively. Further inspection of these clients, as well as a user study about writing data accessing code on their data sources, show that the inference results are useful in the inspection of existing clients and the development of new data access logics.

With the increasing complexity of enterprise applications, it becomes very challenging to create software systems which can exhibit a satisfactory performance behavior. In current system development practice, it often inevitably exists some "anti-patterns", which usually impede the performance or maintainability of software systems. Manually investigating anti-patterns in systems is a time-consuming and labor intensive task. To deal with this problem, we propose a general anti-pattern detection approach for Java EE application. Firstly, we propose a Java EE meta-model, based on which, we use QVT language to specify the detection process of anti-patterns. Secondly, we implement our approach on a runtime architecture-based reflective framework. When a Java EE application runs on one of the supported application servers, we can execute QVT script to detect whether or not there exists a specific anti-pattern in current system and get the report of potential problem components. At last, we perform a case study based on 35 well-known anti-patterns to evaluate the effectiveness and applicability of our approach.

Computation offloading is a promising way to improve the performance as well as reducing the battery power consumption of a smartphone application by executing some parts of the application on a remote server. Supporting such capability is not easy for smartphone application developers due to (1) correctness: some code, e.g., that for GPS, gravity, and other sensors, can run only on the smartphone so that developers have to identify which parts of the application cannot be offloaded; (2) effectiveness: the reduced execution time must be greater than the network delay caused by computation offloading so that developers need to calculate which parts are worth offloading; (3) adaptability: smartphone applications often face changes of user requirements and runtime environments so that developers need to implement the adaptation on offloading. More importantly, considering the large number of today's smartphone applications, solutions applicable for legacy applications will be much more valuable. In this paper, we present a tool, named DPartner, that automatically refactors Android applications to be the ones with computation offloading capability. For a given Android application, DPartner first analyzes its bytecode for discovering the parts worth offloading, then rewrites the bytecode to implement a special program structure supporting on-demand offloading, and finally generates two artifacts to be deployed onto an Android phone and the server, respectively. We evaluated DPartner on three real-world Android applications, demonstrating the reduction of execution time by 46%-97% and battery power consumption by 27%-83%.

In a cloud platform belonging to the PaaS (Platform as a Service) category, autonomic middleware have become the fundamental part of a cloud node. An autonomic middleware can perform adaptive computations for self-management of the system. However, these adaptive computations consume resources such as CPU and memory, and can interfere with each other and also with normal business functions of the system due to resource competition, especially when the system is under heavy load. As a result, the adaptive computations should be tuned from the perspective of resource management. In this position paper, we propose an approach to tuning the autonomic levels and thus controlling the resource costs of the adaptive computations in an autonomic middleware of PaaS cloud, so as to guarantee the system's performance when resources are competed.

Spurred by Web 2.0 paradigm, there emerge large numbers of service mashups by composing readily accessible data and services. Mashups usually address solving situational problems and require quick and iterative development lifecyle. In this paper, we propose an approach to composing data driven mashups, based on tag-based semantics. The core principle is deriving semantic annotations from popular tags, and associating them with programmatic inputs and outputs data. Tag-based semantics promise a quick and simple comprehension of data capabilities. Mashup developers including end-users can intuitively search desired services with tags, and combine several services by means of data flows. Our approach takes a planning technique to retrieving the potentially relevant composition opportunities. With our graphical composition user interfaces, developers can iteratively modify, adjust and refine their mashups to be more satisfying.

Infrastructure resources on-demand requires resource provision (e.g., CPU and memory) to be both sufficient and necessary, which is the most important issue and a challenge in Cloud Computing. Platform as a service (PaaS) encapsulates a layer of software that includes middleware, and even development environment, and provides them as a service for building and deploying cloud applications. In PaaS, the issue of on-demand infrastructure resource management becomes more challenging due to the thousands of cloud applications that share and compete for resources simultaneously. The fundamental solution is to integrate and coordinate the resource consumption and allocation management of a cloud application. The difficulties of such a solution in PaaS are essentially how to maximize the resource utilization of an application, and how to allocate resources to guarantee adequate resource provision for the system. In this paper, we propose an approach to managing infrastructure resources in PaaS by leveraging two adaptive control loops: the resource consumption optimization loop and the resource allocation loop. The optimization loop improves the resource utilization of a cloud application via management functions provided by the corresponding middleware layers of PaaS. The allocation loop provides or reclaims appropriate amounts of resources to/from the application system while guaranteeing its performance. The two loops are integrated to run consecutively and repeatedly to provide infrastructure resources on-demand by first trying to improve resource utilization, and then allocating more resources when necessary. We implement a framework, SmartRod, to investigate our approach. The experiment on SmartRod proves its effectiveness on infrastructure resource management.

The way to document architecture is called Architecture Description (AD). It contains all the key design decisions, presents how the system is composed, specifies the interface of the component, and etc. Such information is needed not only during the whole development but also in the system maintenance or evolvement phase. Meanwhile, the amount of the various ADs in a modern software system becomes very large and the content of ADs is also richer. To understand the system ADs becomes challenging to the engineers. However, past research in the software engineering area did not pay enough attention to assisting the engineers to understand the ADs. On the other hand, according to the document navigation research in Human Computer Interaction (HCI), the engineer's intention should be adequately presented. To address these issues, we proposed a Task-oriented Navigation Approach and developed a tool support. By specifying tasks that express the purpose of the engineer, our approach generates the organized information, trims the irrelevant descriptions, and guides the navigation sequentially. Our approach provides several major benefits. First, it offers an approach to capture the purpose of the engineer. Second, it reminds the engineer about the possible omission during the reading. Last, it improves the understandability of the AD and reduces the workload of the engineer.

Runtime models represent the dynamic data of running systems, and enable developers to manipulate the data in an abstract, model-based way. This paper presents [email protected], a tool that help realize runtime models on a wide class of systems. Receiving a meta-model specifying the target system's data type and an API description specifying how to manipulate the data, [email protected] automatically generates the synchronizer to maintain the runtime model for this system.

Services computing paradigm together with Web services have significantly promoted the automation of business process in enterprise. Prevalent service composition technologies, such as WS-BPEL and WSCI, provide promising means to deal with machine-to-machine communication. Traditionally, in the phase of business process modeling, there usually require some human-involved tasks. Recent new technologies such as BPEL4People and Human Task begin to consider involving human interaction in business process. However, such approaches still have some limitations. On one hand, they exactly require some extensions of current BPEL standards. As a result, the existing business processes have to be rewritten and redeployed. On the other hand, they yet lack of the development and deployment supports of flexible and reusable user interfaces in business process. In this paper, we address these issues by enabling human interaction in business process with rich web applications. Our approach models human tasks as services, and can be seamlessly integrated to current BPEL without any modifications to existing engine and processes. We further support building human task presentations from service-oriented rich user interfaces. During the process execution, the corresponding task stakeholders can select, configure and compose these reusable and rich UI components according to their own application context.

With the increasing maturity of model-driven tools and methods, new model-based analysis methods are developed to support specific stakeholder concerns during software lifecycle. This multiplication of models and their related analysis tools calls for solution addressing the integration of MOF-based analysis methods. Current research works on integration of analysis methods have already addressed the extraction of the needed input data as well as the control and the integration of the tools supporting the analysis execution. However, little attention has been paid to the integration of analysis results back into initial model. We propose a MOF-based framework enabling the integration of analysis results that a) defines a meta-model capturing the integration requirements, b) provides a MOF meta-model extension mechanism with support for upward compatibility; and c) automatically generates a model transformation for model integration. We illustrate the use of our framework by integrating a reliability analysis methods and a fault tolerant reconfiguration method on the ABC/ADL Software Architecture. We applied the resulting analysis composition onto the ECPerf JEE system.

The Web is currently moving towards a platform with rich services. A notable trend is that end-users create mashups composing services with short, iterative development life cycles as well as updating with evolving needs. However, the large number of services and the high complexity of composition constraints make manual composition extremely difficult. Addressing this issue, we have developed an approach to assisting the end-users to build mashups in a simple and fast fashion. A tag-based model provides end-users a quick and intuitive insight of services. End-users simply describe their desired goals with tags. Interacting with a service repository, our approach employs a planning approach to suggest services that end-users might want to involve in the final outputs, including some additional interesting or relevant ones to induce more potential composition opportunities. End-users are allowed to iteratively modify, adjust or refine their goals. We have implemented our approach with a tool called iMashup.

Along with the proliferation of web-delivered services and the wide adoption of popular Web technologies, it has been an emerging development style that composes service-oriented applications with rich user experiences in the web browser. Currently, these service-oriented rich client (SoRC) applications are usually tightly coupled with specific requirements and scenarios, without the solutions of common problems for development, deployment and operation. It leads to the fact that SoRC applications are exactly done in an ad-hoc manner. In this paper, we propose a new type of middleware, which is embedded in web browsers and encapsulates reusable solutions for common problems. This browser-embedded middleware consists of a container managing component instances, a set of communication mechanisms coordinating both browser-server and inter-browser interactions. Different SoRC applications can be constructed more easily based on the middleware. In the case study, we construct a mashup environment, called iMashup, with the middleware and compare it with some popular environments. The comparison shows that iMashup provides composition capabilities with less implementation efforts, occupies much lower memory consumption and achieves more scalability.

Access control requirements (ACRs) are software requirements about limiting privileges of users from accessing sensitive software resources. ACRs often interact with functional requirements (FRs), conform to an access control model, are constrained by authorization constraints of organizations, and change frequently. Current requirements modeling technologies, such as use case modeling approaches, object-oriented analysis, and feature-oriented approaches, are initially designed to model FRs, and cannot explicitly and efficiently model the ACRs. In real world, it is still very difficult for the developers to model and evolve the complex and changeful ACRs of large-scale software applications while ensuring the consistency between ACRs and FRs. This paper analyzes the challenges of modeling ACRs, presents a feature-based approach to modeling the ACRs to overcome them, and illustrates the approach in an online store application.

Interactive tutorials, like Eclipse's cheat sheets, are good for novice programmers to learn how to perform tasks (e.g., checking out a CVS project) in an integrated development environment (IDE). Creating these tutorials often requires programming effort that is time-consuming and difficult. In this paper, we propose an approach using editable replay of user actions to help authors create interactive tutorials with little programming effort. User actions of performing a task can be recorded, edited, and presented as a tutorial. The tutorial can be replayed interactively for mentoring. We present our SmartTutor implementation in the Eclipse IDE and conduct a preliminary evaluation on it, which demonstrates efficiency gains for the tutorial authors.

Architecture-based runtime management (ARM) is a promising approach for Internetware systems. The key enablement of ARM is runtime architecture infrastructure (RAI) that maintains the causal connection between runtime systems and architectural models. An RAI is uneasy to implement and, more importantly, specific to the given system and model. In this paper, we propose a model-driven approach for automated generation of RAI implementation. Developers only need to define three MOF models for their preferred architecture model and the target system (these models are reusable independently for different pairs of the model and system), and one QVT transformation for the causal connection. Our Eclipse-based toolset, called [email protected], will automatically generate the RAI implementation code without any modification on the source code of the target system. This approach is experimented on several runtime systems and architectural models, including ABC architectural models on Eclipse GUI and Android, C2 architectural models on JOnAS, Rainbow C/S style on PLASTIC and UML models on POJO.

Since many web sites provide their own services and a web browser becomes a rich client platform, a new type of web application that is constructed by assembling web-delivered services in web browser, called Service-Oriented Rich Client (SoRC), emerges. Typical SoRC applications include web OSes and mashups. Due to the increasing complexity of SoRC, we propose a new type of middleware, which is embedded in web browsers and encapsulates reusable solutions for common problems of SoRC, including a container for component instances, a set of mechanisms for interactions within the browser, between the browser and server. Different SoRC applications can be constructed easily in high quality based on this middleware. We implement a prototype of the Internetware browser middleware, and then build two SoRC applications based on this prototype: 1) a web-based BPEL editor, iServiceStudio; 2) a mashup environment, iMashup.

Dynamic reconfiguration support in application servers is a solution to meet the demands for flexible and adaptive component-based applications. However, when an application is reconfigured, its fault-tolerant mechanism should be reconfigured either. This is one of the crucial problems we have to solve before a fault-tolerant application is dynamically reconfigured at runtime. This paper proposes a fault-tolerant sandbox to support the reconfigurable fault-tolerant mechanisms on application servers. We present how the sandbox integrates multiple error detection and recovery mechanisms, and how to reconfigure these mechanisms at runtime, especially for coordinated recovery mechanisms. We implement a prototype and perform a set of controlled experiments to demonstrate the sandbox’s capabilities.

The Web has undergone a tremendous change toward a highly user-centric environment. Millions of users can participate and collaborate for their own interests and benefits. Services Computing paradigm together with the proliferation of Web services have created great potential opportunities for the users, also known as service consumers, to produce value-added services by means of service discovery and composition. In this paper, we propose an efficient approach to facilitating the service consumer on discovering Web services. First, we analyze the service discovery requirements from the service consumer's perspective and outline a conceptual model of homogeneous Web service communities. The homogeneous service community contains two types of discovery: the search of similar operations and that of composible operations. Second, we describe a similarity measurement model for Web services by leveraging the metadata from WSDL, and design a graph-based algorithm to support both of the two discovery types. Finally, adopting the popular atom feeds, we design a prototype to facilitate the consumers to discover while subscribing Web services in an easy-of-use manner. With the experimental evaluation and prototype demonstration, our approach not only alleviates the consumers from time-consuming discovery tasks but also lowers their entry barrier in the user-centric Web environment.

Programmers often have to do many repetitive tasks when using an IDE (integrated development environment). These tasks require them to navigate through many views and dialogs in the same steps and input same data, which are time consuming and boring. In this paper, we present an approach to automatically perform the repetitive tasks by catching user actions on the IDE and replaying them when necessary. The sequence and contents of the caught user actions can be edited for generating user actions of similar tasks. The user actions are manifested as a set of high-level information so that they are easy to be edited and robust to UI changes. We present SmartReplayer, an implementation of our approach in the Eclipse IDE and use examples to show that it can greatly improve efficiency of Eclipse Programmers.

In the past a few years, the Web has undergone a tremendous change towards a highly user-centric environment. Millions of users can participate and collaborate for their own interests and benefits. Service oriented computing and Web services have created great potential opportunities for the users to build their own applications. Then, it is a pressing issue that, the users can compose services without too complex tasks and efforts. In this paper, we introduce a user-oriented approach which aims to simplify service composition. We leverage the plentiful information residing in service tags, both from service descriptions (such as WSDL) and the annotations tagged by users. Employing some mining algorithms, a direct acyclic graph is built up to represent potential composition opportunities. With a simple and intuitive search, it allows users to explore the space of potentially composable services and achieve service composition in a heuristic manner. We have developed a composition advisor to provide recommendations guiding and assisting the users. It also lets the users discover and make use of services without having to understand too many details of individual candidate services. To enable the users to accomplish service composition in a more interactive access channel, we finally provide a user-friendly prototype based on Web browsers. It undoubtedly reduces the complexity and lowers the entry barrier for the users, and makes them better play their role in the service-oriented Web environment.

Model refactoring is emerging as a desirable means to improve design model by restructuring it while preserving the behavior properties. It applies the concept of refactoring to a higher level of abstraction and makes refactoring more convenient and effective. Model refactoring always arises at design phase, but unfortunately, 7(days) times 24(hours) high availability requires that refactoring takes effect at runtime without stopping the running systems. In this paper, we present a middleware-based approach to applying model refactoring for component based applications at runtime. First of all, ill-structures in an application are abstracted as bad patterns, each of which has at least one good pattern abstracting the refactored part in the application without the ill-structure. People can define the bad/good patterns using a MOF-based metamodel. After that, with the help of middleware, the ill-structures will be automatically detected and removed by refactoring the running application under the guide of predefined patterns.

Model refinement is a complex task. It is difficult for developers to refine models all by themselves. A good modeling tool should not only do routine refinement work for developers, but also guide them to make decisions during the refinement process. Such refinement work is best done by modeling tools instantly while developers refine models, to provide timely assistance. In this paper, we present a general approach for meta-model designers or experts in different fields to define and describe such automatic refinement work by rules, and these rules can instruct the modeling tool to do the refinement work instantly, whenever the developers modify the model. The automatic refinement rules in our approach are based on OCL, and their semantics and behaviors are formally defined by using Dijkstra's guarded commands, so the rules are compact, unambiguous and reliable to use. We have also implemented the editor and the interpreter for the automatic refinement rules, and integrated them into our own modeling tool to support our approach.

Mission-critical software claims safe and robust adaptations that comply with rigorous criteria of multiple critical quality attributes. Existing adaptation approaches pay little attention to comprehensively capture mission goals and explicitly specify adaptation requirements. We propose an approach to using scenario-based analysis to elicit and specify the criteria of multiple quality attributes as adaptation invariants, and design corresponding architecture variants as facilities implementing adaptations. We also present how to make adaptation decisions at runtime.

The popularity of service oriented computing (SOC) brings a large number of distributed, well-encapsulated and reusable services all over Internet, and makes it possible to create value-added services by means of service composition. Current composition styles are too professional to those end users when building their own applications. Actually, the end user would prefer rapidly discovering the best-of-breed services to assemble as well as visually personalizing the presentation to enjoy rich experiences. We propose an end user service composition approach for reducing the composition complexity and difficulty from the end user perspective. In our approach, similar candidate services are aggregated together as a unified resource, whose wide QoS spectrum can be easily manipulated by the end users to satisfy their requirements. Then they can personalize the services and, the composition occurs only at the presentation layer. The main contributions of the approach are: (i) enabling the end users to personalize the composite application with more powerful presentation; (ii) supporting the end users to dynamically customize the service composition in terms of QoS; (iii) alleviating the end users from the time-consuming task of selecting service to compose.

In current web service discovery and subscription, consumers must pay too much time on manually selection and cannot easily benefit from the wide QoS spectrum brought by the proliferating services. In our approach, we introduce the service pool as a "virtual service" grouping function identical services together and dispatching consumer requests to the proper service in terms of QoS requirements.

Software architecture (SA) is the blueprint of the software system and considered as one of the most important artifacts in component based development. The design and analysis of SA can be very complex. Under the inspiration of Model-Driven Development, the design of SA has been no more constrained in one stage. It is a trend to construct multiple SA models in multiple stages during the software life cycle. Thus, the traceability between these SA models becomes a new challenge. The information between these SA models in deferent stages is usually not recorded well and easy to be lost lately, which makes the maintenance and evolution difficult and error-prone. In this paper, we present an approach to recording the information between SA models via a traceability model for reducing the loss of design decisions and helping developers understand the software system well.

A component array is a group of component implementations that provide the same functions but have different qualities. At runtime, a component array can adapt to changes of the system and environment by executing different implementations. When developing component arrays, developers have to implement them from the scratch and consider all such things as how to manage component implementations, how to control the selection and so on. In this paper, we propose a container model that provides a runtime space for component arrays and makes the development of component arrays easier and dependable. The container model is implemented in a J2EE compliant application server

Component based software development (CBSD) becomes a popular paradigm for Internet based systems. Compared to other popular paradigms, CBSD supports the development from reusable components other than the development from the scratch. Consequently, modeling becomes more important than programming and the modeling techniques in traditional paradigms have to be changed more or less. Particularly, improper selection and misuse of modeling techniques would prevent the target system from benefiting from CBSD and even make the project fail. For helping researchers and practitioners to equip with CBSD, this tutorial will provide basic knowledge and skill of modeling component based systems systematically. Firstly, we will introduce the technical and non-technical motivations of CBSD with emphasis on software reuse which puts a significant impact on modeling. Secondly, we will present a systematic approach to modeling component based systems with a set of existing well-proved modeling techniques, including feature modeling for requirements specification, architecture modeling for abstract design, and object oriented modeling for detailed design. These modeling techniques and a real-life project will be discussed in details in the rest of the tutorial.

Middleware can be viewed as a collection of common services which may fail caused by various reasons. Recovery-based fault tolerance is an effective way to improve middleware services' dependability. But the interdependent relationships among services make the recovery of failed services complex. This paper analyzes the interdependent relationships and correlated faults of the data service and the transaction service in J2EE (Java 2 Platform Enterprise Edition), and presents the coordinated recovery of these two services, which is demonstrated in PKUAS, a J2EE-compliant middleware product. Our coordinated recovery uses a configuration file to define correlated faults and their corresponding recovery operations, a centralized coordinator to schedule these operations, and the request caching to improve the effect. Experimentation results show that our coordinated recovery provide a better user-visible availability than other recovery strategies.

In this paper, an approach is presented to formally model architecture based software development process. The ability of UML in modeling software architecture is reinforced by defining a generic model of component and software architecture, and by integrating the model with UML class model and interaction model to unify software development process. In UML, software development is modeled in different views. With formal semantics, designer can keep consistency among these views. The paper demonstrates how to use the method to construct software.

The continuous requirements of evolving a delivered software system and the rising cost of shutting down a running software system are forcing researchers and practitioners to find ways of updating software as it runs. Dynamic update is a kind of software evolution that updates a running program without interruption. This paper covers the fundamental issues of the mechanisms of dynamic update theoretically. Based on a similarity analysis of many typical approaches to dynamic update during the past decades, we propose a unified formal model (namely, Dynamic Update Connector) to specify mechanisms of updating an architectural component, and reason about its properties. The model borrows the concept of connectors from software architecture community and is specified using process algebra CSP. We also demonstrate the applications of our DUC model.

Reflective middleware is proposed for guaranteeing desired qualities of middleware based systems which reside in the extremely open and dynamic Internet. Current researches and practices focus on how to monitor and change the whole system through reflective mechanisms provided by middleware. However, they put little attention on why, when and what to monitor and change because it is very hard for middleware to collect enough knowledge which is usually specific to the whole system. Being an important artifact in software development, software architecture records plentiful design information, especially the considerations for quality attributes of the target system. It is a natural idea to provide reflective middleware with enough knowledge via software architecture. This paper presents a demonstration of the idea. In this demonstration, the self-adaptations can be analyzed in a quality attribute scenario based way and specified by an extended architecture description language. Such knowledge prescribed at the design phase can be used directly by an architecture based reflective middleware which then automatically adapts itself at runtime.

Autonomic computing middleware is a promising way to enable middleware based systems to cope with the rapid and continuous changes in the era of Internet. Technically, there have been three fundamental and challenging capabilities to an autonomic computing middleware, including how to monitor, reason and control middleware platform and applications. This position paper presents a reflection-based approach to autonomic computing middleware, which shows the philosophy that autonomic computing should focus on how to reason while reflective computing supports how to monitor and control. In this approach, the states and behaviors of middleware-based systems can be observed and changed through reflective mechanisms embedded in middleware platform at runtime. On the basis of reflection, some autonomic computing facilities could be constructed to reason and decide when and what to change. The approach is demonstrated on a reflective J2EE application server, which can automatically optimize itself in the standard J2EE benchmark testing

Runtime environment of software are becoming more and more dynamic and changeful, while pervasive computing and Web services further this situation. Software systems are not only becoming larger, more complex, and also more rigid, which make it difficult to evolve software. This paper focuses on online evolution, more exactly, how to make online evolution process convenient and smart, with help of runtime software architecture (RSA). Following issues are discussed in this paper: types of software environment changes, the incarnation of RSA, retrieval and manipulation of RSA, the relation between RSA and the runtime system, and a visual tool to show RSA, and make evolution process more easy and intuitionist.