Program Slicing and Source Code Analysis: Methods and Applications

A special issue of Electronics (ISSN 2079-9292). This special issue belongs to the section "Computer Science & Engineering".

Deadline for manuscript submissions: 15 October 2024 | Viewed by 2436

Special Issue Editor

Valencian Research Institute for Artificial Intelligence, Technical University of Valencia, Valencia 46022, Spain
Interests: programming languages; debugging; static analysis; program slicing

Special Issue Information

Dear Colleagues,

Software and programming languages’ complexity has been increasing steadily since the inception of the first computer programs and languages. To handle this increase in complexity, many software analysis techniques, such as program slicing, have been developed and included in the development process, for example, in IDEs, debuggers, or compilers.

Program slicing can identify which statements may affect (or be affected by) a given point in the program, the so-called slicing criterion. Even though program slicing was initially designed for debugging (where the slice includes the statements relevant to isolate and fix a bug), currently, the applications of program slicing range from program parallelization and clone detection to neural network optimization and pre-processing for other analyses in which the input size must be minimized due to a high time complexity.

This Special Issue aims to present advancements in source code analysis, synthesis, and transformation; with special emphasis (but not limited to) program slicing. Papers presenting novel techniques and their applications, novel implementations or algorithms, and any advancement in static or dynamic analysis that is relevant to source code analysis or program slicing, e.g., control dependence, System Dependence Graph, flow dependence, dicing, chopping, dependence analyses, formal aspects, usages of program slicing, tools, etc.

Technical Program Committee Member:

Name: Carlos Galindo
Email: cargaji@vrain.upv.es
Affiliation: Valencian Research Institute for Artificial Intelligence, Technical University of Valencia, Valencia 46022, Spain
Website: https://cargaji.webs.upv.es/c/
Research Interests: program slicing; static analysis; programming languages

Dr. Josep Silva
Guest Editor

Manuscript Submission Information

Manuscripts should be submitted online at www.mdpi.com by registering and logging in to this website. Once you are registered, click here to go to the submission form. Manuscripts can be submitted until the deadline. All submissions that pass pre-check are peer-reviewed. Accepted papers will be published continuously in the journal (as soon as accepted) and will be listed together on the special issue website. Research articles, review articles as well as short communications are invited. For planned papers, a title and short abstract (about 100 words) can be sent to the Editorial Office for announcement on this website.

Submitted manuscripts should not have been published previously, nor be under consideration for publication elsewhere (except conference proceedings papers). All manuscripts are thoroughly refereed through a single-blind peer-review process. A guide for authors and other relevant information for submission of manuscripts is available on the Instructions for Authors page. Electronics is an international peer-reviewed open access semimonthly journal published by MDPI.

Please visit the Instructions for Authors page before submitting a manuscript. The Article Processing Charge (APC) for publication in this open access journal is 2400 CHF (Swiss Francs). Submitted papers should be well formatted and use good English. Authors may use MDPI's English editing service prior to publication or during author revisions.

Keywords

  • source code analysis
  • applications and/or their empirical evaluation
  • system dependence graph
  • control and/or data dependence
  • static program slicing
  • dynamic program slicing
  • program slicing in different programming paradigms
  • formal proofs of existing or novel source code analysis techniques
  • benchmark suites
  • code debugging

Published Papers (4 papers)

Order results
Result details
Select all
Export citation of selected articles as:

Research

19 pages, 418 KiB  
Article
Exploring the Potential of Pre-Trained Language Models of Code for Automated Program Repair
by Sichong Hao, Xianjun Shi and Hongwei Liu
Electronics 2024, 13(7), 1200; https://doi.org/10.3390/electronics13071200 - 25 Mar 2024
Viewed by 280
Abstract
In the realm of software development, automated program repair (APR) emerges as a pivotal technique, autonomously debugging faulty code to boost productivity. Despite the notable advancements of large pre-trained language models of code (PLMCs) in code generation, their efficacy in complex tasks like [...] Read more.
In the realm of software development, automated program repair (APR) emerges as a pivotal technique, autonomously debugging faulty code to boost productivity. Despite the notable advancements of large pre-trained language models of code (PLMCs) in code generation, their efficacy in complex tasks like APR remains suboptimal. This limitation is attributed to the generic development of PLMCs, whose specialized potential for APR is yet be to fully explored. In this paper, we propose a novel approach designed to enhance PLMCs’ APR performance through source code augmentation and curriculum learning. Our approach employs code augmentation operators to generate a spectrum of syntactically varied yet semantically congruent bug-fixing programs, thus enriching the dataset’s diversity. Furthermore, we design a curriculum learning strategy, enabling PLMCs to develop a deep understanding of program semantics from these enriched code variants, thereby refining their APR fine-tuning prowess. We apply our approach across different PLMCs and systematically evaluate it on three benchmarks: BFP-small, BFP-medium, and Defects4J. The experimental results show that our approach outperforms both original models and existing baseline methods, demonstrating the promising future of adapting PLMCs for code debugging in practice. Full article
(This article belongs to the Special Issue Program Slicing and Source Code Analysis: Methods and Applications)
Show Figures

Figure 1

28 pages, 1060 KiB  
Article
Reducing the Length of Dynamic and Relevant Slices by Pruning Boolean Expressions
by Thomas Hirsch and Birgit Hofer
Electronics 2024, 13(6), 1146; https://doi.org/10.3390/electronics13061146 - 20 Mar 2024
Viewed by 356
Abstract
Dynamic and relevant (backward) slicing helps programmers in the debugging process by reducing the number of statements in an execution trace. In this paper, we propose an approach called pruned slicing, which can further reduce the size of slices by reasoning over Boolean [...] Read more.
Dynamic and relevant (backward) slicing helps programmers in the debugging process by reducing the number of statements in an execution trace. In this paper, we propose an approach called pruned slicing, which can further reduce the size of slices by reasoning over Boolean expressions. It adds only those parts of a Boolean expression that are responsible for the evaluation outcome of the Boolean expression to the set of relevant variables. We empirically evaluate our approach and compare it to dynamic and relevant slicing using three small benchmarks: the traffic collision avoidance system (TCAS), the Refactory dataset, and QuixBugs. Pruned slicing reduces the size of the TCAS slices on average by 10.2%, but it does not reduce the slice sizes of the Refactory and QuixBugs programs. The times required for computing pruned dynamic and relevant slices are comparable to the computation times of non-pruned dynamic and relevant slices. Thus, pruned slicing is an extension of dynamic and relevant slicing that can reduce the size of slices while having a negligible computational overhead. Full article
(This article belongs to the Special Issue Program Slicing and Source Code Analysis: Methods and Applications)
Show Figures

Figure 1

23 pages, 2104 KiB  
Article
Modeling and Analyzing Reaction Systems in Maude
by Demis Ballis, Linda Brodo and Moreno Falaschi
Electronics 2024, 13(6), 1139; https://doi.org/10.3390/electronics13061139 - 20 Mar 2024
Viewed by 312
Abstract
Reaction Systems (RSs) are a successful computational framework for modeling systems inspired by biochemistry. An RS defines a set of rules (reactions) over a finite set of entities (e.g., molecules, proteins, genes, etc.). A computation in this system is performed by rewriting a [...] Read more.
Reaction Systems (RSs) are a successful computational framework for modeling systems inspired by biochemistry. An RS defines a set of rules (reactions) over a finite set of entities (e.g., molecules, proteins, genes, etc.). A computation in this system is performed by rewriting a finite set of entities (a computation state) using all the enabled reactions in the RS, thereby producing a new set of entities (a new computation state). The number of entities in the reactions and in the computation states can be large, making the analysis of RS behavior difficult without a proper automated support. In this paper, we use the Maude language—a programming language based on rewriting logic—to define a formal executable semantics for RSs, which can be used to precisely simulate the system behavior as well as to perform reachability analysis over the system computation space. Then, by enriching the proposed semantics, we formalize a forward slicer algorithm for RSs that allows us to observe the evolution of the system on both the initial input and a fragment of it (the slicing criterion), thus facilitating the detection of forward causality and influence relations due to the absence/presence of some entities in the slicing criterion. The pursued approach is illustrated by a biological reaction system that models a gene regulation network for controlling the process of differentiation of T helper lymphocytes. Full article
(This article belongs to the Special Issue Program Slicing and Source Code Analysis: Methods and Applications)
Show Figures

Figure 1

12 pages, 889 KiB  
Article
Reduction of False Positives for Runtime Errors in C/C++ Software: A Comparative Study
by Jihyun Park, Jaeyoung Shin and Byoungju Choi
Electronics 2023, 12(16), 3518; https://doi.org/10.3390/electronics12163518 - 20 Aug 2023
Viewed by 897
Abstract
In software development, early defect detection using static analysis can be performed without executing the source code. However, defects are detected on a non-execution basis, thus resulting in a higher ratio of false positives. Recently, studies have been conducted to effectively perform static [...] Read more.
In software development, early defect detection using static analysis can be performed without executing the source code. However, defects are detected on a non-execution basis, thus resulting in a higher ratio of false positives. Recently, studies have been conducted to effectively perform static analyses using machine learning (ML) and deep learning (DL) technologies. This study examines the techniques for detecting runtime errors used in existing static analysis tools and the causes and rates of false positives. It analyzes the latest static analysis technologies that apply machine learning/deep learning to decrease false positives and compares them with existing technologies in terms of effectiveness and performance. In addition, machine-learning/deep-learning-based defect detection techniques were implemented in experimental environments and real-world software to determine their effectiveness in real-world software. Full article
(This article belongs to the Special Issue Program Slicing and Source Code Analysis: Methods and Applications)
Show Figures

Figure 1

Back to TopTop