Acta Cybernetica

Preface

2024-07-24T13:01:03+02:00

The 13th Conference of PhD Students in Computer Science (CSCS) was organized by the Institute of Informatics of the University of Szeged (SZTE) and held in Szeged, Hungary, between June 29 - July 1, 2022.

Single and Combined Algorithms for Open Set Classification on Image Datasets

2024-07-24T13:01:03+02:00

Generally, classification models have closed nature, and they are constrained by the number of classes in the training data. Hence, classifying "unknown" - OOD (out-of-distribution) - samples is challenging, especially in the so called "open set" problem. We propose and investigate different solutions - single and combined algorithms - to tackle this task, where we use and expand a K-classifier to be able to identify K+1 classes. They do not require any retraining or modification on the K-classifier architecture. We show their strengths when avoiding type I or type II errors is fundamental. We also present a mathematical representation for the task to estimate the K+1 classification accuracy, and an inequality that defines its boundaries. Additionally, we introduce a formula to calculate the exact K+1 classification accuracy.

Towards a Block-Level ML-Based Python Vulnerability Detection Tool

2024-07-24T13:01:05+02:00

Computer software is driving our everyday life, therefore their security is pivotal. Unfortunately, security flaws are common in software systems, which can result in a variety of serious repercussions, including data loss, secret information disclosure, manipulation, or system failure. Although techniques for detecting vulnerable code exist, the improvement of their accuracy and effectiveness to a practically applicable level remains a challenge. Many existing methods require a substantial amount of human expert labor to develop attributes that indicate vulnerabilities. In previous work, we have shown that machine learning is suitable for solving the issue automatically by learning features from a vast collection of real-world code and predicting vulnerable code locations. Applying a BERT-based code embedding, LSTM models with the best hyperparameters were able to identify seven different security flaws in Python source code with high precision (average of 91%) and recall (average of 83%). Upon the encouraging first empirical results, we go beyond this paper and discuss the challenges of applying these models in practice and outlining a method that solves these issues. Our goal is to develop a hands-on tool for developers that they can use to pinpoint potentially vulnerable spots in their code.

A Formalisation of Core Erlang, a Concurrent Actor Language

2024-07-24T13:01:07+02:00

In order to reason about the behaviour of programs described in a programming language, a mathematically rigorous definition of that language is needed. In this paper, we present a machine-checked formalisation of concurrent Core Erlang (a subset of Erlang) based on our previous formalisations of its sequential sublanguage. We define a modular, frame stack semantics, show how program evaluation is carried out with it, and prove a number of properties (e.g. determinism, confluence). Finally, we define program equivalence based on bisimulations and prove that side-effect-free evaluation is a bisimulation. This research is part of a wider project that aims to verify refactorings to prove that particular program code transformations preserve program behaviour.

Identifying Concurrent Behaviours in Erlang Legacy Systems

2024-07-24T13:01:08+02:00

In Erlang, behaviours are special forms of design patterns. There are many benefits to using behaviours. For example, behaviours can help abstract away the most common parts when solving similar problems. Design pattern recognition may help understand the source code of the software. It can provide structured information about the purpose of specific parts and the design decisions behind the implementation. For object-oriented languages, several tools exist that use different approaches and methods to identify design patterns. We present a method for identifying source code fragments in legacy Erlang systems amenable to transforming into client-server Erlang design patterns. In our analysis, we identify the base set of server candidates using concurrent process analysis and narrow down the result using further static analysis knowledge using the RefactorErl framework.

Using Version Control Information to Visualize Developers' Knowledge

2024-07-24T15:59:25+02:00

It is not always clear in case of a software project who has the right amount of knowledge concerning a certain module or file. Programmers frequently ask questions like "Who knows the most about this code?" or "Who can I ask for help when I work on this module?". In a large, long-term software product, knowledge is distributed in an uneven way among developers. Developer fluctuation during the product lifetime might cause some parts of the code to be known very well by a multitude of developers, while other parts might sink to the "gray zone", where developer competence is dangerously scarce. It is important for the project management to identify such critical points, to avoid the complete loss of competence. Version control repositories contain loads of useful information about the evolution of a software project.

This paper presents a developer-centered visualization that is intended to show individual, team-bound and company-bound knowledge of large legacy projects. The competence information is computed from the extracted version control information from Git repositories. The calculated competence value is based on the number of commits per developer and their significance. Aggregated views for teams and companies are available based on various heuristics. The visualization is implemented as a new plugin in CodeCompass, a standalone, open-source code comprehension software. Project managers and individual developers may both profit from the tool, whether it concerns software evolution, human-resource management, architecture, knowledge catch-up, or blame.

Ontology Supported Domain Knowledge Module for E-Tutoring System

2024-07-24T13:01:09+02:00

E-tutoring Systems are computer applications that provide direct customized education to learners. The E-tutoring system usually includes four modules: Teaching Module, Knowledge Module, Learner Module, and Learner Interface. This investigation focuses on Knowledge Module, considering design and implementation for a selected domain. One of the useful mechanisms of Artificial Intelligence (AI) that is commonly used to formalize domain knowledge module concepts and their relation in an E-tutoring systems is ontology. The term ontology is described as a representation of the entities in a domain and the way those entities connect to each other. This paper introduces a domain knowledge module for an E-tutoring system that allows knowledge stored in a well-defined form to support reusability, shareability, flexibility, and standardability and to assist the storage of transfer and prerequisite knowledge relationships. The introduced knowledge domain module is designed in two ways the general concepts domain knowledge module and a specific domain knowledge module ontology. This innovative technique is helpful for students in enhancing their learning progress. Combining the proposed ontology domain knowledge module with an E-tutoring system can enhance the quality of intelligent problem-solving. Also, it will be possible to reuse the knowledge domains. As a result, the proposal of the domain knowledge module for the E-tutoring system can enhance the teaching and learning process, support recommendations, and generate hints. In the future, the suggested module can be improved by adding some functionalities and automatically supporting the generation of problems and their solutions.

Comparing Structural Constraints for Accelerated Branch and Bound Solver of Process Network Synthesis Problems

2024-07-24T13:01:10+02:00

The P-Graph methodology can be used to find the optimal solution for large processing system. This methodology solves the combinatorial part of the problem more efficiently than the traditional branch and bound method due to the utilized relationships inherent in the structure. However, reducing the number of possibilities developed in the constraint functions also plays a major role in this algorithm. In this publication, we present a new constraint function that also takes into account the minimum cost structure and compares it with earlier versions.

Standardized Telemedicine Software Development Kit with Hybrid Cloud Support

2024-07-24T13:01:10+02:00

In modern Web development, it is expected that systems operating in the same area can be easily integrated. For common integration points, it is recommended to use a standardized data model and a common interface during the development as this will facilitate further integrations. The use of the cloud infrastructure is increasingly popular in telemedicine, but taking into account the goals, the productivity of the development, the availability of the system and the various regulations, choosing the right solution is not trivial. Inclouded platform consists of numerous currently active telemedical microservices that are working with a common software development kit. This tool provides a standardized data model for document-oriented database systems, has support for public and private clouds by using the classic Data Access Object (DAO) analogy and contains a lot of convenient functions as well. Furthermore, it is found that our solutions can significantly increase development productivity and is confirmed by measurements taken which involved software developers.

Quadratic Displacement Maps for Heightmap Rendering

2024-07-24T13:01:11+02:00

We present a higher-order representation of heightfields by constructing unbounding revolved parabolas about every texel of the height texture. These surfaces of revolution do not intersect the interior of the volume defined by the heightfield. We present a simple generation algorithm and show that these maps can be rendered by computing intersections between lines and parabolas in the plane. We compare its quality and performance with cone step mapping.

The Influence of the Nonfunctional Requirements on the Data Model

2024-07-24T13:01:11+02:00

During the design and development of real-world telemedicine applications, the data model evolves significantly along the datapath. The model itself, the storage technique, and the user interface are the most common contributors. This relates to non-functional requirements. The size and complexity of the domain model may also be significantly influenced by standards. This phenomenon is distinct from data model erosion, which occurs when the data model changes due to a software developer's fault and non-properly defined interfaces. This is occurring by design. We are unaware of any technique, including OMG's Unified Modeling Language (UML), that focuses on this aspect of complex systems: the change of the data model along the datapath. In this article, we investigate this phenomenon and, in addition to identifying the locations where this change may occur, we classify the modifications depending on the possible influence a specific model change may have on the system's overall properties. This paper presents a novel methodology for complex system datapath analysis and demonstrates its application to a selection of telemedicine-related applications. This technique illustrates the possible effect of non-functional requirements on the datapath and the potential consequences of these modifications.

Integer Programming Based Optimization of Power Consumption for Data Center Networks

2024-07-24T13:01:12+02:00

With the quickly developing data centers in smart cities, reducing energy consumption and improving network performance, as well as economic benefits, are essential research topics. In particular, Data Center Networks do not always run at full capacity, which leads to significant energy consumption. This paper experiments with a range of optimization tools to find the optimal solutions for the Integer Linear Programming (ILP) model of network power consumption. The study reports on experiments under three communication patterns (near, long, and random), measuring runtime and memory consumption in order to evaluate the performance of different ILP solvers.
While the results show that, for near traffic pattern, most of the tools rapidly converge to the optimal solution, CP-SAT provides the most stable performance and outperforms the other solvers for the long traffic pattern. On the other hand, for random traffic pattern, Gurobi can be considered to be the best choice, since it is able to solve all the benchmark instances under the time limit and finds solutions faster by 1 or 2 orders of magnitude than the other solvers do.

Extracting Line Parameters of Woven Wire Mesh in Images under Directional Illumination

2024-07-24T13:01:13+02:00

Localizing the wires of a mesh in an image is important in various image processing applications. This task can be difficult if the wires cannot be detected with simple line detectors, e.g. if corrugated wires of a woven mesh appear as dark and bright segments under directional illumination. Template matching is insufficient if the appearance of the wires varies throughout the image, depending on the viewing angle, and neural networks require computationally expensive training on a well-prepared dataset. We propose an efficient way to extract the line parameters (position and orientation) of the wires of a regular mesh from an image by finding meaningful local minima of a cost function, followed by RANSAC-controlled robust outlier filtering.

Overlaying Control Flow Graphs on P4 Syntax Trees with Gremlin

2024-07-24T13:01:14+02:00

Our overall research aim is to statically derive execution cost and other metrics from program code written in the P4 programming language. For this purpose, we extract a detailed control flow graph (CFG) from the code, that can be turned into a full, formal model of execution, to extract properties -- such as execution cost -- from the model. While CFG extraction and analysis is well researched area, details are dependent on code representation and therefore application of textbook algorithms (often defined over unstructured code listings) to real programming languages is often non-trivial. Our aim is to present an algorithm for CFG extraction over P4 abstract syntax trees (AST). During the extraction we create direct links between nodes of the CFG and the P4 AST: this way we can access all information in the P4 AST during CFG traversal. We are utilizing Gremlin, a graph query language to take advantage of graph databases, but also for compactness and to formally prove algorithm correctness.

Corner-Based Implicit Patches

2024-07-24T13:01:14+02:00

Free-form multi-sided surfaces are often defined by side interpolants (also called ribbons), requiring that the surface has to connect to them with a prescribed degree of smoothness. I-patches represent a family of implicit surfaces defined by an arbitrary number of ribbons. While in the case of parametric surfaces describing ribbons is a well-discussed problem, defining implicit ribbons is a different task.

In this paper, we introduce a new representation, corner I-patches, where implicit corner interpolants are blended together. Corner interpolants are usually simpler, lower-degree surfaces than ribbons. The shape of the patch depends on a handful of scalar parameters; constraining them ensures continuity between adjacent patches. Corner I-patches have several favorable properties that can be exploited for design, volume rendering, or cell-based approximation of complex shapes.

Patient Flow Analysis with a Custom Simulation Engine

2024-07-24T13:01:15+02:00

Patient flow simulation and analysis is one of the oldest IT -based methods used to optimize patient care processes and hospital management. During the pandemic, interest in this domain suddenly increased due to the various constraints and recommendations to reduce the likelihood of further infections in the hospital. Suddenly, metrics such as the number of patients waiting in the same area, the maximum time a patient could stay in a single room, and the minimum distance between patients became important issues to monitor and optimize. Using data and modelling concepts from various hospitals, our team developed a simulation tool that used bpmn models to define an emergency department. We then modified a single day's usual patient flow with various real-world inspired edge cases to evaluate how the simulated flow would change and which stations would become bottlenecks, where the quality of patient care would deteriorate and rooms would become overcrowded. To execute the models, we developed our own tool based on the open-source Camunda modeling tool and the Business Process Model Notation (BPMN) file format. To execute the generated models, we use our own Python-based execution environment based on the SpiffWorkflow library, which permits extensive logging and extensive customization of the attributes analysed. In addition, the modelling toolkit of Camunda was narrowed down and compiled so that it could be easily used by researchers who are not programmers. In the paper, we present both the modeling process and the scenario design process, as well as the results obtained through the runs, including the maximum waiting times during the model runs and the maximum number of patients waiting at once, which allowed us to validate the effectiveness of the framework.

Towards Abstraction-based Probabilistic Program Analysis

2024-07-24T13:01:18+02:00

Probabilistic programs that can represent both probabilistic and non-deterministic choices are useful for creating reliability models of complex safety-critical systems that interact with humans or external systems. Such models are often quite complex, so their analysis can be hindered by state-space explosion. One common approach to deal with this problem is the application of abstraction techniques. We present improvements for an abstraction-refinement scheme for the analysis of probabilistic programs, aiming to improve the scalability of the scheme by adapting modern techniques from qualitative software model checking, and make the analysis result more reliable using better convergence checks. We implemented and evaluated the improvements in our Theta model checking framework.

Uncovering Hidden Dependencies: Constructing Intelligible Path Witnesses using Dataflow Analyses

2024-07-24T16:08:32+02:00

The lack of sound, concise and comprehensive error reports emitted by a static analysis tool can cause increased fixing cost, bottleneck at the availability of experts and even may undermine the trust in static analysis as a method. This paper presents novel techniques to improve the quality of bug reports for static analysis tools that employ symbolic execution. With the combination of data and control dependency analysis, we can identify the relevance of particular code snippets that were previously missing from the report. We demonstrated the benefits of our approach by implementing an improved bug report generator algorithm for the Clang Static Analyzer. After being tested by the open source community our solution became enabled by default in the tool.