https://cyber.bibl.u-szeged.hu/index.php/actcybern/issue/feed Acta Cybernetica 2022-12-30T14:08:31+01:00 Boglárka G.-Tóth boglarka@inf.szte.hu Open Journal Systems <div id="main-content" class="region clearfix"> <div class="region region-content"> <div id="block-system-main" class="block block-system"> <div class="content"> <div id="node-30" class="node node-page clearfix"> <div class="content"> <div class="field field-name-body field-type-text-with-summary field-label-hidden"> <div class="field-items"> <div class="field-item even"> <p><img style="margin-left: 10px; margin-right: 10px; float: right; width: 203px; height: 291px;" src="https://www.inf.u-szeged.hu/sites/default/files/kutatas/actacover1802qh.png" alt=""></p> <p>A scientific journal published by the <a href="https://www.inf.u-szeged.hu" target="_blank" rel="noopener">Institute of Informatics</a>, <a href="https://www.u-szeged.hu/english/" target="_blank" rel="noopener">University of Szeged</a>, <a href="https://www.szeged.hu/" target="_blank" rel="noopener">Szeged</a>, <a href="https://www.fsz.bme.hu/hungary/homepage.html" target="_blank" rel="noopener">Hungary</a>.</p> <p>Acta Cybernetica is abstracted by <a href="https://www.ams.org/publications/math-reviews/math-reviews" target="_blank" rel="noopener">Mathematical Reviews</a>, <a href="https://computingreviews.com/" target="_blank" rel="noopener">Computing Reviews</a>, <a href="https://zbmath.org/" target="_blank" rel="noopener">Zentralblatt für Mathematik</a>&nbsp;and <a href="https://dl.acm.org/journal/accy" target="_blank" rel="noopener">ACM Digital Library</a></p> <p>&nbsp;&nbsp; <a href="https://www.scimagojr.com/journalsearch.php?q=13024&amp;tip=sid&amp;clean=0"><img style="margin-left: 10px; margin-right: 10px; float: right; width: 135px; height: 135px;" src="/public/site/images/boglarka/esci-button.png"></a> &nbsp;&nbsp;</p> <p>It is also indexed by <a href="https://www.scopus.com/sourceid/13024" target="_blank" rel="noopener">Scopus</a>,&nbsp;<a href="https://dblp.uni-trier.de/db/journals/actaC/index.html" target="_blank" rel="noopener">DBLP</a>, EBSCO and Emerging Sources Citation Index (ESCI).</p> <p>&nbsp;</p> <p>&nbsp;</p> <p><a title="SCImago Journal &amp; Country Rank" href="https://www.scimagojr.com/journalsearch.php?q=13024&amp;tip=sid&amp;exact=no"><img style="margin-left: 10px; margin-right: 10px; float: right; width: 201px; height: 201px;" src="https://www.scimagojr.com/journal_img.php?id=13024" alt=""></a></p> </div> </div> </div> </div> </div> </div> </div> </div> </div> https://cyber.bibl.u-szeged.hu/index.php/actcybern/article/view/4121 Towards a Generic Framework for Trustworthy Program Refactoring 2022-12-30T14:08:20+01:00 Dániel Horpácsi daniel-h@elte.hu Judit Kőszegi koszegijudit@elte.hu Dávid J. Németh ndj@inf.elte.hu <p>Refactoring has to preserve the dynamics of the transformed program with respect to a particular definition of semantics and behavioral equivalence. Apparently, it is always challenging to relate executable refactoring implementations with the formal semantics of the transformed language. There are a number of approaches to specifying program transformations on various kinds of program models, but trustworthiness of refactoring is still to be improved by means of formal verification. We propose a specification formalism and a generic framework for its processing, which claims to allow semi-automatic execution and formal verification, as well as to be adaptable to multiple paradigms.</p> 2021-03-18T00:00:00+01:00 Copyright (c) https://cyber.bibl.u-szeged.hu/index.php/actcybern/article/view/4099 Report on the Differential Testing of Static Analyzers 2022-12-30T14:08:23+01:00 Gábor Horváth xazax@caesar.elte.hu Réka Nikolett Kovács rekanikolett@caesar.elte.hu Péter Szécsi ps95@caesar.elte.hu <p>Program faults, best known as bugs, are practically unavoidable in today's ever growing software systems. One increasingly popular way of eliminating them, besides tests, dynamic analysis, and fuzzing, is using static analysis based bug-finding tools. Such tools are capable of finding surprisingly sophisticated bugs automatically by inspecting the source code. Their analysis is usually both unsound and incomplete, but still very useful in practice, as they can find non-trivial problems in a reasonable time (e.g. within hours, for an industrial project) without human intervention.</p> <p>Because the problems that static analyzers try to solve are hard, usually intractable, they use various approximations that need to be fine-tuned in order to grant a good user experience (i.e. as many interesting bugs with as few distracting false alarms as possible). For each newly introduced heuristic, this normally happens by performing differential testing of the analyzer on a lot of widely used open source software projects that are known to use related language constructs extensively. In practice, this process is ad hoc, error-prone, poorly reproducible and its results are hard to share.</p> <p>We present a set of tools that aim to support the work of static analyzer developers by making differential testing easier. Our framework includes tools for automatic test suite selection, automated differential experiments, coverage information of increased granularity, statistics collection, metric calculations, and visualizations, all resulting in a convenient, shareable HTML report.</p> 2020-10-22T00:00:00+02:00 Copyright (c) https://cyber.bibl.u-szeged.hu/index.php/actcybern/article/view/4098 Type Inference of Simple Recursive Functions in Scala 2022-12-30T14:08:27+01:00 Gergely Nagy gergely.a.nagy@gmail.com Gábor Oláh olikas@caesar.elte.hu Zoltán Porkoláb gsd@caesar.elte.hu <p>Scala is a well-established multi-paradigm programming language known for its terseness that includes advanced type inference features. Unfortunately this type inferring algorithm does not support typing of recursive functions. This is both against the original design philosophies of Scala and puts an unnecessary burden on the programmer. In this paper we propose a method to compute the return types for simple recursive functions in Scala. We make a heuristic assumption on the return type based on the non-recursive execution branches and provide a proof of this method's correctness. The algorithm does not have a significant effect on the compilation speed. We implemented our method as an extension prototype in the Scala compiler and used it to successfully test our method on various examples. The compiler extension prototype is available for further tests.</p> 2020-10-22T00:00:00+02:00 Copyright (c) https://cyber.bibl.u-szeged.hu/index.php/actcybern/article/view/4120 Adaptation of a Refactoring DSL for the Object-Oriented Paradigm 2022-12-30T14:08:28+01:00 Dávid J. Németh ndj@inf.elte.hu Dániel Horpácsi daniel-h@elte.hu Máté Tejfel matej@inf.elte.hu <p>Many development environments offer refactorings aimed at improving non-functional properties of software, but we have no guarantees that these transformations indeed preserve the observable behavior of the source code they are applied on. An existing domain-specific language makes it possible to formalize automatically verifiable refactorings via instantiating predefined transformation schemes with conditional term rewrite rules.</p> <p>We present a proposal for adapting this language from the functional to the object-oriented programming paradigm, using Java instead of Erlang as a representative. The behavior-preserving property of discussed refactorings is characterized with a multilayered definition of equivalence for Java programs, including the conformity relation of class hierarchies. Based on the decomposition of a complex refactoring rule, we show how new transformation schemes can be identified, along with modifications and extensions of the description language required to accommodate them. Finally, we formally define the chosen base refactoring as a composition of scheme instances.</p> 2021-03-18T00:00:00+01:00 Copyright (c) https://cyber.bibl.u-szeged.hu/index.php/actcybern/article/view/4101 A Modern Look at GRIN, an Optimizing Functional Language Back End 2022-12-30T14:08:28+01:00 Peter Podlovics peter.d.podlovics@gmail.com Csaba Hruska csaba.hruska@gmail.com Andor Pénzes andor.penzes@gmail.com <p>GRIN is short for Graph Reduction Intermediate Notation, a modern back end for lazy functional languages. Most of the currently available compilers for such languages share a common flaw: they can only optimize programs on a per-module basis. The GRIN framework allows for interprocedural whole program analysis, enabling optimizing code transformations across functions and modules as well.</p> <p>Some implementations of GRIN already exist, but most of them were developed only for experimentation purposes. Thus, they either compromise on low-level efficiency or contain ad hoc modifications compared to the original specification.</p> <p>Our goal is to provide a full-fledged implementation of GRIN by combining the currently available best technologies like LLVM, and evaluate the framework's effectiveness by measuring how the optimizer improves the performance of certain programs. We also present some improvements to the already existing components of the framework. Some of these improvements include a typed representation for the intermediate language and an interprocedural program optimization, the dead data elimination.</p> 2021-02-03T00:00:00+01:00 Copyright (c) https://cyber.bibl.u-szeged.hu/index.php/actcybern/article/view/4119 Visualisation of Jenkins Pipelines 2022-12-30T14:08:29+01:00 Ádám Révész adamrevesz@gmail.com Norbert Pataki patakino@elte.hu <p>Continuous Integration (CI) is an essential approach in modern software engineering. CI tools help merging the recent commits from the developers, thus the bugs can be realized in an early phase of development and integration hell can be avoided. Jenkins is the most well-known and most widely-used CI tool.</p> <p>Pipelines become first-class citizen in Jenkins 2. Pipelines consist of stages, such as compiling, building Docker image, integration testing, etc. However, comprehensive Jenkins pipelines are hard to see through and understand. In this paper, we argue for a modern visualisation of Jenkins pipelines. We present our solution for making Jenkins pipelines comprehensible on the dashboard.</p> 2021-03-18T00:00:00+01:00 Copyright (c) https://cyber.bibl.u-szeged.hu/index.php/actcybern/article/view/4117 Instantiation of Java Generics 2022-12-30T14:08:30+01:00 Péter Soha sohaur@inf.elte.hu Norbert Pataki patakino@elte.hu <p>Type parametrization is an essential construct in modern programming languages. On one hand, Java offers generics, on the other hand, C++ offers templates for highly reusable code. The mechanism between these constructs differs and affects usage and runtime performance, as well. Java uses type erasure, C++ deals with instantiations.<br><br>In this paper, we argue for an approach in Java which is similar to C++ template construct. We evaluate the runtime performance of instantiated code and we present our tool which is able to use Java generics as templates. This tool generates Java source code. We present how this approach improves the usage of Java generics.</p> 2022-01-21T00:00:00+01:00 Copyright (c) https://cyber.bibl.u-szeged.hu/index.php/actcybern/article/view/4104 Improved Loop Execution Modeling in the Clang Static Analyzer 2022-12-30T14:08:30+01:00 Péter György Szécsi szepet95@gmail.com Gábor Horváth xazax@inf.elte.hu Zoltán Porkoláb gsd@inf.elte.hu <p>The LLVM Clang Static Analyzer is a source code analysis tool which aims to find bugs in C, C++, and Objective-C programs using symbolic execution, i.e. it simulates the possible execution paths of the code. Currently the simulation of the loops is somewhat naive (but efficient), unrolling the loops a predefined constant number of times. However, this approach can result in a loss of coverage in various cases. This study aims to introduce two alternative approaches which can extend the current method and can be applied simultaneously: (1) determining loops worth to fully unroll with applied heuristics, and (2) using a widening mechanism to simulate an arbitrary number of iteration steps. These methods were evaluated on numerous open source projects, and proved to increase coverage in most of the cases. This work also laid the infrastructure for future loop modeling improvements.</p> 2020-10-22T00:00:00+02:00 Copyright (c) https://cyber.bibl.u-szeged.hu/index.php/actcybern/article/view/4100 Detecting Uninitialized Variables in C++ with the Clang Static Analyzer 2022-12-30T14:08:31+01:00 Kristóf Umann dkszelethus@gmail.com Zoltán Porkoláb gsd@inf.elte.hu <p>Uninitialized variables have been a source of errors since the beginning of software engineering. Some programming languages (e.g. Java and Python) will automatically zero-initialize such variables, but others, like C and C++, leave their state undefined. While laying aside initialization in C and C++ might be a performance advantage if an initial value can't be supplied, working with such variables is an undefined behavior, and is a common source of instabilities and crashes. To avoid such errors, whenever meaningful initialization is possible, it should be used. Tools for detecting these errors run time have existed for decades, but those require the problematic code to be executed. Since in many cases the number of possible execution paths are combinatoric, static analysis techniques emerged as an alternative. In this paper, we overview the technique for detecting uninitialized C++ variables using the Clang Static Analyzer, and describe various heuristics to guess whether a specific variable was left in an undefined state intentionally. We implemented a prototype tool based on our idea and successfully tested it on large open source projects.</p> 2020-11-19T00:00:00+01:00 Copyright (c)