A  B  C  D  E  F  G  H  I  J  K  L  M  N  O  P  Q  R  S  T  U  V  W  X  Y  Z  

  Subjects -> ELECTRONICS (Total: 207 journals)
The end of the list has been reached or no journals were found for your choice.
Similar Journals
Journal Cover
IEEE Transactions on Software Engineering
Journal Prestige (SJR): 0.548
Citation Impact (citeScore): 5
Number of Followers: 84  
 
  Hybrid Journal Hybrid journal (It can contain Open Access articles)
ISSN (Print) 0098-5589
Published by IEEE Homepage  [228 journals]
  • Use and Misuse of the Term “Experiment” in Mining Software
           Repositories Research

    • Free pre-print version: Loading...

      Authors: Claudia Ayala;Burak Turhan;Xavier Franch;Natalia Juristo;
      Pages: 4229 - 4248
      Abstract: The significant momentum and importance of Mining Software Repositories (MSR) in Software Engineering (SE) has fostered new opportunities and challenges for extensive empirical research. However, MSR researchers seem to struggle to characterize the empirical methods they use into the existing empirical SE body of knowledge. This is especially the case of MSR experiments. To provide evidence on the special characteristics of MSR experiments and their differences with experiments traditionally acknowledged in SE so far, we elicited the hallmarks that differentiate an experiment from other types of empirical studies and characterized the hallmarks and types of experiments in MSR. We analyzed MSR literature obtained from a small-scale systematic mapping study to assess the use of the term experiment in MSR. We found that 19% of the papers claiming to be an experiment are indeed not an experiment at all but also observational studies, so they use the term in a misleading way. From the remaining 81% of the papers, only one of them refers to a genuine controlled experiment while the others stand for experiments with limited control. MSR researchers tend to overlook such limitations, compromising the interpretation of the results of their studies. We provide recommendations and insights to support the improvement of MSR experiments.
      PubDate: Nov. 1 2022
      Issue No: Vol. 48, No. 11 (2022)
       
  • A Systematic Assessment on Android Third-Party Library Detection Tools

    • Free pre-print version: Loading...

      Authors: Xian Zhan;Tianming Liu;Yepang Liu;Yang Liu;Li Li;Haoyu Wang;Xiapu Luo;
      Pages: 4249 - 4273
      Abstract: Third-party libraries (TPLs) have become a significant part of the Android ecosystem. Developers can employ various TPLs to facilitate their app development. Unfortunately, the popularity of TPLs also brings new security issues. For example, TPLs may carry malicious or vulnerable code, which can infect popular apps to pose threats to mobile users. Furthermore, TPL detection is essential for downstream tasks, such as vulnerabilities and malware detection. Thus, various tools have been developed to identify TPLs. However, no existing work has studied these TPL detection tools in detail, and different tools focus on different applications and techniques with performance differences. A comprehensive understanding of these tools will help us make better use of them. To this end, we conduct a comprehensive empirical study to fill the gap by evaluating and comparing all publicly available TPL detection tools based on six criteria: accuracy of TPL construction, effectiveness, efficiency, accuracy of version identification, resiliency to code obfuscation, and ease of use. Besides, we enhance these open-source tools by fixing their limitations, to improve their detection ability. Finally, we build an extensible framework that integrates all existing available TPL detection tools, providing an online service for the research community. We release the evaluation dataset and enhanced tools. According to our study, we also present the essential findings and discuss promising implications to the community; e.g., 1) Most existing TPL detection techniques more or less depend on package structure to construct in-app TPL candidates. However, using package structure as the module decoupling feature is error-prone. We hence suggest future researchers using the class dependency to substitute package structure. 2) Extracted features include richer semantic information (e.g., class dependencies) can achieve better resiliency to code obfuscation. 3) Existing tools usually have - low recall; that is because previous tools ignore some features of Android apps and TPLs, such as the compilation mechanism, the new format of TPLs, TPL dependency. Most existing tools cannot effectively find partial import TPLs, obfuscated TPLs, which directly limit their capability. 4) Existing tools are complementary to each other; we can build a better tool via combining the advantages of each tool. We believe our work provides a clear picture of existing TPL detection techniques and also gives a road-map for future research.
      PubDate: Nov. 1 2022
      Issue No: Vol. 48, No. 11 (2022)
       
  • Transfer Learning Across Variants and Versions: The Case of Linux Kernel
           Size

    • Free pre-print version: Loading...

      Authors: Hugo Martin;Mathieu Acher;Juliana Alves Pereira;Luc Lesoil;Jean-Marc Jézéquel;Djamel Eddine Khelladi;
      Pages: 4274 - 4290
      Abstract: With large scale and complex configurable systems, it is hard for users to choose the right combination of options (i.e., configurations) in order to obtain the wanted trade-off between functionality and performance goals such as speed or size. Machine learning can help in relating these goals to the configurable system options, and thus, predict the effect of options on the outcome, typically after a costly training step. However, many configurable systems evolve at such a rapid pace that it is impractical to retrain a new model from scratch for each new version. In this paper, we propose a new method to enable transfer learning of binary size predictions among versions of the same configurable system. Taking the extreme case of the Linux kernel with its $approx 14,500$≈14,500 configuration options, we first investigate how binary size predictions of kernel size degrade over successive versions. We show that the direct reuse of an accurate prediction model from 2017 quickly becomes inaccurate when Linux evolves, up to a 32% mean error by August 2020. We thus propose a new approach for transfer evolution-aware model shifting (tEAMS). It leverages the structure of a configurable system to transfer an initial predictive model towards its future versions with a minimal amount of extra processing for each version. We show that tEAMS vastly outperforms state of the art approaches over the 3 years history of Linux kernels, from 4.13 to 5.8.
      PubDate: Nov. 1 2022
      Issue No: Vol. 48, No. 11 (2022)
       
  • Challenges and Common Solutions in Smart Contract Development

    • Free pre-print version: Loading...

      Authors: Niclas Kannengießer;Sebastian Lins;Christian Sander;Klaus Winter;Hellmuth Frey;Ali Sunyaev;
      Pages: 4291 - 4318
      Abstract: Smart contracts are a promising means of formalizing and reliably enforcing agreements between entities using distributed ledger technology (DLT). Research has revealed that a significant number of smart contracts are subject to programming flaws, making them vulnerable to attacks and leading to detrimental effects, such as asset loss. Researchers and developers call for a thorough analysis of challenges to identify their causes and propose solutions. To respond to these calls, we conducted two literature reviews and diverse expert interviews and synthesized scattered knowledge on challenges and solutions. We identified 29 challenges (e.g., code visibility, code updateability, and encapsulation) and 60 solutions (e.g., gas limit specification, off-ledger computations, and shadowing). Moreover, we developed 20 software design patterns (SDPs) in collaboration with smart contract developers. The SDPs help developers adjust their programming habits and thus support them in their daily development practices. Our results provide actionable knowledge for smart contract developers to overcome the identified challenges and offer support for comparing smart contract integration concepts across three fundamentally different DLT protocols (i.e., Ethereum, EOSIO, and Hyperledger Fabric). Moreover, we support developers in becoming aware of peculiarities in smart contract development and the resulting benefits and drawbacks.
      PubDate: Nov. 1 2022
      Issue No: Vol. 48, No. 11 (2022)
       
  • A Mixed-Method Approach to Recommend Corrections and Correct REST
           Antipatterns

    • Free pre-print version: Loading...

      Authors: Fatima Sabir;Yann-Gaël Guéhéneuc;Francis Palma;Naouel Moha;Ghulam Rasool;Hassan Akhtar;
      Pages: 4319 - 4338
      Abstract: Many companies, e.g., Facebook and YouTube, use the REST architecture and provide REST APIs to their clients. Like any other software systems, REST APIs need maintenance and must evolve to improve and stay relevant. Antipatterns—poor design practices—hinder this maintenance and evolution. Although the literature defines many antipatterns and proposes approaches for their (automatic) detection, their correction did not receive much attention. Therefore, we apply a mixed-method approach to study REST APIs and REST antipatterns with the objectives to recommend corrections or, when possible, actually correct the REST antipatterns. Qualitatively, via case studies, we analyse the evolution of 11 REST APIs, including Facebook, Twitter, and YouTube, over six years. We detect occurrences of eight REST antipatterns in the years 2014, 2017, and 2020 in 17 versions of 11 REST APIs. Thus, we show that (1) REST APIs and antipatterns evolve over time and (2) developers seem to remove antipatterns. Qualitatively via a discourse analysis, we analyse developers’ forums and report that developers are concerned with the occurrences of REST antipatterns and discuss corrections to these antipatterns. Following these qualitative studies, using an engineering-research approach, we propose the following novel and unique contributions: (1) we describe and compare the corrections of eight REST antipatterns from the academic literature and from developers’ forums; (2) we devise and describe algorithms to recommend corrections to some of these antipatterns; (3) we present algorithms and a tool to correct some of these antipatterns by intercepting and modifying responses from REST APIs; and, (4) we validate the recommendations and the corrections manually and via a survey answered by 24 REST developer-. Thus, we propose to REST API developers and researchers the first, grounded approach to correct REST antipatterns.
      PubDate: Nov. 1 2022
      Issue No: Vol. 48, No. 11 (2022)
       
  • Compiling Quantamorphisms for the IBM Q Experience

    • Free pre-print version: Loading...

      Authors: Ana Neri;Rui Soares Barbosa;José N. Oliveira;
      Pages: 4339 - 4356
      Abstract: Based on the connection between the categorical derivation of classical programs from specifications and a category-theoretic approach to quantum information, this paper contributes to extending the laws of classical program algebra to quantum programming. This aims at building correct-by-construction quantum circuits to be deployed on quantum devices such as those available through the IBM Q Experience. Reversibility is ensured by minimal complements. Such complementation is extended inductively to encompass catamorphisms on lists (vulgo folds), giving rise to the corresponding recursion scheme in reversible computation. The same idea is then applied to the setting of quantum programming, where computation is expressed by unitary transformations. This yields the notion of ‘quantamorphism’, a structural form of quantum recursion implementing cycles and folds on lists with quantum control flow. By Kleisli correspondence, quantamorphisms can be written as monadic functional programs with quantum parameters. This enables the use of Haskell, a monadic functional programming language, to perform the experimental work. Such calculated quantum programs prepared in Haskell are pushed through Quipper and the Qiskit interface to IBM Q quantum devices. The generated quantum circuits – often quite large – exhibit the predicted behaviour. However, running them on real quantum devices naturally incurs a significant amount of errors. As quantum technology is rapidly evolving, an increase in reliability is likely in the future, allowing for our programs to run more accurately.
      PubDate: Nov. 1 2022
      Issue No: Vol. 48, No. 11 (2022)
       
  • DevRec: Multi-Relationship Embedded Software Developer Recommendation

    • Free pre-print version: Loading...

      Authors: Xinqiang Xie;Xiaochun Yang;Bin Wang;Qiang He;
      Pages: 4357 - 4379
      Abstract: Collaboration efficiency is of paramount importance for software development. Finding suitable developers is critical and challenging due to the difficulty of capturing developers’ expertises, relevance as well as the sparsity of explicit developer-task interactions. To tackle this problem, existing developer recommendation approaches focus on modelling the developer’s expertise or interactions with tasks based on their historical information. However, such approaches often suffer from low performance because they ignore some useful information that might help improve recommendation performance, such as 1) developers’ collaboration relationship; 2) the interaction relationship between developer and task; and 3) the tasks’ similarity relationship. To leverage the above-mentioned relationships, this paper proposes DevRec, a novel multi-relationship embedded approach for software developer recommendation. We first formally define the multi-relationships and then learn the vector representations (aka. embeddings) of developers and tasks. Second, we explicitly encoded the multi-relationships into the embedding process. Third, to refine the embeddings of developers and tasks, we recursively propagate the embeddings from their high-order connectivity based on graph convolution network. Moreover, to reveal the importance of different relationships, we generate their attentive weights based on attention mechanism. Finally, to evaluate the performance of DevRec, we conduct extensive experiments on two real-world datasets, and to investigate the usefulness of DevRec in practice, we conduct a user study at a large software company. The results show that DevRec outperforms other five state-of-the-art approaches significantly.
      PubDate: Nov. 1 2022
      Issue No: Vol. 48, No. 11 (2022)
       
  • Pluto: Exposing Vulnerabilities in Inter-Contract Scenarios

    • Free pre-print version: Loading...

      Authors: Fuchen Ma;Zhenyang Xu;Meng Ren;Zijing Yin;Yuanliang Chen;Lei Qiao;Bin Gu;Huizhong Li;Yu Jiang;Jiaguang Sun;
      Pages: 4380 - 4396
      Abstract: Attacks on smart contracts have caused considerable losses to digital assets. Many techniques based on symbolic execution, fuzzing, and static analysis are used to detect contract vulnerabilities. Most of the current analyzers only consider vulnerability detection intra-contract scenarios. However, Ethereum contracts usually interact with others by calling their functions. A bug hidden in a path that depends on information from external contract calls is defined as an inter-contract vulnerability. Failure to deal with this kind of bug can result in potential false negatives and false positives. In this work, we propose Pluto, which supports vulnerability detection in inter-contract scenarios. It first builds an Inter-contract Control Flow Graph (ICFG) to extract semantic information among contract calls. Afterward, it symbolically explores the ICFG and deduces Inter-Contract Path Constraints (ICPC) to check the reachability of execution paths more accurately. Finally, Pluto detects whether there is a vulnerability based on some predefined rules. For evaluation, we compare Pluto with five state-of-the-art tools, including Oyente, Mythril, Securify, ILF, and Clairvoyance on a labeled benchmark and 39,443 real-world Ethereum smart contracts. The result shows that other tools can only detect 10% of the inter-contract vulnerabilities, while Pluto can detect 80% of them on the labeled dataset. Beyond that, Pluto has detected 451 confirmed vulnerabilities on real-world contracts, including 36 vulnerabilities in inter-contract scenarios. Two bugs have been assigned with unique CVE identifiers by the US National Vulnerability Database (NVD). On average, Pluto costs 16.9 seconds to analyze a contract, which is as fast as the state-of-the-art tools.
      PubDate: Nov. 1 2022
      Issue No: Vol. 48, No. 11 (2022)
       
  • Building Maintainable Software Using Abstraction Layering

    • Free pre-print version: Loading...

      Authors: John Spray;Roopak Sinha;Arnab Sen;Xingbin Cheng;
      Pages: 4397 - 4410
      Abstract: Increased software maintainability can help improve a company's profitability by directly reducing ongoing software development costs. Abstraction Layered Architecture (ALA) is a reference architecture for building maintainable applications, but its effectiveness in commercial projects has remained unexplored. This research, carried out as a 16-month joint industry-academic project, explores developing commercial code bases using ALA and the extent to which ALA improves maintainability. An existing application from Datamars, New Zealand, was re-developed by using ALA and compared with the original application. In order to carry out these comparisons, we developed suitable measures by adapting maintainability characteristics from the ISO 25010 family of standards. Specifically, we determined metrics to capture the five sub-characteristics of maintainability: modularity, reusability, analysability, modifiability, and testability; and used them to test our hypothesis that the use of ALA improved maintainability of the application. During the evaluation, we found that the modularity, reusability, analysability, and testability of the re-developed ALA application were higher than for the original application. The modifiability of the ALA-based application was lower in the short-term, but shown to trend upwards in the longer term. Our findings led to proposing a generalised ALA-based development method that promises a significant reduction in maintenance costs.
      PubDate: Nov. 1 2022
      Issue No: Vol. 48, No. 11 (2022)
       
  • Detecting Compiler Warning Defects Via Diversity-Guided Program Mutation

    • Free pre-print version: Loading...

      Authors: Yixuan Tang;He Jiang;Zhide Zhou;Xiaochen Li;Zhilei Ren;Weiqiang Kong;
      Pages: 4411 - 4432
      Abstract: Compiler diagnostic warnings help developers identify potential programming mistakes during program compilation. However, these warnings could be erroneous due to the defects of compiler warning diagnostics. Although the existing technique (i.e., Epiphron) can automatically generate test programs for compiler warning defect detection, the effectiveness of Epiphron on defect-finding is still limited, due to the limitation for generating warning-sensitive test program structures. Therefore, in this paper, we propose a DIversity-guided PROgram Mutation approach, called DIPROM, to construct diverse warning-sensitive programs for effective compiler warning defect detection. Given a seed test program, DIPROM first removes its dead code to reduce false positive warning defects. Then, the abstract syntax tree (AST) of the test program is constructed; DIPROM iteratively mutates the structures of the AST to generate warning-sensitive program variants. To effectively construct diverse warning-sensitive structures, DIPROM applies a novel diversity-guided strategy to generate program variants in each iteration. With the generated program variants, differential testing is conducted to detect warning defects in different compilers. In the experiments, we evaluate DIPROM with two popular C compilers (i.e., GCC and Clang). Experimental results show that DIPROM significantly outperforms three state-of-the-art approaches (i.e., HiCOND, Epiphron, and Hermes) by up to 18.93%$sim$∼76.74% in terms of the bug-finding capability on average. Meanwhile, DIPROM is efficient, which spends less time on finding the same average number of warning defects. We at last applied DIPROM to the latest development versions of GCC and Clang. After t-o months’ running, we reported 8 new warning defects; 5 of them have been confirmed/fixed by developers.
      PubDate: Nov. 1 2022
      Issue No: Vol. 48, No. 11 (2022)
       
  • The Importance of Security Is in the Eye of the Beholder: Cultural,
           Organizational, and Personal Factors Affecting the Implementation of
           Security by Design

    • Free pre-print version: Loading...

      Authors: Renana Arizon-Peretz;Irit Hadar;Gil Luria;
      Pages: 4433 - 4446
      Abstract: Security by design is a recommended approach, addressing end-to-end security and privacy in the design of software systems. To realize this approach, proactive security behavior is required from software developers. This research follows results from previous studies that suggest that personal and organizational characteristics influence security-related behaviors during the software design process. The research is aimed at gaining an in-depth understanding of proactive security behavior and the factors affecting it. Leveraging organization climate theory from organizational psychology, we propose a theoretical model, detailing different factors and their relations with proactive security behavior and test it in empirical settings. The empirical study was conducted in collaboration with an internationally distributed information technology enterprise and included a survey questionnaire completed by 499 software developers working in seven countries. The results of the survey confirm the moderation-mediation relations in the proposed model, revealing that organizational security climate and security self-efficacy are both positively associated with proactive security behavior, organizational security climate is positively associated with security self-efficacy, and cultures promoting individualism moderate the relationship between organizational security climate and security self-efficacy, thus impeding proactive security behavior. The body of knowledge of organizational psychology points to directions that can effectively be activated for improvement.
      PubDate: Nov. 1 2022
      Issue No: Vol. 48, No. 11 (2022)
       
  • Verification and Synthesis of Responsive Symmetric Uni-Rings

    • Free pre-print version: Loading...

      Authors: Ali Ebnenasir;
      Pages: 4447 - 4464
      Abstract: This paper investigates the verification and synthesis of parameterized protocols that satisfy leadsto properties on symmetric unidirectional rings (a.k.a. uni-rings) of deterministic, self-disabling and constant-space processes. First, we show that when $R$R and $Q$Q are conjunctive global state predicates, verifying ‘$R$R leadsto $Q$Q’ (denoted $R leadsto Q$R⇝Q) for parameterized protocols on symmetric uni-rings is undecidable. Then, we show that surprisingly synthesizing symmetric uni-ring protocols that satisfy $R leadsto Q$R⇝Q is actually decidable. We identify necessary and sufficient conditions for the decidability of synthesi- based on which we design and implement a sound and complete algorithm that takes the predicates $R$R and $Q$Q, and automatically generates a parameterized protocol that satisfies $R leadsto Q$R⇝Q for unbounded (but finite) ring sizes. Moreover, we show that verifying leadsto properties remains undecidable even if $R$R and $Q$Q are local state predicates! This result would lead to the impossibility of computing a cutoff for local leadsto on symmetric rings of deterministic, self-disabling and constant-space processes. We further show that verifying local and global deadlocks in our formal setting are decidable problems. We also present a cutoff theorem that enables the construction of symmetric rings where deadlocks are reachable.
      PubDate: Nov. 1 2022
      Issue No: Vol. 48, No. 11 (2022)
       
  • Android Custom Permissions Demystified: A Comprehensive Security
           Evaluation

    • Free pre-print version: Loading...

      Authors: Rui Li;Wenrui Diao;Zhou Li;Shishuai Yang;Shuang Li;Shanqing Guo;
      Pages: 4465 - 4484
      Abstract: Permission is the fundamental security mechanism for protecting user data and privacy on Android. Given its importance, security researchers have studied the design and usage of permissions from various aspects. However, most of the previous research focused on the security issues of system permissions. Overlooked by many researchers, an app can use custom permissions to share its resources and capabilities with other apps. However, the security implications of using custom permissions have not been fully understood. In this paper, we systematically evaluate the design and implementation of Android custom permissions. Notably, we built an automatic fuzzing tool, called CuPerFuzzer+, to detect custom permission related vulnerabilities existing in the Android OS. CuPerFuzzer+ treats the operations of the permission mechanism as a black-box and executes massive targeted test cases to trigger privilege escalation. In the experiments, CuPerFuzzer+ discovered 5,932 effective cases with 47 critical paths successfully. Through investigating these vulnerable cases and analyzing the source code of Android OS, we further identified a series of severe design shortcomings lying in the Android permission framework, including dangling custom permission, inconsistent permission-group mapping, custom permission elevating, inconsistent permission definition, dormant permission group, and inconsistent permission type. Exploiting these shortcomings, a malicious app can access unauthorized platform resources. On top of these observations, we propose three general design guidelines to secure custom permissions. Our findings have been acknowledged by the Android security team and assigned CVE-2020-0418, CVE-2021-0306, CVE-2021-030-, and CVE-2021-0317.
      PubDate: Nov. 1 2022
      Issue No: Vol. 48, No. 11 (2022)
       
  • API-Related Developer Information Needs in Stack Overflow

    • Free pre-print version: Loading...

      Authors: Mingwei Liu;Xin Peng;Andrian Marcus;Shuangshuang Xing;Christoph Treude;Chengyuan Zhao;
      Pages: 4485 - 4500
      Abstract: Stack Overflow (SO) provides informal documentation for APIs in response to questions that express API related developer needs. Navigating the information available on SO and getting information related to a particular API and need is challenging due to the vast amount of questions and answers and the tag-driven structure of SO. In this paper we focus on identifying and classifying fine-grained developer needs expressed in sentences of API-related SO questions, as well as the specific information types used to express such needs, and the different roles APIs play in these questions and their answers. We derive a taxonomy, complementing existing ones, through an empirical study of 266 SO posts. We then develop and evaluate an approach for the automated identification of the fine-grained developer needs in SO threads, which takes a thread as input and outputs the corresponding developer needs, the types of information expressing them, and the roles of API elements relevant to the needs. To show a practical application of our taxonomy, we introduce and evaluate an approach for the automated retrieval of SO questions, based on these developer needs.
      PubDate: Nov. 1 2022
      Issue No: Vol. 48, No. 11 (2022)
       
  • XDebloat: Towards Automated Feature-Oriented App Debloating

    • Free pre-print version: Loading...

      Authors: Yutian Tang;Hao Zhou;Xiapu Luo;Ting Chen;Haoyu Wang;Zhou Xu;Yan Cai;
      Pages: 4501 - 4520
      Abstract: Existing programming practices for building Android apps mainly follow the “one-size-fits-all” strategy to include lots of functions and adapt to most types of devices. However, this strategy can result in software bloat and many serious issues, such as slow download speed, and large attack surfaces. Existing solutions cannot effectively debloat an app as they either lack flexibility or require human efforts. This work proposes a novel feature-oriented debloating approach and builds a prototype, named XDebloat, to automate this process in a flexible manner. First, We propose three feature location approaches to mine features in an app. XDebloat supports feature location approaches at a fine granularity. It also makes the feature location results editable. Second, XDebloat considers several Android-oriented issues (i.e., callbacks) to perform a more precise analysis. Third, XDebloat supports two major debloating strategies: pruning-based debloating and module-based debloating. We evaluate XDebloat with 200 open-source and 1,000 commercial apps. The results show that XDebloat can successfully remove components from apps or transform apps into on-demand modules within 10 minutes. For the pruning-based debloating strategy, on average, XDebloat can remove 32.1% code from an app. For the module-based debloating strategy, XDebloat can help developers build instant apps or app bundles automatically.
      PubDate: Nov. 1 2022
      Issue No: Vol. 48, No. 11 (2022)
       
  • Why Did Developers Migrate Android Applications From Java to Kotlin'

    • Free pre-print version: Loading...

      Authors: Matias Martinez;Bruno Gois Mateus;
      Pages: 4521 - 4534
      Abstract: Currently, the majority of apps running on mobile devices are Android apps developed in Java. However, developers can now write Android applications using a new programming language: Kotlin, which Google adopted in 2017 as an official programming language for developing Android apps. Since then, Android developers have been able to: a) start writing Android applications from scratch using Kotlin, b) evolve their existing Android applications written in Java by adding Kotlin code (possible thanks to the interoperability between the two languages), or c) migrate their Android apps from Java to Kotlin. This paper aims to study this last case. We conducted a qualitative study to find out why Android developers have migrated Java code to Kotlin and to bring together their experiences about the process, in order to identify the main difficulties they have faced. To execute the study, we first identified commits from open-source Android projects that have migrated Java code to Kotlin. Then, we emailed the developers that wrote those migrations. We thus obtained information from 98 developers who had migrated code from Java to Kotlin. This paper presents the main reasons identified by the study for performing the migration. We found that developers migrated Java code to Kotlin in order to access programming language features (e.g., extension functions, lambdas, smart casts) that are not available with Java for Android development, and to obtain safer code (i.e., avoid null-pointer exceptions). We also identified research directions that the research community could focus on in order to help developers to improve the experience of migrating their Java applications to Kotlin.
      PubDate: Nov. 1 2022
      Issue No: Vol. 48, No. 11 (2022)
       
  • Mithra: Anomaly Detection as an Oracle for Cyberphysical Systems

    • Free pre-print version: Loading...

      Authors: Afsoon Afzal;Claire Le Goues;Christopher Steven Timperley;
      Pages: 4535 - 4552
      Abstract: Testing plays an essential role in ensuring the safety and quality of cyberphysical systems (CPSs). One of the main challenges in automated and software-in-the-loop simulation testing of CPSs is defining effective oracles that can check that a given system conforms to expectations of desired behavior. Manually specifying such oracles can be tedious, complex, and error-prone, and so techniques for automatically learning oracles are attractive. Characteristics of CPSs, such as limited or no access to source code, behavior that is non-deterministic and sensitive to noise, and that the system may respond differently to input based on its context introduce considerable challenges for automated oracle learning. We present Mithra, a novel, unsupervised oracle learning technique for CPSs that operates on existing telemetry data. It uses a three-step multivariate time series clustering to discover the set of unique, correct behaviors for a CPS, which it uses to construct robust oracles. We instantiate our proposed technique for ArduPilot, a popular, open-source autopilot software. On a set of 24 bugs, we show that Mithra effectively identifies buggy executions with few false positives and outperforms AR-SI, a state-of-the-art CPS oracle learning technique. We demonstrate Mithra’s wider applicability by applying it to an autonomous racer built for the Robot Operating System.
      PubDate: Nov. 1 2022
      Issue No: Vol. 48, No. 11 (2022)
       
  • Empowering the Human as the Fitness Function in Search-Based Model-Driven
           Engineering

    • Free pre-print version: Loading...

      Authors: Francisca Pérez;Jaime Font;Lorena Arcega;Carlos Cetina;
      Pages: 4553 - 4568
      Abstract: In Search-Based Software Engineering, more than 100 works have involved the human in the search process to obtain better results. However, the case where the human completely replaces the fitness function remains neglected. There is a good reason for that; no matter how intelligent the human is, humans cannot assess millions of candidate solutions as heuristics do. In this work, we study the influence of using the Human as the Fitness Function (HaFF) on the quality of the results. To do that, we focus on Search-Based Model-Driven Engineering (SBMDE) because inspecting models should require less human effort than inspecting code thanks to the abstraction of models. Therefore, we analyze the impact of HaFF in a real-world industrial case study of feature location in models. Furthermore, we also consider a reformulation operation (replacement) in the evaluation because a recent work reported that this operation significantly reduces the number of iterations required in comparison to the widespread crossover and mutation operations. The combination of HaFF and the reformulation operation (HaFF_R) improves the results of the best baseline by 0.15% in recall and 14.26% in precision. Analyzing the results, we learned how to better leverage HaFF_R, which increased the improvement with regard to the best baseline to 1.15% in recall and 20.05% in precision. HaFF_R significantly improves precision because humans are immune to the main limitations of the baselines: vocabulary mismatch and tacit knowledge. A focus group confirmed the acceptance of HaFF. These results are relevant for SBMDE because feature location is one of the main activities performed during maintenance and evolution. Our results, and what we learned from them, can also motivate and help other researchers to explore the benefits of HaFF. In fact, we provide a guideline that further discusses how to apply HaFF to other soft-are engineering problems.
      PubDate: Nov. 1 2022
      Issue No: Vol. 48, No. 11 (2022)
       
  • Automated Use-After-Free Detection and Exploit Mitigation: How Far Have We
           Gone'

    • Free pre-print version: Loading...

      Authors: Binfa Gui;Wei Song;Hailong Xiong;Jeff Huang;
      Pages: 4569 - 4589
      Abstract: C/C++ programs frequently encounter memory errors, such as Use-After-Free (UAF), buffer overflow, and integer overflow. Among these memory errors, UAF vulnerabilities are increasingly being exploited by attackers to disrupt critical software systems, leading to serious consequences, such as remote code execution and data breaches. Researchers have proposed dozens of approaches to detect UAFs in testing environments and to mitigate UAF exploit in production environments. However, to the best of our knowledge, no comprehensive studies have evaluated and compared these approaches. In this paper, we shed light on the current UAF detection and exploit mitigation approaches and provide a systematic overview, comprehensive comparison, and evaluation. Specifically, we evaluate the effectiveness and efficiency of publicly available UAF detection and exploit mitigation tools. The experimental results show that static UAF detectors are suitable for detecting intra-procedural UAFs but are not sufficient to detect inter-procedural UAFs in real-world programs. Dynamic UAF detectors are still the first choice for detecting inter-procedural UAFs. Our evaluation also demonstrates that the runtime overhead of existing UAF exploit mitigation tools is relatively stable whereas the memory overhead may vary dramatically with respect to different programs. Finally, we envision potential valuable future research directions.
      PubDate: Nov. 1 2022
      Issue No: Vol. 48, No. 11 (2022)
       
  • Leveraging Structure in Software Merge: An Empirical Study

    • Free pre-print version: Loading...

      Authors: Georg Seibt;Florian Heck;Guilherme Cavalcanti;Paulo Borba;Sven Apel;
      Pages: 4590 - 4610
      Abstract: Large-scale software development today relies heavily on version control systems facilitating distributed development of software projects. For the purpose of merging diverging versions of the code base, version control systems employ line-based merge algorithms, which are applicable to all text files. Structured merge algorithms have been proposed as an alternative to unstructured, line-based merging, with the goal of reducing the number of merge conflicts that have to be manually resolved by the developer. By leveraging the structure inherent in source code (i.e., by representing source code files in terms of abstract syntax trees instead of sequences of text lines), these algorithms are able to merge revisions in various situations (e.g., reordering of methods) that would cause conflicts when merged using an unstructured approach. However, merging abstract syntax trees is inherently more complex than merging sequences of text lines, which makes structured merge algorithms computationally more expensive than an unstructured merge. To reduce the runtime cost of structured merge algorithms, semistructured merge as well as combinations of different merge strategies were proposed. As such, we observe a range of increasingly structured merge algorithms, which feature different characteristics in terms of conflict resolution and runtime. The progressively increasing use of structure to avoid merge conflicts or to automate conflict resolution raises a number of questions: How is the correctness of the code resulting from a merge affected when employing structured merge algorithms' Which algorithm strikes the best balance between runtime, conflict resolution potential, and correctness of the merge result' For the first time, we evaluate a whole range of merge algorithms (from unstructured over semistructured to structured as well as combinations) by replaying merge commits in a controlled setting. We employ the test suite of the projects in question as an oracle for the -orrectness of the resulting code, triangulated by a thorough manual analysis. Using 7727 merge commits from 10 open-source projects, we find that combined strategies appear to be the best of both worlds: They resolve as many conflicts as structured merge at a significantly lower runtime per merge commit. Notably, structured merge strategies do cause more test failures, however, the increase is small.
      PubDate: Nov. 1 2022
      Issue No: Vol. 48, No. 11 (2022)
       
  • Aroc: An Automatic Repair Framework for On-Chain Smart Contracts

    • Free pre-print version: Loading...

      Authors: Hai Jin;Zeli Wang;Ming Wen;Weiqi Dai;Yu Zhu;Deqing Zou;
      Pages: 4611 - 4629
      Abstract: Ongoing smart contract attack events have seriously impeded the practical application of blockchain. Although lots of researches have been conducted, they mostly focus on off-chain vulnerability detection. However, smart contracts cannot be modified once they have been deployed on-chain, thus existing techniques cannot protect those deployed contracts from being attacked. To mitigate this problem, we propose a general smart contract repairer named Aroc, which can automatically patch vulnerable deployed contracts without changing the contract codes. The core insight of Aroc is to generate patch contracts to abort malicious transactions in advance. Taking the three most serious bug types (i.e., reentrancy, arithmetic bugs, and unchecked low-level checks) as examples, we present how Aroc automatically repairs them on-chain. We conduct abundant evaluations on four kinds of datasets to evaluate the effectiveness and efficiency of Aroc. In particular, Aroc can repair 95.95% of the vulnerable contracts with an average correctness ratio of 93.32%. Meanwhile, Aroc introduces acceptable additional overheads to smart contract users and blockchain miners. When compared with the state-of-the-art techniques, Aroc introduces either fewer execution overheads or contract codes.
      PubDate: Nov. 1 2022
      Issue No: Vol. 48, No. 11 (2022)
       
  • CAGFuzz: Coverage-Guided Adversarial Generative Fuzzing Testing for
           Image-Based Deep Learning Systems

    • Free pre-print version: Loading...

      Authors: Pengcheng Zhang;Bin Ren;Hai Dong;Qiyin Dai;
      Pages: 4630 - 4646
      Abstract: Deep Neural Network (DNN) driven technologies have been extensively employed in various aspects of our life. Nevertheless, the applied DNN always fails to detect erroneous behaviors, which may lead to serious problems. Several approaches have been proposed to enhance adversarial examples for automatically testing deep learning (DL) systems, such as image-based DL systems. However, the approaches contain the following two limitations. First, existing approaches only take into account small perturbations on adversarial examples, they design and generate adversarial examples for a certain particular DNN model. This might hamper the transferability of the examples for other DNN models. Second, they only use shallow features (e.g., pixel-level features) to judge the differences between the generated adversarial examples and the original examples. The deep features, which contain high-level semantic information, such as image object categories and scene semantics, are completely neglected. To address these two problems, we propose CAGFuzz, a Coverage-guided Adversarial Generative Fuzzing testing approach for image-based DL systems. CAGFuzz is able to generate adversarial examples for mainstream DNN models to discover their potential errors. First, we train an Adversarial Example Generator (AEG) based on general datasets. AEG only considers the data characteristics to alleviate the transferability problem. Second, we extract the deep features of the original and adversarial examples, and constrain the adversarial examples by cosine similarity to ensure that the deep features of the adversarial examples remain unchanged. Finally, we use the adversarial examples to retrain the models. Based on several standard datasets, we design a set of dedicated experiments to evaluate CAGFuzz. The experimental re-ults show that CAGFuzz can detect more hidden errors, enhance the accuracy of the target DNN models, and generate adversarial examples with higher transferability.
      PubDate: Nov. 1 2022
      Issue No: Vol. 48, No. 11 (2022)
       
  • AI-Enabled Automation for Completeness Checking of Privacy Policies

    • Free pre-print version: Loading...

      Authors: Orlando Amaral;Sallam Abualhaija;Damiano Torre;Mehrdad Sabetzadeh;Lionel C. Briand;
      Pages: 4647 - 4674
      Abstract: Technological advances in information sharing have raised concerns about data protection. Privacy policies contain privacy-related requirements about how the personal data of individuals will be handled by an organization or a software system (e.g., a web service or an app). In Europe, privacy policies are subject to compliance with the General Data Protection Regulation (GDPR). A prerequisite for GDPR compliance checking is to verify whether the content of a privacy policy is complete according to the provisions of GDPR. Incomplete privacy policies might result in large fines on violating organization as well as incomplete privacy-related software specifications. Manual completeness checking is both time-consuming and error-prone. In this paper, we propose AI-based automation for the completeness checking of privacy policies. Through systematic qualitative methods, we first build two artifacts to characterize the privacy-related provisions of GDPR, namely a conceptual model and a set of completeness criteria. Then, we develop an automated solution on top of these artifacts by leveraging a combination of natural language processing and supervised machine learning. Specifically, we identify the GDPR-relevant information content in privacy policies and subsequently check them against the completeness criteria. To evaluate our approach, we collected 234 real privacy policies from the fund industry. Over a set of 48 unseen privacy policies, our approach detected 300 of the total of 334 violations of some completeness criteria correctly, while producing 23 false positives. The approach thus has a precision of 92.9% and recall of 89.8%. Compared to a baseline that applies keyword search only, our approach results in an improvement of 24.5% in precision and 38% in recall.
      PubDate: Nov. 1 2022
      Issue No: Vol. 48, No. 11 (2022)
       
  • Systematic Evaluation and Usability Analysis of Formal Methods Tools for
           Railway Signaling System Design

    • Free pre-print version: Loading...

      Authors: Alessio Ferrari;Franco Mazzanti;Davide Basile;Maurice H. ter Beek;
      Pages: 4675 - 4691
      Abstract: Formal methods and supporting tools have a long record of success in the development of safety-critical systems. However, no single tool has emerged as the dominant solution for system design. Each tool differs from the others in terms of the modeling language used, its verification capabilities and other complementary features, and each development context has peculiar needs that require different tools. This is particularly problematic for the railway industry, in which formal methods are highly recommended by the norms, but no actual guidance is provided for the selection of tools. To guide companies in the selection of the most appropriate formal methods tools to adopt in their contexts, a clear assessment of the features of the currently available tools is required. To address this goal, this paper considers a set of 13 formal methods tools that have been used for the early design of railway systems, and it presents a systematic evaluation of such tools and a preliminary usability analysis of a subset of 7 tools, involving railway practitioners. The results are discussed considering the most desired aspects by industry and earlier related studies. While the focus is on the railway signaling domain, the overall methodology can be applied to similar contexts. Our study thus contributes with a systematic evaluation of formal methods tools and it shows that despite the poor graphical interfaces, usability and maturity of the tools are not major problems, as claimed by contributions from the literature. Instead, support for process integration is the most relevant obstacle for the adoption of most of the tools. Our contribution can be useful to R&D engineers from railway signaling companies and infrastructure managers, but also to tool developers and academic researchers alike.
      PubDate: Nov. 1 2022
      Issue No: Vol. 48, No. 11 (2022)
       
  • Evaluating and Improving Unified Debugging

    • Free pre-print version: Loading...

      Authors: Samuel Benton;Xia Li;Yiling Lou;Lingming Zhang;
      Pages: 4692 - 4716
      Abstract: Automated debugging techniques, including fault localization and program repair, have been studied for over a decade. However, the only existing connection between fault localization and program repair is that fault localization computes the potential buggy elements for program repair to patch. Recently, a pioneering work, ProFL, explored the idea of unified debugging to unify fault localization and program repair in the other direction for the first time to boost both areas. More specifically, ProFL utilizes the patch execution results from one state-of-the-art repair system, PraPR, to help improve state-of-the-art fault localization. In this way, ProFL not only improves fault localization for manual repair, but also extends the application scope of automated repair to all possible bugs (not only the small ratio of bugs that repair systems can automatically fix). However, ProFL only considers one program repair system (i.e., PraPR), and it is not clear how other existing program repair systems based on different designs contribute to unified debugging. In this work, we perform an extensive study of the unified debugging approach on 16 state-of-the-art program repair systems for the first time. Our initial experimental results on the widely studied Defects4J benchmark suite reveal various practical guidelines for unified debugging, such as (1) nearly all 16 studied repair systems positively contribute to unified debugging despite their varying repair capabilities, (2) repair systems targeting multi-edit patches can bring extraneous noise into unified debugging, (3) repair systems with more executed/plausible patches tend to perform better for unified debugging, (4) unified debugging effectiveness does not rely on the availability of correct patches from automated repair, and (5) we propose a new unified debugging technique, UniDebug++, which localizes over 20% more bugs within Top-1 than state-of-the-art unified debugging technique ProFL (evaluated against four Defects4J subjects). Furthermore, we conduct more comprehensive studies to extend the above experiments to make the following additional contributions: we (6) further perform an extensive study on 76.3% additional buggy versions from Defects4J (for Closure and Mockito) and confirm that UniDebug++ again outperforms ProFL by localizing 185 (out of 395 in total) bugs within Top-1, 14% more than ProFL, (7) investigate the impact of 33 SBFL formulae on unified debugging and observe that UniDebug++ consistently improves upon all formulae, e.g., 61% and 53% average improvement on MFR / MAR, (8) demonstrate that UniDebug++ can substantially boost state-of-the-art learning-based method-level fault localization techniques, (9) extend unified debugging to the statement level for first time and observe that UniDebug++ localizes 78 (out of 395 in total) bugs within Top-1 (22% more bugs than ProFL) and outperforms state-of-the-art learning-based fault localization techniques by 30%, and finally (10) propose a new technique, UniDebug+$^star$★, based on detailed patch statistics, to improve upon UniDebug++, e.g., further localizing up to 9% more bugs within Top-1 than UniDebug++.
      PubDate: Nov. 1 2022
      Issue No: Vol. 48, No. 11 (2022)
       
 
JournalTOCs
School of Mathematical and Computer Sciences
Heriot-Watt University
Edinburgh, EH14 4AS, UK
Email: journaltocs@hw.ac.uk
Tel: +00 44 (0)131 4513762
 


Your IP address: 18.232.56.9
 
Home (Search)
API
About JournalTOCs
News (blog, publications)
JournalTOCs on Twitter   JournalTOCs on Facebook

JournalTOCs © 2009-