当前期刊: arXiv - CS - Software Engineering Go to current issue    加入关注   
显示样式:        排序: 导出
我的关注
我的收藏
您暂时未登录!
登录
  • Learning and Suggesting Source Code Changes from Version History: A Systematic Review
    arXiv.cs.SE Pub Date : 2019-09-09
    Leandro Ungari Cayres; Bruno Santos de Lima; Rogério Eduardo Garcia

    Context: Software systems are in continuous evolution through source code changes to fixing bugs, adding new functionalities and improving the internal architecture. All these practices are recorded in the version history, which can be reused as an advantage in the development process. Objective: This paper aims to investigate approaches and techniques related to the learning of source code changes, since the change identification step, learning, and reuse in recommending strategies. Method: We conducted a systematic review related to primary studies about source code changes. The search approach identified 2410 studies, up to and including 2012, which resulted in a final set of 39 selected papers. We grouped the studies according to each established research question. This review investigates how source code changes, which were performed in the past of software, can support the improvement of the software project. Results: The majority of approaches and techniques have used repetitiveness behavior of source code changes to identify structural or metrics patterns in software repositories, trough the evaluation of sequences of versions. To extract the structural patterns, the approaches have used programming-by-example techniques to differencing source code changes. In quality metrics analysis, the studies have applied mainly complexity and object-oriented metrics. Conclusion: The main implication of this review is that source code changes as examples, to support the improvement of coding practice during the development process, in which we presented some relevant strategies to guide each step, since identifying until the suggesting of source code changes.

    更新日期:2020-01-17
  • Mermin Polynomials for Entanglement Evaluation in Grover's algorithm and Quantum Fourier Transform
    arXiv.cs.SE Pub Date : 2020-01-15
    Henri de Boutray; Hamza Jaffali; Frédéric Holweck; Alain Giorgetti; Pierre-Alain Masson

    The entanglement of a quantum system can be valuated using Mermin polynomials. This gives us a means to study entanglement evolution during the execution of quantum algorithms. We first consider Grover's quantum search algorithm, noticing that states during the algorithm are maximally entangled in the direction of a single constant state, which allows us to search for a single optimal Mermin operator and use it to evaluate entanglement through the whole execution of Grover's algorithm. Then the Quantum Fourier Transform is also studied with Mermin polynomials. A different optimal Mermin operator is searched at each execution step, since in this case there is no single direction of evolution. The results for the Quantum Fourier Transform are compared to results from a previous study of entanglement with Cayley hyperdeterminant. All our computations can be replayed thanks to a structured and documented open-source code that we provide.

    更新日期:2020-01-16
  • Learning Concise Models from Long Execution Traces
    arXiv.cs.SE Pub Date : 2020-01-15
    Natasha Yogananda Jeppu; Tom Melham; Daniel Kroening; John O'Leary

    Abstract models of system-level behaviour have applications in design exploration, analysis, testing and verification. We describe a new algorithm for automatically extracting useful models, as automata, from execution traces of a HW/SW system driven by software exercising a use-case of interest. Our algorithm leverages modern program synthesis techniques to generate predicates on automaton edges, succinctly describing system behaviour. It employs trace segmentation to tackle complexity for long traces. We learn concise models capturing transaction-level, system-wide behaviour--experimentally demonstrating the approach using traces from a variety of sources, including the x86 QEMU virtual platform and the Real-Time Linux kernel.

    更新日期:2020-01-16
  • Integrating the Common Variability Language with Multilanguage Annotations for Web Engineering
    arXiv.cs.SE Pub Date : 2020-01-15
    José Miguel Horcas Aguilera; Alejandro Cortiñas; Lidia Fuentes; Miguel R. Luaces

    Web applications development involves managing a high diversity of files and resources like code, pages or style sheets, implemented in different languages. To deal with the automatic generation of custom-made configurations of web applications, industry usually adopts annotation-based approaches despite the majority of studies encourage the use of composition-based approaches to implement Software Product Lines. Recent work tries to combine both approaches to get the complementary benefits. However, technological companies are reticent to adopt new development paradigms such as feature-oriented programming or aspect-oriented programming. Moreover, it is extremely difficult, or even impossible, to apply these programming models to web applications, mainly because of their multilingual nature, since their development involves multiple types of source code (Java, Groovy, JavaScript), templates (HTML, Markdown, XML), style sheet files (CSS and its variants, such as SCSS), and other files (JSON, YML, shell scripts). We propose to use the Common Variability Language as a composition-based approach and integrate annotations to manage fine grained variability of a Software Product Line for web applications. In this paper, we (i) show that existing composition and annotation-based approaches, including some well-known combinations, are not appropriate to model and implement the variability of web applications; and (ii) present a combined approach that effectively integrates annotations into a composition-based approach for web applications. We implement our approach and show its applicability with an industrial real-world system.

    更新日期:2020-01-16
  • Ready, set, Go! Data-race detection and the Go language
    arXiv.cs.SE Pub Date : 2019-10-28
    Daniel Schnetzer Fava; Martin Steffen

    Data races are often discussed in the context of lock acquisition and release, with race-detection algorithms routinely relying on vector clocks as a means of capturing the relative ordering of events from different threads. In this paper, we present a data-race detector for a language with channel communication as its sole synchronization primitive, and provide a semantics directly tied to the happens-before relation, thus forging the notion of vector clocks.

    更新日期:2020-01-16
  • Testing with Jupyter notebooks: NoteBook VALidation (nbval) plug-in for pytest
    arXiv.cs.SE Pub Date : 2020-01-13
    Hans Fangohr; Vidar Fauske; Thomas Kluyver; Maximilian Albert; Oliver Laslett; David Cortés-Ortuño; Marijan Beg; Min Ragan-Kelly

    The Notebook validation tool nbval allows to load and execute Python code from a Jupyter notebook file. While computing outputs from the cells in the notebook, these outputs are compared with the outputs saved in the notebook file, treating each cell as a test. Deviations are reported as test failures, with various configuration options available to control the behaviour. Application use cases include the validation of notebook-based documentation, tutorials and textbooks, as well as the use of notebooks as additional unit, integration and system tests for the libraries that are used in the notebook. Nbval is implemented as a plugin for the pytest testing software.

    更新日期:2020-01-15
  • A Case Study on Visualizing Large Spatial Datasets in a Web-based Map Viewer
    arXiv.cs.SE Pub Date : 2020-01-14
    Alejandro Cortiñas; Miguel R. Luaces; Tirso V. Rodeiro

    Lately, many companies are using Mobile Workforce Management technologies combined with information collected by sensors from mobile devices in order to improve their business processes. Even for small companies, the information that needs to be handled grows at a high rate, and most of the data collected have a geographic dimension. Being able to visualize this data in real-time within a map viewer is a very important deal for these companies. In this paper we focus on this topic, presenting a case study on visualizing large spatial datasets. Particularly, since most of the Mobile Workforce Management software is web-based, we propose a solution suitable for this environment.

    更新日期:2020-01-15
  • The geometry of syntax and semantics for directed file transformations
    arXiv.cs.SE Pub Date : 2020-01-14
    Steve Huntsman; Michael Robinson

    We introduce a conceptual framework that associates syntax and semantics with vertical and horizontal directions in principal bundles and related constructions. This notion of geometry corresponds to a mechanism for performing goal-directed file transformations such as "eliminate unsafe syntax" and suggests various engineering practices.

    更新日期:2020-01-15
  • Atomicity Checking in Linear Time using Vector Clocks
    arXiv.cs.SE Pub Date : 2020-01-14
    Umang Mathur; Mahesh Viswanathan

    Multi-threaded programs are challenging to write. Developers often need to reason about a prohibitively large number of thread interleavings to reason about the behavior of software. A non-interference property like atomicity can reduce this interleaving space by ensuring that any execution is equivalent to an execution where all atomic blocks are executed serially. We consider the well studied notion of conflict serializability for dynamically checking atomicity. Existing algorithms detect violations of conflict serializability by detecting cycles in a graph of transactions observed in a given execution. The size of such a graph can grow quadratically with the size of the trace making the analysis not scalable. In this paper, we present AeroDrome, a novel single pass linear time algorithm that uses vector clocks to detect violations of conflict serializability in an online setting. Experiments show that AeroDrome scales to traces with a large number of events with significant speedup.

    更新日期:2020-01-15
  • ReluDiff: Differential Verification of Deep Neural Networks
    arXiv.cs.SE Pub Date : 2020-01-10
    Brandon Paulsen; Jingbo Wang; Chao Wang

    As deep neural networks are increasingly being deployed in practice, their efficiency has become an important issue. While there are compression techniques for reducing the network's size, energy consumption and computational requirement, they only demonstrate empirically that there is no loss of accuracy, but lack formal guarantees of the compressed network, e.g., in the presence of adversarial examples. Existing verification techniques such as Reluplex, ReluVal, and DeepPoly provide formal guarantees, but they are designed for analyzing a single network instead of the relationship between two networks. To fill the gap, we develop a new method for differential verification of two closely related networks. Our method consists of a fast but approximate forward interval analysis pass followed by a backward pass that iteratively refines the approximation until the desired property is verified. We have two main innovations. During the forward pass, we exploit structural and behavioral similarities of the two networks to more accurately bound the difference between the output neurons of the two networks. Then in the backward pass, we leverage the gradient differences to more accurately compute the most beneficial refinement. Our experiments show that, compared to state-of-the-art verification tools, our method can achieve orders-of-magnitude speedup and prove many more properties than existing tools.

    更新日期:2020-01-14
  • The Next Generation of Human-Drone Partnerships: Co-Designing an Emergency Response System
    arXiv.cs.SE Pub Date : 2020-01-12
    Ankit AgrawalUniversity of Notre Dame, USA; Sophia AbrahamUniversity of Notre Dame, USA; Benjamin BurgerUniversity of Notre Dame, USA; Chichi ChristineUniversity of Notre Dame, USA; Luke FraserUniversity of Notre Dame, USA; John HoeksemaUniversity of Notre Dame, USA; Sara HwangUniversity of Notre Dame, USA; Elizabeth TravnikUniversity of Notre Dame, USA; Shreya KumarUniversity of Notre Dame, USA; Walter ScheirerUniversity of Notre Dame, USA; Jane Cleland-HuangUniversity of Notre Dame, USA; Michael VierhauserJohannes Keppler University, Linz, Austria; Ryan BauerSouth Bend Fire Department, South Bend, IN, USA; Steve CoxSouth Bend Fire Department, South Bend, IN, USA

    The use of semi-autonomous Unmanned Aerial Vehicles (UAV) to support emergency response scenarios, such as fire surveillance and search and rescue, offers the potential for huge societal benefits. However, designing an effective solution in this complex domain represents a "wicked design" problem, requiring a careful balance between trade-offs associated with drone autonomy versus human control, mission functionality versus safety, and the diverse needs of different stakeholders. This paper focuses on designing for situational awareness (SA) using a scenario-driven, participatory design process. We developed SA cards describing six common design-problems, known as SA demons, and three new demons of importance to our domain. We then used these SA cards to equip domain experts with SA knowledge so that they could more fully engage in the design process. We designed a potentially reusable solution for achieving SA in multi-stakeholder, multi-UAV, emergency response applications.

    更新日期:2020-01-14
  • Testing Database Engines via Pivoted Query Synthesis
    arXiv.cs.SE Pub Date : 2020-01-13
    Manuel Rigger; Zhendong Su

    Relational databases are used ubiquitously. They are managed by database management systems (DBMS), which allow inserting, modifying, and querying data using a domain-specific language called Structured Query Language (SQL). Popular DBMS have been extensively tested by fuzzers, which have been successful in finding crash bugs. However, approaches to finding logic bugs, such as when a DBMS computes an incorrect result set, have remained mostly untackled. Differential testing is an effective technique to test systems that support a common language by comparing the outputs of these systems. However, this technique is ineffective for DBMS, because each DBMS typically supports its own SQL dialect. To this end, we devised a novel and general approach that we have termed Pivoted Query Synthesis. The core idea of this approach is to automatically generate queries for which we ensure that they fetch a specific, randomly selected row, called the pivot row. If the DBMS fails to fetch the pivot row, the likely cause is a bug in the DBMS. We tested our approach on three widely-used and mature DBMS, namely SQLite, MySQL, and PostgreSQL. In total, we reported 123 bugs in these DBMS, 99 of which have been fixed or verified, demonstrating that the approach is highly effective and general. We expect that the wide applicability and simplicity of our approach will enable the improvement of robustness of many DBMS.

    更新日期:2020-01-14
  • Towards Integration-Level Test Case Generation Using Call Site Information
    arXiv.cs.SE Pub Date : 2020-01-13
    Pouria Derakhshanfar; Xavier Devroey; Annibale Panichella; Andy Zaidman; Arie van Deursen

    Search-based approaches have been used in the literature to automate the process of creating unit test cases. However, related work has shown that generated unit-tests with high code coverage could be ineffective, i.e., they may not detect all faults or kill all injected mutants. In this paper, we proposed an integration-level test case generator named CLING, that exploits the integration code of a pair of classes (caller and callee) that interact with one another through method calls. In particular, CLING generates integration-level test cases that maximize the Coupled Branches Criterion (CBC). CBC is a novel integration-level coverage criterion that measures how thoroughly a test suite exercises the interactions between callers and callees. We evaluate CLING on 140 pairs of classes from five different open-source Java projects. Our results show that (1) CLING generates test suites with high CBC coverage; (2) such generated suites can kill, on average, 10% mutants that are not killable by unit-level tests generated with EVOSUITE for the same classes; (3) CLING detects 29 integration faults that remain undetected when using automatically generated unit-level test suites.

    更新日期:2020-01-14
  • Formal specification of a security framework for smart contracts
    arXiv.cs.SE Pub Date : 2020-01-13
    Mikhail Mandrykin; Jake O'Shannessy; Jacob Payne; Ilya Shchepetkov

    As smart contracts are growing in size and complexity, it becomes harder and harder to ensure their correctness and security. Due to the lack of isolation mechanisms a single mistake or vulnerability in the code can bring the whole system down, and due to this smart contract upgrades can be especially dangerous. Traditional ways to ensure the security of a smart contract, including DSLs, auditing and static analysis, are used before the code is deployed to the blockchain, and thus offer no protection after the deployment. After each upgrade the whole code need to be verified again, which is a difficult and time-consuming process that is prone to errors. To address these issues a security protocol and framework for smart contracts called Cap9 was developed. It provides developers the ability to perform upgrades in a secure and robust manner, and improves isolation and transparency through the use of a low level capability-based security model. We have used Isabelle/HOL to develop a formal specification of the Cap9 framework and prove its consistency. The paper presents a refinement-based approach that we used to create the specification, as well as discussion of some encountered difficulties during this process.

    更新日期:2020-01-14
  • A quantum-classical cloud platform optimized for variational hybrid algorithms
    arXiv.cs.SE Pub Date : 2020-01-13
    Peter J. Karalekas; Nikolas A. Tezak; Eric C. Peterson; Colm A. Ryan; Marcus P. da Silva; Robert S. Smith

    In order to support near-term applications of quantum computing, a new compute paradigm has emerged--the quantum-classical cloud--in which quantum computers (QPUs) work in tandem with classical computers (CPUs) via a shared cloud infrastructure. In this work, we enumerate the architectural requirements of a quantum-classical cloud platform, and present a framework for benchmarking its runtime performance. In addition, we walk through two platform-level enhancements, parametric compilation and active qubit reset, that specifically optimize a quantum-classical architecture to support variational hybrid algorithms (VHAs), the most promising applications of near-term quantum hardware. Finally, we show that integrating these two features into the Rigetti Quantum Cloud Services (QCS) platform results in considerable improvements to the latencies that govern algorithm runtime.

    更新日期:2020-01-14
  • SMT-Friendly Formalization of the Solidity Memory Model
    arXiv.cs.SE Pub Date : 2020-01-09
    Ákos Hajdu; Dejan Jovanović

    Solidity is the dominant programming language for Ethereum smart contracts. This paper presents a high-level formalization of the Solidity language with a focus on the memory model. The presented formalization covers all features of the language related to managing state and memory. In addition, the formalization we provide is effective: all but few features can be encoded in the quantifier-free fragment of standard SMT theories. This enables precise and efficient reasoning about the state of smart contracts written in Solidity. The formalization is implemented in the solc-verify verifier and we provide an extensive set of tests that covers the breadth of the required semantics. We also provide an evaluation on the test set that validates the semantics and shows the novelty of the approach compared to other Solidity-level contract analysis tools.

    更新日期:2020-01-13
  • The Effectiveness of Supervised Machine Learning Algorithms in Predicting Software Refactoring
    arXiv.cs.SE Pub Date : 2020-01-10
    Maurício Aniche; Erick Maziero; Rafael Durelli; Vinicius Durelli

    Refactoring is the process of changing the internal structure of software to improve its quality without modifying its external behavior. Empirical studies have repeatedly shown that refactoring has a positive impact on the understandability and maintainability of software systems. However, before carrying out refactoring activities, developers need to identify refactoring opportunities. Currently, refactoring opportunity identification heavily relies on developers' expertise and intuition. In this paper, we investigate the effectiveness of machine learning algorithms in predicting software refactorings. More specifically, we train six different machine learning algorithms (i.e., Logistic Regression, Naive Bayes, Support Vector Machine, Decision Trees, Random Forest, and Neural Network) with a dataset comprising over two million refactorings from 11,149 real-world projects from the Apache, F-Droid, and GitHub ecosystems. The resulting models predict 20 different refactorings at class, method, and variable-levels with an accuracy often higher than 90%. Our results show that (i) Random Forests are the best models for predicting software refactoring, (ii) process and ownership metrics seem to play a crucial role in the creation of better models, and (iii) models generalize well in different contexts.

    更新日期:2020-01-13
  • Agile Risk Management for Multi-Cloud Software Development
    arXiv.cs.SE Pub Date : 2020-01-10
    Victor Muntés-Mulero; Oscar Ripolles; Smrati Gupta; Jacek Dominiak; Eric Willeke; Peter Matthews; Balázs Somosköi

    Industry in all sectors is experiencing a profound digital transformation that puts software at the core of their businesses. In order to react to continuously changing user requirements and dynamic markets, companies need to build robust workflows that allow them to increase their agility in order to remain competitive. This increasingly rapid transformation, especially in domains like IoT or Cloud computing, poses significant challenges to guarantee high quality software, since dynamism and agile short-term planning reduce the ability to detect and manage risks. In this paper, we describe the main challenges related to managing risk in agile software development, building on the experience of more than 20 agile coaches operating continuously for 15 years with hundreds of teams in industries in all sectors. We also propose a framework to manage risks that considers those challenges and supports collaboration, agility, and continuous development. An implementation of that framework is then described in a tool that handles risks and mitigation actions associated with the development of multi-cloud applications. The methodology and the tool have been validated by a team of evaluators that were asked to consider its use in developing an urban smart mobility service and an airline flight scheduling system.

    更新日期:2020-01-13
  • Optimizing the Efficiency of Accelerated Reliability Testing for the Internet Router Motherboard
    arXiv.cs.SE Pub Date : 2020-01-06
    Hanxiao Zhang; Shouzhou Liu; Yan-Fu Li

    With the rapid development of internet Router, the complexity of its mainboard has been growing dramatically. The high reliability requirement renders the number of testing cases increasing exponentially, which becomes the bottleneck that prevents further elevation of the production efficiency. In this work, we develop a novel optimization method of two major steps to largely reduce the testing time and increase the testing efficiency. In the first step, it optimizes the selection of test cases given the required amount of testing time reduction while ensuring the coverage of failures. In the second step, selected test cases are optimally scheduled to maximize the efficiency of mainboard testing. A numerical experiment is investigated to illustrate the effectiveness of the proposed methods. The results show that the optimal subset of the test cases can be selected satisfying the 10% testing time reduction requirement, and the effectiveness index of the scheduled sequence can be improved by more than 75% with test case sequencing. Moreover, our method can self-adjust to the new failure data, which realizes the automatic configuration of board test cases.

    更新日期:2020-01-13
  • What are the Actual Flaws in Important Smart Contracts (and How Can We Find Them)?
    arXiv.cs.SE Pub Date : 2019-11-18
    Alex Groce; Josselin Feist; Gustavo Grieco; Michael Colburn

    An important problem in smart contract security is understanding the likelihood and criticality of discovered, or potential, weaknesses in contracts. In this paper we provide a summary of Ethereum smart contract audits performed for 23 professional stakeholders, avoiding the common problem of reporting issues mostly prevalent in low-quality contracts. These audits were performed at a leading company in blockchain security, using both open-source and proprietary tools, as well as human code analysis performed by professional security engineers. We categorize 246 individual defects, making it possible to compare the severity and frequency of different vulnerability types, compare smart contract and non-smart contract flaws, and to estimate the efficacy of automated vulnerability detection approaches.

    更新日期:2020-01-13
  • Killing Stubborn Mutants with Symbolic Execution
    arXiv.cs.SE Pub Date : 2020-01-09
    Thierry Titcheu Chekam; Mike Papadakis; Maxime Cordy; Yves Le Traon

    We introduce SeMu, a Dynamic Symbolic Execution technique that generates test inputs capable of killing stubborn mutants (killable mutants that remain undetected after a reasonable amount of testing). SeMu aims at mutant propagation (triggering erroneous states to the program output) by incrementally searching for divergent program behaviours between the original and the mutant versions. We model the mutant killing problem as a symbolic execution search within a specific area in the programs' symbolic tree. In this framework, the search area is defined and controlled by parameters that allow scalable and cost-effective mutant killing. We integrate SeMu in KLEE and experimented with Coreutils (a benchmark frequently used in symbolic execution studies). Our results show that our modelling plays an important role in mutant killing. Perhaps more importantly, our results also show that, within a two-hour time limit, SeMu kills 37% of the stubborn mutants, where KLEE kills none and where the mutant infection strategy (strategy suggested by previous research) kills 17%.

    更新日期:2020-01-10
  • Logram: Efficient Log Parsing Using n-Gram Dictionaries
    arXiv.cs.SE Pub Date : 2020-01-07
    Hetong DaiConcordia University; Heng LiQueen's University; Weiyi ShangConcordia University; Tse-Hsun ChenConcordia University; Che-Shao ChenConcordia University

    Software systems usually record important runtime information in their logs. Logs help practitioners understand system runtime behaviors and diagnose field failures. As logs are usually very large in size, automated log analysis is needed to assist practitioners in their software operation and maintenance efforts. Typically, the first step of automated log analysis is log parsing, i.e., converting unstructured raw logs into structured data. However, log parsing is challenging, because logs are produced by static templates in the source code (i.e., logging statements) yet the templates are usually inaccessible when parsing logs. Prior work proposed automated log parsing approaches that have achieved high accuracy. However, as the volume of logs grows rapidly in the era of cloud computing, efficiency becomes a major concern in log parsing. In this work, we propose an automated log parsing approach, Logram, which leverages n-gram dictionaries to achieve efficient log parsing. We evaluated Logram on 16 public log datasets and compared Logram with five state-of-the-art log parsing approaches. We found that Logram achieves a similar parsing accuracy to the best existing approaches while outperforms these approaches in efficiency (i.e., 1.8 to 5.1 times faster than the second fastest approaches). Furthermore, we deployed Logram on Spark and we found that Logram scales out efficiently with the number of Spark nodes (e.g., with near-linear scalability) without sacrificing parsing accuracy. In addition, we demonstrated that Logram can support effective online parsing of logs, achieving similar parsing results and efficiency with the offline mode.

    更新日期:2020-01-10
  • Time Pressure in Software Engineering: A Systematic Review
    arXiv.cs.SE Pub Date : 2019-01-17
    Miikka Kuutila; Mika Mäntylä; Umar Farooq; Maëlick Claes

    Large project overruns and overtime work have been reported in the software industry, resulting in additional expense for companies and personal issues for developers. The present work aims to provide an overview of studies related to time pressure in software engineering; specifically, existing definitions, possible causes, and metrics relevant to time pressure were collected, and a mapping of the studies to software processes and approaches was performed. Moreover, we synthesize results of existing quantitative studies on the effects of time pressure on software development, and offer practical takeaways for practitioners and researchers, based on empirical evidence. Our search strategy examined 5,414 sources, found through repository searches and snowballing. Applying inclusion and exclusion criteria resulted in the selection of 102 papers, which made relevant contributions related to time pressure in software engineering. The majority of high quality studies report increased productivity and decreased quality under time pressure. Frequent categories of studies focus on quality assurance, cost estimation, and process simulation. It appears that time pressure is usually caused by errors in cost estimation. The effect of time pressure is most often identified during software quality assurance. The majority of empirical studies report increased productivity under time pressure, while the most cost estimation and process simulation models assume that compressing the schedule increases the total needed hours. We also find evidence of the mediating effect of knowledge on the effects of time pressure, and that tight deadlines impact tasks with an algorithmic nature more severely. Future research should better contextualize quantitative studies to account for the existing conflicting results and to provide an understanding of situations when time pressure is either beneficial or harmful.

    更新日期:2020-01-10
  • Learning to Encode and Classify Test Executions
    arXiv.cs.SE Pub Date : 2020-01-08
    Foivos Tsimpourlas; Ajitha Rajan; Miltiadis Allamanis

    The challenge of automatically determining the correctness of test executions is referred to as the test oracle problem and is one of the key remaining issues for automated testing. The goal in this paper is to solve the test oracle problem in a way that is general, scalable and accurate. To achieve this, we use supervised learning over test execution traces. We label a small fraction of the execution traces with their verdict of pass or fail. We use the labelled traces to train a neural network (NN) model to learn to distinguish runtime patterns for passing versus failing executions for a given program. Our approach for building this NN model involves the following steps, 1. Instrument the program to record execution traces as sequences of method invocations and global state, 2. Label a small fraction of the execution traces with their verdicts, 3. Designing a NN component that embeds information in execution traces to fixed length vectors, 4. Design a NN model that uses the trace information for classification, 5. Evaluate the inferred classification model on unseen execution traces from the program. We evaluate our approach using case studies from different application domains: 1. Module from Ethereum Blockchain, 2. Module from PyTorch deep learning framework, 3. Microsoft SEAL encryption library components, 4. Sed stream editor, 5. Value pointer library and 6. Nine network protocols from Linux packet identifier, L7-Filter. We found the classification models for all subject programs resulted in high precision, recall and specificity, over 95%, while only training with an average 9% of the total traces. Our experiments show that the proposed neural network model is highly effective as a test oracle and is able to learn runtime patterns to distinguish passing and failing test executions for systems and tests from different application domains.

    更新日期:2020-01-09
  • Comparing Constraints Mined From Execution Logs to Understand Software Evolution
    arXiv.cs.SE Pub Date : 2020-01-08
    Thomas Krismayer; Michael Vierhauser; Rick Rabiser; Paul Grünbacher

    Complex software systems evolve frequently, e.g., when introducing new features or fixing bugs during maintenance. However, understanding the impact of such changes on system behavior is often difficult. Many approaches have thus been proposed that analyze systems before and after changes, e.g., by comparing source code, model-based representations, or system execution logs. In this paper, we propose an approach for comparing run-time constraints, synthesized by a constraint mining algorithm, based on execution logs recorded before and after changes. Specifically, automatically mined constraints define the expected timing and order of recurring events and the values of data elements attached to events. Our approach presents the differences of the mined constraints to users, thereby providing a higher-level view on software evolution and supporting the analysis of the impact of changes on system behavior. We present a motivating example and a preliminary evaluation based on a cyber-physical system controlling unmanned aerial vehicles. The results of our preliminary evaluation show that our approach can help to analyze changed behavior and thus contributes to understanding software evolution.

    更新日期:2020-01-09
  • Questioning the AI: Informing Design Practices for Explainable AI User Experiences
    arXiv.cs.SE Pub Date : 2020-01-08
    Q. Vera Liao; Daniel Gruen; Sarah Miller

    A surge of interest in explainable AI (XAI) has led to a vast collection of algorithmic work on the topic. While many recognize the necessity to incorporate explainability features in AI systems, how to address real-world user needs for understanding AI remains an open question. By interviewing 20 UX and design practitioners working on various AI products, we seek to identify gaps between the current XAI algorithmic work and practices to create explainable AI products. To do so, we develop an algorithm-informed XAI question bank in which user needs for explainability are represented as prototypical questions users might ask about the AI, and use it as a study probe. Our work contributes insights into the design space of XAI, informs efforts to support design practices in this space, and identifies opportunities for future XAI work. We also provide an extended XAI question bank and discuss how it can be used for creating user-centered XAI.

    更新日期:2020-01-09
  • Comparing Python, Go, and C++ on the N-Queens Problem
    arXiv.cs.SE Pub Date : 2020-01-08
    Pascal Fua; Krzysztof Lis

    Python currently is the dominant language in the field of Machine Learning but is often criticized for being slow to perform certain tasks. In this report, we use the well-known $N$-queens puzzle as a benchmark to show that once compiled using the Numba compiler it becomes competitive with C++ and Go in terms of execution speed while still allowing for very fast prototyping. This is true of both sequential and parallel programs. In most cases that arise in an academic environment, it therefore makes sense to develop in ordinary Python, identify computational bottlenecks, and use Numba to remove them.

    更新日期:2020-01-09
  • Architecting Safe Automated Driving with Legacy Platforms
    arXiv.cs.SE Pub Date : 2019-12-10
    Naveen Mohan

    Modern vehicles have electrical architectures whose complexity grows year after year due to feature growth corresponding to customer expectations. The latest of the expectations, automation of the dynamic driving task however, is poised to bring about some of the largest changes seen so far. In one fell swoop, not only does required functionality for automated driving drastically increase the system complexity, it also removes the fall-back of the human driver who is usually relied upon to handle unanticipated failures after the fact. The need to architect thus requires a greater rigour than ever before, to maintain the level of safety that has been associated with the automotive industry. The work that is part of this thesis has been conducted, in close collaboration with our industrial partner Scania CV AB, within the Vinnova FFI funded project ARCHER. This thesis aims to provide a methodology for architecting during the concept phase of development, using industrial practices and principles including those from safety standards such as ISO 26262. The main contributions of the thesis are in two areas. The first area i.e. Part A contributes, (i) an analysis of the challenges of architecting automated driving, and serves as a motivation for the approach taken in the rest of this thesis, i.e. Part B where the contributions include, (ii) a definition of a viewpoint for functional safety according to the definitions of ISO 42010, (iii) a method to systematically extract information from legacy components and (iv) a process to use legacy information and architect in the presence of uncertainty to provide a work product, the Preliminary Architectural Assumptions (PAA), as required by ISO 26262. The contributions of Part B together comprise a methodology to architect the PAA.

    更新日期:2020-01-09
  • Perception and Acceptance of an Autonomous Refactoring Bot
    arXiv.cs.SE Pub Date : 2020-01-08
    Marvin Wyrich; Regina Hebig; Stefan Wagner; Riccardo Scandariato

    The use of autonomous bots for automatic support in software development tasks is increasing. In the past, however, they were not always perceived positively and sometimes experienced a negative bias compared to their human counterparts. We conducted a qualitative study in which we deployed an autonomous refactoring bot for 41 days in a student software development project. In between and at the end, we conducted semi-structured interviews to find out how developers perceive the bot and whether they are more or less critical when reviewing the contributions of a bot compared to human contributions. Our findings show that the bot was perceived as a useful and unobtrusive contributor, and developers were no more critical of it than they were about their human colleagues, but only a few team members felt responsible for the bot.

    更新日期:2020-01-09
  • On the Evaluation of Intelligence Process Automation
    arXiv.cs.SE Pub Date : 2020-01-08
    Deborah Ferreira; Julia Rozanova; Krishna Dubba; Dell Zhang; Andre Freitas

    Intelligent Process Automation (IPA) is emerging as a sub-field of AI to support the automation of long-tail processes which requires the coordination of tasks across different systems. So far, the field of IPA has been largely driven by systems and use cases, lacking a more formal definition of the task and its assessment. This paper aims to address this gap by providing a formalisation of IPA and by proposing specific metrics to support the empirical evaluation of IPA systems. This work also compares and contrasts IPA against related tasks such as end-user programming and program synthesis.

    更新日期:2020-01-09
  • Contextual Documentation Referencing on Stack Overflow
    arXiv.cs.SE Pub Date : 2019-06-11
    Sebastian Baltes; Christoph Treude; Martin P. Robillard

    Software engineering is knowledge-intensive and requires software developers to continually search for knowledge, often on community question answering platforms such as Stack Overflow. Such information sharing platforms do not exist in isolation, and part of the evidence that they exist in a broader software documentation ecosystem is the common presence of hyperlinks to other documentation resources found in forum posts. With the goal of helping to improve the information diffusion between Stack Overflow and other documentation resources, we conducted a study to answer the question of how and why documentation is referenced in Stack Overflow threads. We sampled and classified 759 links from two different domains, regular expressions and Android development, to qualitatively and quantitatively analyze the links' context and purpose, including attribution, awareness, and recommendations. We found that links on Stack Overflow serve a wide range of distinct purposes, ranging from citation links attributing content copied into Stack Overflow, over links clarifying concepts using Wikipedia pages, to recommendations of software components and resources for background reading. This purpose spectrum has major corollaries, including our observation that links to documentation resources are a reflection of the information needs typical to a technology domain. We contribute a framework and method to analyze the context and purpose of Stack Overflow links, a public dataset of annotated links, and a description of five major observations about linking practices on Stack Overflow. We further point to potential tool support to enhance the information diffusion between Stack Overflow and other documentation resources.

    更新日期:2020-01-09
  • Vis-a-Vis: Visual Exploration of Visualization Source Code Evolution
    arXiv.cs.SE Pub Date : 2020-01-04
    Fabian Bolte; Stefan Bruckner

    Developing an algorithm for a visualization prototype often involves the direct comparison of different development stages and design decisions, and even minor modifications may dramatically affect the results. While existing development tools provide visualizations for gaining general insight into performance and structural aspects of the source code, they neglect the central importance of result images unique to graphical algorithms. In this paper, we present a novel approach that enables visualization programmers to simultaneously explore the evolution of their algorithm during the development phase together with its corresponding visual outcomes by providing an automatically updating meta visualization. Our interactive system allows for the direct comparison of all development states on both the visual and the source code level, by providing easy to use navigation and comparison tools. The on-the-fly construction of difference images, source code differences, and a visual representation of the source code structure further enhance the user's insight into the states' interconnected changes over time. Our solution is accessible via a web-based interface that provides GPU-accelerated live execution of C++ and GLSL code, as well as supporting a domain-specific programming language for scientific visualization.

    更新日期:2020-01-08
  • Mind the Gap: Trade-Offs between Distributed Ledger Technology Characteristics
    arXiv.cs.SE Pub Date : 2019-06-03
    Niclas Kannengießer; Sebastian Lins; Tobias Dehling; Ali Sunyaev

    When developing applications on Distributed Ledger Technology (DLT), a crucial decision is the selection of a suitable DLT design (e.g., Ethereum) because it is hard to change the underlying DLT design post hoc. To facilitate selection of suitable DLT designs, we review DLT characteristics and identify trade-offs between them. Furthermore, we assess how DLT designs account for these trade-offs and we develop archetypes for DLT designs that cater to specific quality requirements. The main purpose of our article is to introduce scientific and practical audiences to the intricacies of DLT designs and to support development of viable applications on DLT.

    更新日期:2020-01-08
  • Unleashing the Potentials of Immersive Augmented Reality for Software Engineering
    arXiv.cs.SE Pub Date : 2020-01-05
    Leonel Merino; Mircea Lungu; Christoph Seidl

    In immersive augmented reality (IAR), users can wear a head-mounted display to see computer-generated images superimposed to their view of the world. IAR was shown to be beneficial across several domains, e.g., automotive, medicine, gaming and engineering, with positive impacts on, e.g., collaboration and communication. We think that IAR bears a great potential for software engineering but, as of yet, this research area has been neglected. In this vision paper, we elicit potentials and obstacles for the use of IAR in software engineering. We identify possible areas that can be supported with IAR technology by relating commonly discussed IAR improvements to typical software engineering tasks. We further demonstrate how innovative use of IAR technology may fundamentally improve typical activities of a software engineer through a comprehensive series of usage scenarios outlining practical application. Finally, we reflect on current limitations of IAR technology based on our scenarios and sketch research activities necessary to make our vision a reality. We consider this paper to be relevant to academia and industry alike in guiding the steps to innovative research and applications for IAR in software engineering.

    更新日期:2020-01-07
  • Cross-Dataset Design Discussion Mining
    arXiv.cs.SE Pub Date : 2020-01-06
    Alvi Mahadi; Karan Tongay; Neil A. Ernst

    Being able to identify software discussions that are primarily about design, which we call design mining, can improve documentation and maintenance of software systems. Existing design mining approaches have good classification performance using natural language processing (NLP) techniques, but the conclusion stability of these approaches is generally poor. A classifier trained on a given dataset of software projects has so far not worked well on different artifacts or different datasets. In this study, we replicate and synthesize these earlier results in a meta-analysis. We then apply recent work in transfer learning for NLP to the problem of design mining. However, for our datasets, these deep transfer learning classifiers perform no better than less complex classifiers. We conclude by discussing some reasons behind the transfer learning approach to design mining.

    更新日期:2020-01-07
  • Runtime Verification of Linux Kernel Security Module
    arXiv.cs.SE Pub Date : 2020-01-06
    Denis Efremov; Ilya Shchepetkov

    The Linux kernel is one of the most important Free/Libre Open Source Software (FLOSS) projects. It is installed on billions of devices all over the world, which process various sensitive, confidential or simply private data. It is crucial to establish and prove its security properties. This work-in-progress paper presents a method to verify the Linux kernel for conformance with an abstract security policy model written in the Event-B specification language. The method is based on system call tracing and aims at checking that the results of system call execution do not lead to accesses that violate security policy requirements. As a basis for it, we use an additional Event-B specification of the Linux system call interface that is formally proved to satisfy all the requirements of the security policy model. In order to perform the conformance checks we use it to reproduce intercepted system calls and verify accesses.

    更新日期:2020-01-07
  • Using CEF Digital Service Infrastructures in the Smart4Health Project for the Exchange of Electronic Health Records
    arXiv.cs.SE Pub Date : 2020-01-06
    Tamara Slosarek; Attila Wohlbrandt; Erwin Böttinger

    The Smart4Health (S4H) software application will empower EU citizens to manage, analyze, and exchange their aggregated electronic health data. In order to provide such a service, basic features are needed to ensure usability, reliability, and trust. The CEF building blocks implement such functionalities while complying with EU regulations. This report examines the current status and applicability of the CEF building blocks for the envisioned S4H software application. The major findings of the report are that (1) most CEF building blocks are currently not ready to be applied without further implementation efforts and (2) the S4H-specific use cases and user needs, to which the single CEF building blocks correspond, must be clarified. Open questions raised in this report need to be answered before a clear analysis can be made. Moreover, the functionalities of CEF building blocks aim at the matured product, while for the first version of the S4H software application basic implementations suffice. Still, concepts need to be elaborated of how the sample implementation of CEF building blocks or suitable alternative applications can be included into the system at a later point.

    更新日期:2020-01-07
  • Why and How to Balance Alignment and Diversity of Requirements Engineering Practices in Automotive
    arXiv.cs.SE Pub Date : 2020-01-06
    Rebekka Wohlrab; Eric Knauss; Patrizio Pelliccione

    In large-scale automotive companies, various requirements engineering (RE) practices are used across teams. RE practices manifest in Requirements Information Models (RIM) that define what concepts and information should be captured for requirements. Collaboration of practitioners from different parts of an organization is required to define a suitable RIM that balances support for diverse practices in individual teams with the alignment needed for a shared view and team support on system level. There exists no guidance for this challenging task. This paper presents a mixed methods study to examine the role of RIMs in balancing alignment and diversity of RE practices in four automotive companies. Our analysis is based on data from systems engineering tools, 11 semi-structured interviews, and a survey to validate findings and suggestions. We found that balancing alignment and diversity of RE practices is important to consider when defining RIMs. We further investigated enablers for this balance and actions that practitioners take to achieve it. From these factors, we derived and evaluated recommendations for managing RIMs in practice that take into account the lifecycle of requirements and allow for diverse practices across sub-disciplines in early development, while enforcing alignment of requirements that are close to release.

    更新日期:2020-01-07
  • The SmartSHARK Ecosystem for Software Repository Mining
    arXiv.cs.SE Pub Date : 2020-01-06
    Alexander Trautsch; Fabian Trautsch; Steffen Herbold; Benjamin Ledel; Jens Grabowski

    Software repository mining is the foundation for many empirical software engineering studies. The collection and analysis of detailed data can be challenging, especially if data shall be shared to enable replicable research and open science practices. SmartSHARK is an ecosystem that supports replicable and reproducible research based on software repository mining.

    更新日期:2020-01-07
  • Composition, Cooperation, and Coordination of Computational Systems
    arXiv.cs.SE Pub Date : 2016-02-23
    Johannes Reich

    In this paper I elaborated on the idea of David Harel and Amir Pnueli to distinguish systems according to their compositional behavior. The basic idea is to assume a functional relation between state functions as the system-constituting property, allowing to partition the world into a system and a rest. The obvious idea to base the composition of systems on the concept of computable functions and their compositional behavior leads to supersystem formation by composing simple and recursive systems. But this approach does not allow to account adequately for systems that interact with many other systems in a stateful and nondeterministic way which is why I introduce the concept of interactivity and cooperation. In order to describe interactive systems satisfactorily, a balance is needed between the representation of their relationship to all the other systems and what happens within the systems. I thus introduce the complementary descriptions of external interactions and internal coordination, both based on a role concept in the sense of a projection of a system onto its interactions. Beside the interesting distinction between composition, cooperation and coordination, the presented approach also fits well with other rather well known concepts. First the concept of components and interfaces. Components become systems with a well defined compositional behavior were the interface concept captures both, the transformational and the compositional behavior of a system in its interactions. Another tightly related concept is that of decisions and games. I introduce the concept of decisions as an additional internal input alphabet in order to determine nondeterministic interactions and thus fictitiously assume a system function where we actually do not have the knowledge to do so. Thus, the close relationship between protocols and games becomes obvious.

    更新日期:2020-01-07
  • A Study of Bug Resolution Characteristics in Popular Programming Languages
    arXiv.cs.SE Pub Date : 2018-01-03
    Jie M. Zhang; Feng Li; Dan Hao; Meng Wang; Hao Tang; Lu Zhang; Mark Harman

    This paper presents a large-scale study that investigates the bug resolution characteristics among popular Github projects written in different programming languages. We explore correlations but, of course, we cannot infer causation. Specifically, we analyse bug resolution data from approximately 70 million Source Line of Code, drawn from 3 million commits to 600 GitHub projects, primarily written in 10 programming languages. We find notable variations in apparent bug resolution time and patch (fix) size. While interpretation of results from such large-scale empirical studies is inherently difficult, we believe that the differences in medians are sufficiently large to warrant further investigation, replication, re-analysis and follow up research. For example, in our corpus, the median apparent bug resolution time (elapsed time from raise to resolve) for Ruby was 4X that for Go and 2.5X for Java. We also found that patches tend to touch more files for the corpus of strongly typed and for statically typed programs. However, we also found evidence for a lower elapsed resolution time for bug resolution committed to projects constructed from statically typed languages. These findings, if replicated in subsequent follow on studies, may shed further empirical light on the debate about the importance of static typing.

    更新日期:2020-01-07
  • The Evolution of Empirical Methods in Software Engineering
    arXiv.cs.SE Pub Date : 2019-12-24
    Michael Felderer; Guilherme Horta Travassos

    Empirical methods like experimentation have become a powerful means to drive the field of software engineering by creating scientific evidence on software development, operation, and maintenance, but also by supporting practitioners in their decision making and learning. Today empirical methods are fully applied in software engineering. However, they have developed in several iterations since the 1960s. In this chapter we tell the history of empirical software engineering and present the evolution of empirical methods in software engineering in five iterations, i.e., (1) mid-1960s to mid-1970s, (2) mid-1970s to mid-1980s, (3) mid-1980s to end of the 1990s, (4) the 2000s, and (5) the 2010s. We present the five iterations of the development of empirical software engineering mainly from a methodological perspective and additionally take key papers, venues, and books, which are covered in chronological order in a separate section on recommended further readings, into account. We complement our presentation of the evolution of empirical software engineering by presenting the current situation and an outlook in Sect. 4 and the available books on empirical software engineering. Furthermore, based on the chapters covered in this book we discuss trends on contemporary empirical methods in software engineering related to the plurality of research methods, human factors, data collection and processing, aggregation and synthesis of evidence, and impact of software engineering research.

    更新日期:2020-01-07
  • CryptoExplorer: An Interactive Web Platform Supporting Secure Use of Cryptography APIs
    arXiv.cs.SE Pub Date : 2020-01-03
    Mohammadreza Hazhirpasand; Mohammad Ghafari; Oscar Nierstrasz

    Research has shown that cryptographic APIs are hard to use. Consequently, developers resort to using code examples available in online information sources that are often not secure. We have developed a web platform, named CryptoExplorer, stocked with numerous real-world secure and insecure examples that developers can explore to learn how to use cryptographic APIs properly. This platform currently provides 3,263 secure uses, and 5,897 insecure uses of Java Cryptography Architecture mined from 2,324 Java projects on GitHub. A preliminary study shows that CryptoExplorer provides developers with secure crypto API use examples instantly, developers can save time compared to searching on the internet for such examples, and they learn to avoid using certain algorithms in APIs by studying misused API examples. We have a pipeline to regularly mine more projects, and, on request, we offer our dataset to researchers.

    更新日期:2020-01-06
  • Towards Intelligent Robotic Process Automation for BPMers
    arXiv.cs.SE Pub Date : 2020-01-03
    Simone Agostinelli; Andrea Marrella; Massimo Mecella

    Robotic Process Automation (RPA) is a fast-emerging automation technology that sits between the fields of Business Process Management (BPM) and Artificial Intelligence (AI), and allows organizations to automate high volume routines. RPA tools are able to capture the execution of such routines previously performed by a human users on the interface of a computer system, and then emulate their enactment in place of the user by means of a software robot. Nowadays, in the BPM domain, only simple, predictable business processes involving routine work can be automated by RPA tools in situations where there is no room for interpretation, while more sophisticated work is still left to human experts. In this paper, starting from an in-depth experimentation of the RPA tools available on the market, we provide a classification framework to categorize them on the basis of some key dimensions. Then, based on this analysis, we derive four research challenges and discuss prospective approaches necessary to inject intelligence into current RPA technology, in order to achieve more widespread adoption of RPA in the BPM domain.

    更新日期:2020-01-06
  • 2LS: Heap Analysis and Memory Safety (Competition Contribution)
    arXiv.cs.SE Pub Date : 2019-03-02
    Viktor Malik; Martin Hruska; Peter Schrammel; Tomas Vojnar

    2LS is a framework for analysis of sequential C programs that can verify and refute program assertions and termination. The 2LS framework is built upon the CPROVER infrastructure and implements template-based synthesis techniques, e.g. to find invariants and ranking functions, and incremental loop unwinding techniques to find counterexamples and k-induction proofs. The main improvements in this year's version are the ability of 2LS to analyse programs requiring combined reasoning about shape and content of dynamic data structures, and an instrumentation for memory safety properties.

    更新日期:2020-01-06
  • Challenges in Survey Research
    arXiv.cs.SE Pub Date : 2019-08-16
    Stefan Wagner; Daniel Méndez Fernández; Michael Felderer; Daniel Graziotin; Marcos Kalinowski

    While being an important and often used research method, survey research has been less often discussed on a methodological level in empirical software engineering than other types of research. This chapter compiles a set of important and challenging issues in survey research based on experiences with several large-scale international surveys. The chapter covers theory building, sampling, invitation and follow-up, statistical as well as qualitative analysis of survey data and the usage of psychometrics in software engineering surveys.

    更新日期:2020-01-06
  • Pre-trained Contextual Embedding of Source Code
    arXiv.cs.SE Pub Date : 2019-12-21
    Aditya Kanade; Petros Maniatis; Gogul Balakrishnan; Kensen Shi

    The source code of a program not only serves as a formal description of an executable task, but it also serves to communicate developer intent in a human-readable form. To facilitate this, developers use meaningful identifier names and natural-language documentation. This makes it possible to successfully apply sequence-modeling approaches, shown to be effective in natural-language processing, to source code. A major advancement in natural-language understanding has been the use of pre-trained token embeddings; BERT and other works have further shown that pre-trained contextual embeddings can be extremely powerful and can be fine-tuned effectively for a variety of downstream supervised tasks. Inspired by these developments, we present the first attempt to replicate this success on source code. We curate a massive corpus of Python programs from GitHub to pre-train a BERT model, which we call Code Understanding BERT (CuBERT). We also pre-train Word2Vec embeddings on the same dataset. We create a benchmark of five classification tasks and compare fine-tuned CuBERT against sequence models trained with and without the Word2Vec embeddings. Our results show that CuBERT outperforms the baseline methods by a margin of 2.9-22%. We also show its superiority when fine-tuned with smaller datasets, and over fewer epochs. We further evaluate CuBERT's effectiveness on a joint classification, localization and repair task involving prediction of two pointers.

    更新日期:2020-01-04
  • Web APIs in Android through the Lens of Security
    arXiv.cs.SE Pub Date : 2020-01-01
    Pascal Gadient; Mohammad Ghafari; Oscar Nierstrasz

    Web communication has become an indispensable characteristic of mobile apps. However, it is not clear what data the apps transmit, to whom, and what consequences such transmissions have. We analyzed the web communications found in mobile apps from the perspective of security. We first manually studied 160 Android apps to identify the commonly-used communication libraries, and to understand how they are used in these apps. We then developed a tool to statically identify web API URLs used in the apps, and restore the JSON data schemas including the type and value of each parameter. We extracted 9,714 distinct web API URLs that were used in 3,376 apps. We found that developers often use the java.net package for network communication, however, third-party libraries like OkHttp are also used in many apps. We discovered that insecure HTTP connections are seven times more prevalent in closed-source than in open-source apps, and that embedded SQL and JavaScript code is used in web communication in more than 500 different apps. This finding is devastating; it leaves billions of users and API service providers vulnerable to attack.

    更新日期:2020-01-04
  • Business Value of ITSM. Requirement or Mirage?
    arXiv.cs.SE Pub Date : 2020-01-01
    James J. Cusick

    This paper builds on a presentation provided as part of a recent panel session on ITSM (IT Service Management) Business Value at the NYC itSMF (Service Management Forum) Local Interest Group meeting. The panel presentation explored the definition of Business Value and how ITSM itself could be measured to produce business value. While ITSM and ITIL have been in use for years it often remains a challenge to demonstrate the business value of these methods or even to understand business value itself. This paper expands on the panel discussion on what is meant by business value and how it can be found (if at all) in the context of ITSM development and process improvement. Keywords. IT Service Management, ITSM, ITIL, ITIL 4, DevOps, IT Operations, Process Engineering, Process Improvement, Quality, Business Value, Metrics, GQM, Lean, Cost of Quality, Capability Maturity Models.

    更新日期:2020-01-04
  • Dataset of Video Game Development Problems
    arXiv.cs.SE Pub Date : 2020-01-02
    Cristiano Politowski; Fabio Petrillo; Gabriel Cavalheiro Ullmann; Josias de Andrade Werly; Yann-Gaël Guéhéneuc

    Different from traditional software development, there is little information about the software-engineering process and techniques in video-game development. One popular way to share knowledge among the video-game developers' community is the publishing of postmortems, which are documents summarizing what happened during the video-game development project. However, these documents are written without formal structure and often providing disparate information. Through this paper, we provide developers and researchers with grounded dataset describing software-engineering problems in video-game development extracted from postmortems. We created the dataset using an iterative method through which we manually coded more than 200 postmortems spanning 20 years (1998 to 2018) and extracted 1,035 problems related to software engineering while maintaining traceability links to the postmortems. We grouped the problems in 20 different types. This dataset is useful to understand the problems faced by developers during video-game development, providing researchers and practitioners a starting point to study video-game development in the context of software engineering.

    更新日期:2020-01-04
  • A Zero-Positive Learning Approach for Diagnosing Software Performance Regressions
    arXiv.cs.SE Pub Date : 2017-09-21
    Mejbah Alam; Justin Gottschlich; Nesime Tatbul; Javier Turek; Timothy Mattson; Abdullah Muzahid

    The field of machine programming (MP), the automation of the development of software, is making notable research advances. This is, in part, due to the emergence of a wide range of novel techniques in machine learning. In this paper, we apply MP to the automation of software performance regression testing. A performance regression is a software performance degradation caused by a code change. We present AutoPerf - a novel approach to automate regression testing that utilizes three core techniques: (i) zero-positive learning, (ii) autoencoders, and (iii) hardware telemetry. We demonstrate AutoPerf's generality and efficacy against 3 types of performance regressions across 10 real performance bugs in 7 benchmark and open-source programs. On average, AutoPerf exhibits 4% profiling overhead and accurately diagnoses more performance bugs than prior state-of-the-art approaches. Thus far, AutoPerf has produced no false negatives.

    更新日期:2020-01-04
  • Bayesian data analysis in empirical software engineering---The case of missing data
    arXiv.cs.SE Pub Date : 2019-04-01
    Richard Torkar; Robert Feldt; Carlo A. Furia

    Bayesian data analysis (BDA) is today used by a multitude of research disciplines. These disciplines use BDA as a way to embrace uncertainty by using multilevel models and making use of all available information at hand. In this chapter, we first introduce the reader to BDA and then provide an example from empirical software engineering, where we also deal with a common issue in our field, i.e., missing data. The example we make use of presents the steps done when conducting state of the art statistical analysis. First, we need to understand the problem we want to solve. Second, we conduct causal analysis. Third, we analyze non-identifiability. Fourth, we conduct missing data analysis. Finally, we do a sensitivity analysis of priors. All this before we design our statistical model. Once we have a model, we present several diagnostics one can use to conduct sanity checks. We hope that through these examples, the reader will see the advantages of using BDA. This way, we hope Bayesian statistics will become more prevalent in our field, thus partly avoiding the reproducibility crisis we have seen in other disciplines.

    更新日期:2020-01-04
  • The Prolog debugger and declarative programming
    arXiv.cs.SE Pub Date : 2019-06-11
    Włodzimierz Drabent

    Logic programming is a declarative programming paradigm. Programming language Prolog makes logic programming possible, at least to a substantial extent. However the Prolog debugger works solely in terms of the operational semantics. So it is incompatible with declarative programming. This report discusses this issue and tries to find how the debugger may be used from the declarative point of view. The results are rather not encouraging. Also, the box model of Byrd, used by the debugger, is explained in terms of SLD-resolution.

    更新日期:2020-01-04
  • IR2Vec: A Flow Analysis based Scalable Infrastructure for Program Encodings
    arXiv.cs.SE Pub Date : 2019-09-13
    Venkata Keerthy S; Rohit Aggarwal; Shalini Jain; Maunendra Sankar Desarkar; Ramakrishna Upadrasta; Y. N. Srikant

    We propose IR2Vec, a Concise and Scalable encoding infrastructure to represent programs as a distributed embedding in continuous space. This distributed embedding is obtained by combining representation learning methods with data and control flow information to capture the syntax as well as the semantics of the input programs. Our embeddings are obtained from the Intermediate Representation (IR) of the source code, and are both language as well as machine independent. The entities of the IR are modelled as relationships, and their representations are learned to form a seed embedding vocabulary. This vocabulary is used along with the flow analyses information to form a hierarchy of encodings based on various levels of program abstractions. We show the effectiveness of our methodology on a software engineering task (program classification) as well as optimization tasks (Heterogeneous device mapping and Thread coarsening). The embeddings generated by IR2Vec outperform the existing methods in all the three tasks even when using simple machine learning models. As we follow an agglomerative method of forming encodings at various levels using seed embedding vocabulary, our encoding is naturally more scalable and not data-hungry when compared to the other methods.

    更新日期:2020-01-04
  • On correctness of an n queens program
    arXiv.cs.SE Pub Date : 2019-09-16
    Włodzimierz Drabent

    Thom Fr\"uhwirth presented a short, elegant and efficient Prolog program for the n queens problem. However the program may be seen as rather tricky and one may be not convinced about its correctness. This paper explains the program in a declarative way, and provides a proof of its correctness and completeness.

    更新日期:2020-01-04
  • Adaptive Metamorphic Testing with Contextual Bandits
    arXiv.cs.SE Pub Date : 2019-10-01
    Helge Spieker; Arnaud Gotlieb

    Metamorphic Testing is a software testing paradigm which aims at using necessary properties of a system-under-test, called metamorphic relations, to either check its expected outputs, or to generate new test cases. Metamorphic Testing has been successful to test programs for which a full oracle is not available or to test programs for which there are uncertainties on expected outputs such as learning systems. In this article, we propose Adaptive Metamorphic Testing as a generalization of a simple yet powerful reinforcement learning technique, namely contextual bandits, to select one of the multiple metamorphic relations available for a program. By using contextual bandits, Adaptive Metamorphic Testing learns which metamorphic relations are likely to transform a source test case, such that it has higher chance to discover faults. We present experimental results over two major case studies in machine learning, namely image classification and object detection, and identify weaknesses and robustness boundaries. Adaptive Metamorphic Testing efficiently identifies weaknesses of the tested systems in context of the source test case.

    更新日期:2020-01-04
  • DeCaf: Diagnosing and Triaging Performance Issues in Large-Scale Cloud Services
    arXiv.cs.SE Pub Date : 2019-10-11
    Chetan Bansal; Sundararajan Renganathan; Ashima Asudani; Olivier Midy; Mathru Janakiraman

    Large scale cloud services use Key Performance Indicators (KPIs) for tracking and monitoring performance. They usually have Service Level Objectives (SLOs) baked into the customer agreements which are tied to these KPIs. Dependency failures, code bugs, infrastructure failures, and other problems can cause performance regressions. It is critical to minimize the time and manual effort in diagnosing and triaging such issues to reduce customer impact. Large volumes of logs and mixed type of attributes (categorical, continuous) makes any automated or manual diagnosing non-trivial. In this paper, we present the design, implementation and experience from building and deploying DeCaf, a system for automated diagnosis and triaging of KPI issues using service logs. It uses machine learning along with pattern mining to help service owners automatically root cause and triage performance issues. We present the learnings and results from case studies on two large scale cloud services in Microsoft where DeCaf successfully diagnosed 10 known and 31 unknown issues. DeCaf also automatically triages the identified issues by leveraging historical data. Our key insights are that for any such diagnosis tool to be effective in practice, it should a) scale to large volumes of service logs and attributes, b) support different types of KPIs and ranking functions, c) be integrated into the DevOps processes.

    更新日期:2020-01-04
  • Open Source Software Sustainability Models: Initial White Paper from the Informatics Technology for Cancer Research Sustainability and Industry Partnership Work Group
    arXiv.cs.SE Pub Date : 2019-12-27
    Y. Ye; R. D. Boyce; M. K. Davis; K. Elliston; C. Davatzikos; A. Fedorov; J. C. Fillion-Robin; I. Foster; J. Gilbertson; M. Heiskanen; J. Klemm; A. Lasso; J. V. Miller; M. Morgan; S. Pieper; B. Raumann; B. Sarachan; G. Savova; J. C. Silverstein; D. Taylor; J. Zelnis; G. Q. Zhang; M. J. Becich

    The Sustainability and Industry Partnership Work Group (SIP-WG) is a part of the National Cancer Institute Informatics Technology for Cancer Research (ITCR) program. The charter of the SIP-WG is to investigate options of long-term sustainability of open source software (OSS) developed by the ITCR, in part by developing a collection of business model archetypes that can serve as sustainability plans for ITCR OSS development initiatives. The workgroup assembled models from the ITCR program, from other studies, and via engagement of its extensive network of relationships with other organizations (e.g., Chan Zuckerberg Initiative, Open Source Initiative and Software Sustainability Institute). This article reviews existing sustainability models and describes ten OSS use cases disseminated by the SIP-WG and others, and highlights five essential attributes (alignment with unmet scientific needs, dedicated development team, vibrant user community, feasible licensing model, and sustainable financial model) to assist academic software developers in achieving best practice in software sustainability.

    更新日期:2020-01-04
  • LLOV: A Fast Static Data-Race Checker for OpenMP Programs
    arXiv.cs.SE Pub Date : 2019-12-27
    Utpal Bora; Santanu Das; Pankaj Kureja; Saurabh Joshi; Ramakrishna Upadrasta; Sanjay Rajopadhye

    In the era of Exascale computing, writing efficient parallel programs is indispensable and at the same time, writing sound parallel programs is highly difficult. While parallel programming is easier with frameworks such as OpenMP, the possibility of data races in these programs still persists. In this paper, we propose a fast, lightweight, language agnostic, and static data race checker for OpenMP programs based on the LLVM compiler framework. We compare our tool with other state-of-the-art data race checkers on a variety of well-established benchmarks. We show that the precision, accuracy, and the F1 score of our tool is comparable to other checkers while being orders of magnitude faster. To the best of our knowledge, this work is the only tool among the state-of-the-art data race checkers that can verify a FORTRAN program to be datarace free.

    更新日期:2020-01-04
Contents have been reproduced by permission of the publishers.
导出
全部期刊列表>>
2020新春特辑
限时免费阅读临床医学内容
ACS材料视界
科学报告最新纳米科学与技术研究
清华大学化学系段昊泓
自然科研论文编辑服务
中国科学院大学楚甲祥
上海纽约大学William Glover
中国科学院化学研究所
课题组网站
X-MOL
北京大学分子工程苏南研究院
华东师范大学分子机器及功能材料
中山大学化学工程与技术学院
试剂库存
天合科研
down
wechat
bug