YBYegor Bugayenko

Yegor Bugayenko

*This is an algorithmically generated author record based on publicly available information.

Yegor Bugayenko has a total of 24 co-authors. Here are the top co-authors by number of shared publications:


Latest Publications

  • Open Access

    Compile-Time Java Stream Fusion via mapMulti

    by Yegor Bugayenko, Maxim Trunnikov, Vladimir Zakharov

  • Open Access

    CAM: A Collection of Snapshots of GitHub Java Repositories Together with Metrics

    by Yegor Bugayenko

    Even though numerous researchers require stable datasets along with source code and basic metrics calculated on them, neither GitHub nor any other code hosting platform provides such a resource. Consequently, each researcher must download their own data, compute the necessary metrics, and then publish the dataset somewhere to ensure it remains accessible indefinitely. Our CAM (stands for ``Classes and Metrics'') project addresses this need. It is an open-source software capable of cloning Java repositories from GitHub, filtering out unnecessary files, parsing Java classes, and computing metrics such as Cyclomatic Complexity, Halstead Effort and Volume, C\&K metrics, Maintainability Metrics, LCOM5 and HND, as well as some Git-based Metrics. At least once a year, we execute the entire script, a process which requires a minimum of ten days on a very powerful server, to generate a new dataset. Subsequently, we publish it on Amazon S3, thereby ensuring its availability as a reference for researchers. The latest archive of 2.2Gb that we published on the 2nd of March, 2024 includes 532K Java classes with 48 metrics for each class.

  • Open Access

    An Algorithm for Partial Elimination of Jumps in an Object-Oriented Dataflow Language

    by Yegor Bugayenko, Mikhail Lipanin

    Despite enduring criticisms spanning several decades, jump statements such as goto, break, continue, and return remain prevalent in imperative programming languages, including but not limited to C++, Java, and Python. The academic community has yet to reach a consensus regarding whether the refactoring of source code in these languages to eliminate such statements can indeed enhance code readability. Nevertheless, it is evident that automated program analysis would derive substantial benefits from this refactoring, given that structured code analysis is more straightforward than analyzing code that exhibits capricious alterations in its control flow. While algorithms tailored for this refactoring process have been proposed for certain imperative languages, we introduce a congruent algorithm, specifically designed for a dataflow programming language. It’s important to note that although dataflow languages lack jump statements, they might incorporate jump-objects (in object-oriented contexts) or jump-functions (within functional paradigms). Our algorithm has been instantiated as a command-line tool tailored for refactoring EO, an object-oriented dataflow language. Preliminary tests with several EO programs have validated the tool’s efficacy. Leveraging φ -calculas, we provide a formal proof underscoring the validity of every transformation encompassed within our algorithm.

  • Open Access

    Object Specialization to Partially Reduce Polymorphism of Attributes

    by Alena Vasileva, Yegor Bugayenko

    In object-oriented programming languages, objects with polymorphic attributes can negatively impact performance and hinder static analysis. These attributes require dynamic dispatch, which is slower than static binding, and complicate the analysis process. We propose a novel algorithm for object specialization that addresses this issue by replacing polymorphic attributes with monomorphic ones, resulting in improved performance and simplified static analysis. Our algorithm is a new approach compared to existing function specialization algorithms. We provide a proof of the algorithm’s soundness and correctness, and present an implementation of the algorithm as a software tool. Empirical evaluation shows that our approach achieves significant improvements in performance and simplifies the static analysis process. Our algorithm can be applied to a variety of object-oriented languages such as Java and Python.


  • Transformation of C Programming Language Memory Model into Object-Oriented Representation of EO Language

    by A. I. Legalov, Y. G. Bugayenko, N. K. Chuykin, M. V. Shipitsin, Y. I. Riabtsev, A. N. Kamenskiy

    The paper analyzes the possibilities of transforming C programming language constructs into objects of EO programming language. The key challenge of the me

  • Open Access

    Prioritizing tasks in software development: A systematic literature review

    by Yegor Bugayenko, Ayomide Bakare, Arina Cheverda, Mirko Farina, Artem Kruglov, Yaroslav Plaksin, Witold Pedrycz, Giancarlo Succi

    Task prioritization is one of the most researched areas in software development. Given the huge number of papers written on the topic, it might be challenging for IT practitioners–software developers, and IT project managers–to find the most appropriate tools or methods developed to date to deal with this important issue. The main goal of this work is therefore to review the current state of research and practice on task prioritization in the Software Engineering domain and to individuate the most effective ranking tools and techniques used in the industry. For this purpose, we conducted a systematic literature review guided and inspired by the Preferred Reporting Items for Systematic Reviews and Meta-Analyses, otherwise known as the PRISMA statement. Based on our analysis, we can make a number of important observations for the field. Firstly, we found that most of the task prioritization approaches developed to date involve a specific type of prioritization strategy—bug prioritization. Secondly, the most recent works we review investigate task prioritization in terms of “pull request prioritization” and “issue prioritization,” (and we speculate that the number of such works will significantly increase due to the explosion of version control and issue management software systems). Thirdly, we remark that the most frequently used metrics for measuring the quality of a prioritization model are f-score, precision, recall, and accuracy.


  • Open Access

    Analyses of Software Data and Their Interpretations: A Framework of Information Granules

    by Ayomide Bakare, Yegor Bugayenko, Artem Kruglov, Witold Pedrycz, Giancarlo Succi

    Data collected from software applications such as issue management systems or version control systems are abstract and require their thorough and comprehensive analysis. Automated issue generation is an understudied area in automated software development despite its effectiveness, safety, and satisfaction which increases developer productivity. Analysis of software data from automated issue generation provides information which could be used by relevant tools or monitored as any other feature in the development process. In this paper, we systematically apply a suite of methods, including clustering algorithms, cluster validity indexes, and information granularity, to generate explainable prototypes using software data from generated GitHub Issues. Among other approaches of data analytics, we employ the principle of justifiable granularity and a method of optimal information allocation. These methods are applied to two dimensional synthetic Gaussian data to illustrate the performance of the methods. The study provides the experimental results using the methods applied to real industrial data coming from the 0pdd software. The resultant groups provide some insights into structure for organising puzzles with similar characteristics.

  • Open Access

    An experience in automatically extracting CAPAs from code repositories

    by Yegor Bugayenko, Imre Delgado, Firas Jolha, Zamira Kholmatova, Artem Kruglov, Witold Pedrycz, Giancarlo Succi, Xavier Vasquez

    TOM (stands for Theoretically Objective Measurements of Software Development Projects) is a set of services that are in charge of helping developers or teams in the process of identifying anomilies within their software development process, and providing a list of preventive or corrective actions (aka CAPAS) that positively impact the process. and in this way to improve the quality of the final product and its development process. In order to get help from TOM, it is as simple as adding our bot (@0capa) to the list of collaborators in your repository, and with this our bot will automatically take care of obtaining different metrics from your repository, in order to suggest actions to take into account to that in your future updates the identified anomalies are not repeated. This paper presents the underlying research on this idea.

  • Open Access

    Transformation of C Programming Language Memory Model into Object-Oriented Representation of EO Language

    by Alexander I. Legalov, Yegor G. Bugayenko, Nickolay K. Chuykin, Maksim V. Shipitsin, Yaroslav I. Riabtsev, Andrey N. Kamenskiy

    The paper analyzes the possibilities of transforming C programming language constructs into objects of EO programming language. The key challenge of the method is the transpilation from a system programming language into a language of a higher level of abstraction, which doesn’t allow direct manipulations with computer memory. Almost all application and domain-oriented programming languages disable such direct access to memory. Operations that need to be supported in this case include the use of dereferenced pointers, the imposition of data of different types in the same memory area, and different interpretation of the same data which is located in the same memory address space. A decision was made to create additional EO-objects that directly simulate the interaction with computer memory as in C language. These objects encapsulate unreliable data operations which use pointers. An abstract memory object was proposed for simulating the capabilities of C language to provide interaction with computer memory. The memory object is essentially an array of bytes. It is possible to write into memory and read from memory at a given index. The number of bytes read or written depends on which object is being used. The transformation of various C language constructs into EO code is considered at the level of the compilation unit. To study the variants and analyze the results a transpiler was developed that provides necessary transformations. It is implemented on the basis of Clang, which forms an abstract syntax tree. This tree is processed using LibTooling and LibASTMatchers libraries. As a result of compiling a C program, code in EO language is generated. The considered approach turns out to be appropriate for solving different problems. One of such problems is static code analysis. Such solutions make it possible to isolate low-level code fragments into separate program objects, focusing on their study and possible transformations into more reliable code.


  • Open Access

    Volatility metric to detect anomalies in source code repositories

    by Yegor Bugayenko

    A new metric was introduced to calculate the distance between actively modified files in a source code repository and the files, which are rarely modified and may be considered abandoned or even dead. It was empirically demonstrated that larger repositories have larger values of the introduced metric. The metric may be used for earlier detection of code maintenance anomalies and helping software developers make the decision of splitting the repository into smaller ones in order to prevent maintainability issues.