Science of Computer Programming最新文献

Code smell detection is one of the essential tasks in the field of software engineering. Identifying whether a code snippet has a code smell is subjective and varies by programming language, developer, and development method. Moreover, developers tend to focus on code smells that have a real impact on development and ignore insignificant ones. However, existing static code analysis tools and code smell detection approaches exhibit a high false positive rate in detecting code smells, which makes insignificant smells drown out those smells that developers value. Therefore, accurately reporting those actionable code smells that developers tend to spend energy on refactoring can prevent developers from getting lost in the sea of smells and improve refactoring efficiency. In this paper, we aim to detect actionable code smells that developers tend to refactor. Specifically, we first collect actionable and non-actionable code smells from projects with numerous historical versions to construct our datasets. Then, we propose a dual-stream model for fusion learning of code metrics and code semantics to detect actionable code smells. On the one hand, code metrics quantify the code's structure and even some rules or patterns, providing fundamental information for detecting code smells. On the other hand, code semantics encompass information about developers' refactoring tendencies, which prove valuable in detecting actionable code smells. Extensive experiments show that our approach can detect actionable code smells more accurately compared to existing approaches.

Quantum computing is a revolutionary paradigm in computer science based on the principles of quantum mechanics. It has the potential to solve problems that are currently unsolvable for classical computing. Applications of quantum computing already span a variety of sectors.

Ongoing enhancements to the integrated programming and development environment simplify the creation and optimization of quantum algorithms. Ultimately, the focus on supporting tools represents the starting point towards achieving quantum computing maturity, facilitating its transition from an experimental domain to a practical industry.

As quantum software gains ground and relevance in various domains, it is essential to address the evaluation of hybrid systems that combine classical and quantum elements to ensure diverse quality characteristics. However, in the realm of quantum software, models, metrics, and tools are still to be established.

The primary contribution of this paper is to present the first technological environment for measuring and evaluating the analyzability of hybrid software.

Real-world examples of hybrid software are provided to showcase the functionality of the different tools in the environment, yielding readable and representative results for the evaluator.

ChatGPT is a language model with artificial intelligence (AI) capabilities that has found utility across various sectors. Given its impact, we conducted two empirical studies to assess the potential and limitations of ChatGPT and other AI tools in software development. In the first study, we evaluated ChatGPT 3.5′s effectiveness in generating code for 180 coding problems from LeetCode, an online coding interview preparation platform. Our findings suggest that ChatGPT 3.5 is more effective in solving easy and medium coding problems but less reliable for harder problems. Further, ChatGPT 3.5 is somewhat more effective at coding problems with higher popularity scores. In the second study, we administered a questionnaire (N = 99) to programmers to gain insights into their views on ChatGPT and other AI tools. Our findings indicate that programmers use AI tools for various tasks, such as generating boilerplate code, explaining complex code, and conducting research. AI tools also help programmers to become more productive by creating better-performing, shorter, and more readable code, among other benefits. However, AI tools can sometimes misunderstand requirements and generate erroneous code. While most programmers are not currently concerned about AI tools replacing them, they are apprehensive about what the future may hold. Our research has also revealed associations between AI tool usage, trust, perceived productivity, and job security threats caused by the tools.

As video games become more complex and widespread, player experience (PX) testing becomes crucial in the game industry. Attracting and retaining players are key elements to guarantee the success of a game in the highly competitive market. Although a number of techniques have been introduced to measure the emotional aspect of the experience, automated testing of player experience still needs to be explored. This paper presents PX-MBT, a framework for automated player experience testing with emotion pattern verification. PX-MBT (1) utilizes a model-based testing approach for test suite generation, (2) employs a computational model of emotions developed based on a psychological theory of emotions to model players' emotions during game-plays with an intelligent agent, and (3) verifies emotion patterns given by game designers on executed test suites to identify PX-issues. We explain PX-MBT architecture and provide an example along with its result in emotion pattern verification, which asserts the evolution of emotions over time, and heat-maps to showcase the spatial distribution of emotions on the game map.

The primary aim of Automatic Program Repair (APR) is to automatically repair defective programs, with the intention of reducing the amount of effort required by developers. However, APR techniques may produce overfitting patches that do not truly repair the program, allowing the program to pass all test cases. This paper provides a comprehensive review of the overfitting problem and adds to the existing research on overfitting in conditional statements. Our proposed method, ETPAT (Expression Tree-based Patch Assessment Technique), implements expression trees and targeted coverage criteria to identify differences between the original and the patched program. We utilize ETPAT to verify test case adequacy. In parallel, ETPAT also guides the generation of corresponding test cases via equivalence class information, which may be added to the original test suite, making it more robust while also preventing the repair technique from generating comparable overfitting patches. With reference to the patch set in the BuggyJavaJML benchmark, ETPAT recognized 77/82 (93.9%) overfitting patches out of 120 patches related to conditional constraints, displaying superior accuracy rates and fewer test cases required than the original repair tool.

Python package installation is far from trivial. Users encounter a variety of errors when installing Python libraries, including dependency conflicts and incompatibilities. Existing solutions focus on parsing third-party dependencies but ignore the impact of local settings and user requirements. In this paper, we propose a novel approach, HELP, to help Python users tackle installation errors. We first establish a local knowledge base by extracting the PyPI database and dependency analysis. When the user provides the installation requirements, HELP extracts multiple constraints including user requirements, Python version constraints, and dependency constraints, and models them into SMT expressions. Then HELP solves the installation problem by using the SMT solver.

To understand the status of Python version compatibility, we conduct an empirical study on Python version compatibility on 8,502 libraries. The study reveals that 80% of Python libraries do not declare Python version constraints in most versions. We also find that installation errors are strongly related to Python versions. To evaluate HELP, we conduct the experiment on 495 sampled installation failures. The results show that HELP can effectively resolve 263 installation failures, 42% more than the baseline approach. Especially, HELP provides a more comprehensive diagnosis when encountering configuration-related installation failures. Besides, HELP is more efficient than pip at predicting installation failures (30X speedups), which may save much effort if the installation cannot succeed.

Formal approaches and tools have been defined, implemented and successfully applied to support the design and development of Collective Adaptive Systems. These tools are highly specialised in their fields, and their integration requires an effort.

In this paper, we introduce Sibilla, a Java modular tool that facilitates the integration of multiple specification languages for supporting quantitative analysis of systems. After a description of the general architecture of Sibilla, the main features of the tool are discussed via simple examples.

A concurrent system specified as a rewrite theory can be analyzed symbolically using narrowing-based reachability analysis. Narrowing-based approaches have been applied to formally analyze cryptographic protocols and parameterized protocols. However, existing narrowing-based analysis methods, based on a breadth-first-search strategy, cannot deal with generic distributed systems with objects and messages due to the symbolic state-space explosion problem and implicit constraints imposed on object-oriented systems. This paper proposes a heuristic search approach for narrowing-based reachability analysis to guide the search for counterexamples with a small number of objects. As a result, our method can effectively find a counterexample if an error state is reachable. In addition, this paper also shows how to encode implicit object-oriented constraints using order-sorted signatures and equational constraints. We demonstrate the effectiveness of our technique using a nontrivial distributed consensus algorithm.

Researchers have been developing automatic bug triaging techniques by leveraging bug information sourced from bug tracking systems. Recent studies have modeled the bug-developer relationship as a graph, introducing graph neural networks for bug triaging. Despite achieving positive outcomes, these methods overlook issues related to data sparsity and fail to fully exploit implicit relationships within the graph. In addressing these challenges, we present the Neighborhood Contrastive Learning-based Graph Neural Network Bug Triaging framework, abbreviated as NCGBT. Our approach models the relationship between bugs and developers as a bipartite graph. We utilize a pre-trained language model to acquire the initial representation of bug nodes. Employing a basic graph neural network framework, we learn the representation of all nodes and leverage these representations to predict developers for a given bug. Our proposed strategy involves neighborhood contrastive learning applied to the basic graph neural network approach. We take into account the neighbors of nodes from both structural and semantic perspectives, utilizing them as contrastive objects. Extensive experiments conducted on three public datasets demonstrate the effectiveness of the NCGBT framework.