Árpád Beszédes

Árpád Beszédes

Auto-generated profile, based on publicly available information

Árpád Beszédes

Department of Software Engineering, University of Szeged, Szeged, Hungary

Research Focus & Metrics

Academic Career Length

20Years (2007-Present)

(Calculated once Scilit publication data is synced: current year − year of first publication + 1)

Representative Publications

View All Publications
18 January 2022 in IEEE Access
Verified
Journal Article
Open access
Qusay Idrees SarhanQusay Idrees Sarhan
Qusay Idrees Sarhan
ABArpad Beszedes
Arpad Beszedes
In software debugging, fault localization is the most difficult, expensive, tedious, and time-consuming task, particularly for large-scale software systems. This is due to the fact that it requires significant human participation and it is difficult to automate its sub-tasks. Therefore, there is a high demand for automatic fault localization techniques that can help software engineers effectively find the locations of faults with minimal human intervention. This has led to the proposal of implementing different types of such techniques. However, Spectrum Based Fault Localization (SBFL) is considered amongst the most prominent techniques in this respect due to its efficiency and effectiveness. In SBFL, the probability of each program element (e.g., statement, block, or function) being faulty is calculated based on the results of executing test cases and their corresponding code coverage information. However, SBFL techniques are not yet widely adopted in the industry. The rationale behind this is that they pose a number of issues and their performance is affected by several influential factors. For example, the characteristics of bugs, target programs, test suites, and supporting tools make their effectiveness differ dramatically from one case to another. There are massive studies on SBFL that cover its usage, formulas, performance, etc. So far, no dedicated survey points out comprehensively the issues of SBFL. In this paper, various SBFL challenges and issues have been identified, categorized, and discussed alongside many directions. Also, the paper raises awareness of the works being achieved to address the identified issues and suggests some potential solutions too.

8 October 2020 in Software Testing, Verification and Reliability
Verified
Journal Article
Open access
PDF file
PGPéter Gyimesi
Péter Gyimesi
BVBéla Vancsics
Béla Vancsics
ASAndrea Stocco
Andrea Stocco
DMDavood Mazinanian
Davood Mazinanian
ÁBÁrpád Beszédes
Árpád Beszédes
AMAli Mesbah
Ali Mesbah
Summary: JavaScript is a popular programming language that is also error‐prone due to its asynchronous, dynamic, and loosely typed nature. In recent years, numerous techniques have been proposed for analyzing and testing JavaScript applications. However, our survey of the literature in this area revealed that the proposed techniques are often evaluated on different datasets of programs and bugs. The lack of a commonly used benchmark limits the ability to perform fair and unbiased comparisons for assessing the efficacy of new techniques. To fill this gap, we propose BugsJS, a benchmark of 453 real, manually validated JavaScript bugs from 10 popular JavaScript server‐side programs, comprising 444k lines of code (LOC) in total. Each bug is accompanied by its bug report, the test cases that expose it, as well as the patch that fixes it. We extended BugsJS with a rich web interface for visualizing and dissecting the bugs' information, as well as a programmable API to access the faulty and fixed versions of the programs and to execute the corresponding test cases, which facilitates conducting highly reproducible empirical studies and comparisons of JavaScript analysis and testing tools. Moreover, following a rigorous procedure, we performed a classification of the bugs according to their nature. Our internal validation shows that our taxonomy is adequate for characterizing the bugs in BugsJS. We discuss several ways in which the resulting taxonomy and the benchmark can help direct researchers interested in automated testing of JavaScript applications. © 2021 The Authors. Software Testing, Verification & Reliability published by John Wiley & Sons, Ltd.

1 September 2013
Verified
Conference Paper
Closed access
GBGergo Balogh
Gergo Balogh
ABArpad Beszedes
Arpad Beszedes
Data visualisation with high expressive power plays an important role in code comprehension. Recent visualization tools try to fulfil the expectations of the users and use various analogies. For example, in an architectural metaphor, each class is represented by a building. Buildings are grouped into districts according to the structure of the namespaces. We think that these unique ways of code representation have great potential, but in our opinion they use very simple graphical techniques (shapes, figures, low resolution) to visualize the structure of the source code.On the other hand, computer games use high quality graphic and good expressive power. A good example is Minecraft, a popular role playing game with great extensibility and interactivity from another (third party) software. It supports both high definition, photo-realistic textures and long range 3D scene displaying. Our main contribution is to connect data visualisation with high end-user graphics capabilities. To achieve this, a conversion tool was implemented. It processes the basic source code metrics as input and generates a Minecraft world with buildings, districts, and gardens. The tool is in the prototype state, but it can be used to investigate the possibilities of this kind of data visualisation.

6 August 2022 in Empirical Software Engineering
Verified
Journal Article
Open access
PDF file
FHFerenc Horváth
Ferenc Horváth
ÁBÁrpád Beszédes
Árpád Beszédes
BVBéla Vancsics
Béla Vancsics
GBGergő Balogh
Gergő Balogh
LVLászló Vidács
László Vidács
TGTibor Gyimóthy
Tibor Gyimóthy
Tool support for automated fault localization in program debugging is limited because state-of-the-art algorithms often fail to provide efficient help to the user. They usually offer a ranked list of suspicious code elements, but the fault is not guaranteed to be found among the highest ranks. In Spectrum-Based Fault Localization (SBFL) – which uses code coverage information of test cases and their execution outcomes to calculate the ranks –, the developer has to investigate several locations before finding the faulty code element. Yet, all the knowledge she a priori has or acquires during this process is not reused by the SBFL tool. There are existing approaches in which the developer interacts with the SBFL algorithm by giving feedback on the elements of the prioritized list. We propose a new approach called iFL which extends interactive approaches by exploiting contextual knowledge of the user about the next item in the ranked list (e. g., a statement), with which larger code entities (e. g., a whole function) can be repositioned in their suspiciousness. We implemented a closely related algorithm proposed by Gong et al., called Talk. First, we evaluated iFL using simulated users, and compared the results to SBFL and Talk. Next, we introduced two types of imperfections in the simulation: user’s knowledge and confidence levels. On SIR and Defects4J, results showed notable improvements in fault localization efficiency, even with strong user imperfections. We then empirically evaluated the effectiveness of the approach with real users in two sets of experiments: a quantitative evaluation of the successfulness of using iFL, and a qualitative evaluation of practical uses of the approach with experienced developers in think-aloud sessions.

20 November 2024 in IEEE Access
Verified
Journal Article
Open access
HHHassan B. Hassan Hassan
Hassan B. Hassan Hassan
Qusay Idrees SarhanQusay Idrees Sarhan
Qusay Idrees Sarhan
ÁBÁrpád Beszédes
Árpád Beszédes
Static code analysis plays a crucial role in software quality assurance. To maximize the effectiveness of these tools, it’s vital to evaluate them in a way that promotes collaboration, long-term viability, and ease of use. This paper explores the application of FAIR principles (Findability, Accessibility, Interoperability, and Reusability) to the assessment of static code analysis tools. We examine a curated selection of Python tools, considering their features, technical capabilities, and alignment with FAIR guidelines. Our analysis highlights that extending the FAIR principles to include clear documentation, performance metrics, and comprehensive testing is essential for a thorough and usable evaluation process. Furthermore, as Internet of Things (IoT) technologies become more prevalent, there is a pressing need to adapt these tools for varied and interconnected environments. This adaptation is essential for addressing the unique challenges, quality, and security issues that are characteristic of IoT systems. By applying this FAIR-based framework, we aim to empower informed decision-making within the software engineering community and promote the development of more sustainable, reliable, and reproducible static code analysis solutions.

1 October 2007 in 2007 IEEE International Conference on Software Maintenance
Verified
Conference Paper
Closed access
ABArpad Beszedes
Arpad Beszedes
TGTamas Gergely
Tamas Gergely
JJJudit Jasz
Judit Jasz
GTGabriella Toth
Gabriella Toth
TGTibor Gyimothy
Tibor Gyimothy
VRVaclav Rajlich
Vaclav Rajlich
In this paper, we introduce static execute after (SEA) relationship among program components and present an efficient analysis algorithm. Our case studies show that SEA may approximate static slicing with perfect recall and high precision, while being much less expensive and more usable. When differentiating between explicit and hidden dependencies, our case studies also show that SEA may correlate with direct and indirect class coupling. We speculate that SEA may find applications in computation of hidden dependencies and through it in many maintenance tasks, including change propagation and regression testing.