Search for Articles:
Title / Keyword
Author / Affiliation / Email
Journal
Article Type
 
 
Advanced Search
 
Section
Special Issue
Volume
Issue
Number
Page
 
5.3
2.6
Journals
Electronics
Special Issues
Program Slicing and Source Code Analysis: Methods and Applications
share announcement

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: closed (15 March 2025) | Viewed by 7890

Special Issue Editors

Prof. Dr. Josep Silva

E-Mail Website
Guest Editor
Valencian Research Institute for Artificial Intelligence, Technical University of Valencia, 46022 Valencia, Spain
Interests: programming languages; debugging; static analysis; program slicing
Dr. Carlos Galindo

E-Mail Website
Co-Guest Editor
Valencian Research Institute for Artificial Intelligence, Technical University of Valencia, 46022 Valencia, Spain
Interests: program slicing; static analysis; programming languages

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.

Dr. Josep Silva
Dr. Carlos Galindo
Guest Editors

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

Benefits of Publishing in a Special Issue

  • Ease of navigation: Grouping papers by topic helps scholars navigate broad scope journals more efficiently.
  • Greater discoverability: Special Issues support the reach and impact of scientific research. Articles in Special Issues are more discoverable and cited more frequently.
  • Expansion of research network: Special Issues facilitate connections among authors, fostering scientific collaborations.
  • External promotion: Articles in Special Issues are often promoted through the journal's social media, increasing their visibility.
  • e-Book format: Special Issues with more than 10 articles can be published as dedicated e-books, ensuring wide and rapid dissemination.

Further information on MDPI's Special Issue policies can be found here.

Published Papers (5 papers)

Download All Papers
Order results
Result details
Show export options expand_more Show export options expand_less
Select all
Export citation of selected articles as:

Research

18 pages, 512 KiB  
Article
Incremental Repair Feedback on Automated Assessment of Programming Assignments
by José Carlos Paiva, José Paulo Leal and Álvaro Figueira
Electronics 2025, 14(4), 819; https://doi.org/10.3390/electronics14040819 - 19 Feb 2025
Viewed by 394
Abstract
Automated assessment tools for programming assignments have become increasingly popular in computing education. These tools offer a cost-effective and highly available way to provide timely and consistent feedback to students. However, when evaluating a logically incorrect source code, there are some reasonable concerns [...] Read more.
Automated assessment tools for programming assignments have become increasingly popular in computing education. These tools offer a cost-effective and highly available way to provide timely and consistent feedback to students. However, when evaluating a logically incorrect source code, there are some reasonable concerns about the formative gap in the feedback generated by such tools compared to that of human teaching assistants. A teaching assistant either pinpoints logical errors, describes how the program fails to perform the proposed task, or suggests possible ways to fix mistakes without revealing the correct code. On the other hand, automated assessment tools typically return a measure of the program’s correctness, possibly backed by failing test cases and, only in a few cases, fixes to the program. In this paper, we introduce a tool, AsanasAssist, to generate formative feedback messages to students to repair functionality mistakes in the submitted source code based on the most similar algorithmic strategy solution. These suggestions are delivered with incremental levels of detail according to the student’s needs, from identifying the block containing the error to displaying the correct source code. Furthermore, we evaluate how well the automatically generated messages provided by AsanasAssist match those provided by a human teaching assistant. The results demonstrate that the tool achieves feedback comparable to that of a human grader while being able to provide it just in time. Full article
(This article belongs to the Special Issue Program Slicing and Source Code Analysis: Methods and Applications)
►▼ Show Figures

Figure 1

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 1798
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 1187
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
Cited by 2 | Viewed by 1317
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 1983
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

Show export options expand_more Show export options expand_less
Select all
Export citation of selected articles as:
 
Displaying articles 1-5
Back to TopTop