The paper continues the previous work of the authors where an abstract model of a distributed network containing only hosts and switches has been developed. Hosts offer certain services to users; messages (requests) between hosts are forwarded through intermediate nodes according to switching rules, and the node configuration determines a set of paths from host to host along which packets are forwarded. The situation is modeled using a graph of physical connections where the graph nodes are hosts and switches, and each host (like a switch) contains a system of switching rules. The possibility of increasing the efficiency of the network is based on using of information about service classes, into which the set of all services provided by network hosts is divided. Based on the information about service classes, the tasks of message transmission, (incremental) node configuration are considered depending on various changes of network parameters. 

This paper is devoted to the application of suffix codes in the modular metric for solving clustering and k-nearest neighbors (KNN) problems. The advantages of using the modular metric over the Euclidean metric are considered, especially in high-dimensional spaces. The main emphasis is placed on the development of efficient clustering and k-nearest neighbors algorithms using codes that can correct errors in the modular metric. The proposed approach provides polynomial complexity with respect to the training sample dimension, which makes it promising for machine learning applications with large datasets and high-performance requirements.

Modern computational tasks involving large-number processing demand not only high precision but also significant operational speed. In this context, the residue number system provides an effective approach for parallel processing of large numbers, with applications in cryptography, signal processing, and artificial neural networks. The primary task in defining such a system is determining its basis. This paper presents an algorithm for generating compact residue number system bases based on the Diemitko theorem. The proposed algorithm generates bases 15.5% faster on average than Pseudo-Mersenne-based construction and 75.7% faster than the general filtering method. Comparative analysis demonstrates that using compact bases delivers an average 12% acceleration in modular operations compared to special moduli sets.

The congestion control algorithms in the TCP protocol use RTT predictions indirectly or directly to determine congestion. The main algorithm for predicting RTT based on a weighted moving average is the Jacobson Algorithm. However, this algorithm may not work quite efficiently if the RTT is subject to a heavy-tailed distribution. In this paper, we propose an RTT prediction method based on supervised learning in both the offline and online cases. The results show improvement in the performance of algorithms based on supervised learning compared to the classical Jacobson algorithm in terms of MAPE, MAE, and MSE metrics. In addition, the high efficiency of online learning in comparison with offline learning in the case of data drift is shown.

This paper discusses a particular type of subtle use-after-free errors in the Direct Rendering Manager (DRM) subsystem of the Linux kernel. These errors occur due to incorrectly allocated memory for structures accessible from user space via device callbacks. To detect these errors, we use a shape analysis based on the Symbolic Memory Graph (SMG) domain. We introduce the coloring of allocated memory to track its origin. Among 186 Linux DRM drivers, we have found 6 violations of the proposed rule.

The article examines machine learning methods for detecting the introduction of SQL code into the network logs using the KNIME program, based on finding patterns between incoming features and subsequent forecasting in a binary classification problem. Unlike existing works, this article examines the effectiveness of five tree-based machine learning methods. The content and sequence of work stages are presented. The highest results were shown by the Random Forest method (accuracy – 97.58%; area under the ROC curve is 0.976).

This paper introduces the Dynamic Adaptive Packet Buffering (DAPB) algorithm. Designed to enhance data transfer efficiency in modern networking environments, it is built on the principles of Nagle's algorithm. DAPB addresses the limitations of existing buffering techniques by dynamically adjusting its behavior based on real-time network conditions, application requirements, and latency sensitivity. The algorithm incorporates context-sensitive buffering, adaptive timeout mechanisms, and machine learning-driven predictions to achieve a balance between efficiency, latency, and energy consumption. DAPB's context-aware buffering tailors its strategy to the specific needs of the application, minimizing buffering for latency-sensitive applications like VoIP and online gaming, while maximizing buffering for throughput-sensitive applications like file transfers. The adaptive timeout mechanism dynamically adjusts the waiting timeout based on network conditions such as round-trip time, packet loss, and jitter, ensuring optimal performance under varying workloads. Machine learning models are used to predict optimal buffer sizes and timeout values, leveraging historical data and real-time metrics to improve decision-making. The algorithm also features selective aggregation, intelligently deciding which packets to aggregate and which to send immediately. This ensures that urgent packets are transmitted without delay, while nonurgent packets are aggregated to reduce overhead. Additionally, DAPB prioritizes energy efficiency by optimizing buffer sizes and timeout values, making it suitable for energy-constrained environments like edge computing and IoT devices. The DAPB algorithm is expected to improve the data transfer performance in various scenarios. Compared to the standard Nagle algorithm, the DAPB algorithm is expected to reduce latency, improve throughput, and enhance energy efficiency. This paper is the result of a research project implemented as part of the Basic Research Program at the National Research University Higher School of Economics (HSE University).

The popularity of using LLM for code generation makes it mandatory to comprehensively verify the security and reliability of the generated code. To verify the generated code, it is suggested to use the static analyzer Svace, which checks the executable code using the built-in compiler and checks the code for weaknesses. The result of the generation is processed using Svace and receives prompts with detected warnings or errors in the code and requests corrections from LLM after generation. In addition, we fine-tune the Qwen2.5-Coder model using direct preference optimization (DPO) for error code pairs that include common syntax errors and runtime errors. This reduced the error rate, including syntactic errors and vulnerabilities, by 20\%. To evaluate the models, we collected a specialized dataset from open sets for LLM evaluation, focusing on tasks in which the models generate erroneous code. The experimental results show that fine-tuning the model with a focus on code quality allows you to generate code that reduces typical errors. In this work, we combine an iterative prompting mechanism with DPO to improve the security and accuracy of LLM code generation.

Recently, large language models (LLMs), those pretrained on code, have demonstrated strong capabilities in generating programs from informal natural language intent. However, LLM-generated code is prone to bugs. Developers interacting with LLMs seek trusted code and, ideally, clear indications of potential bugs and vulnerabilities. Verified code can mitigate potential business risks associated with adopting generated code. We use model-agnostic framework CodePatchLLM, an extension for LLM that utilizes Svace feedback to enhance code generation quality. We evaluate CodePatchLLM on four popular LLMs across three datasets. Our experiments show an average absolute reduction of 19.1% in static analyzer warnings for Java across all datasets and models, while preserving pass@1 code generation accuracy.

The article presents an experimental evaluation of SVAN, a static analysis tool designed for functional verification of RTL models written in Verilog and SystemVerilog. The research addresses the growing need for reliable domestic EDA tools, particularly in light of restrictions on proprietary solutions. SVAN’s architecture integrates formal methods and heuristic approaches to detect a wide range of errors, including syntactic issues, coding style violations, logical inconsistencies, and security vulnerabilities. Empirical testing on open-source hardware benchmarks demonstrates SVAN’s superior effectiveness compared to Synopsys VCS and Verilator, with a 73% broader error detection spectrum and 25-23% higher error identification rate, respectively. Key advantages of SVAN include high analysis accuracy and detailed error classification. However, limitations such as reduced flexibility in handling mixed-language designs highlight areas for future improvement. The study underscores SVAN’s potential as a competitive tool for static verification in electronic design automation.

Currently, the information technologies industry is a leader in growth rate among the main economic sectors. However, the most important components of the development process, such as estimation and refactoring of program products, still remain without generic tools. Therefore, our main goal is to design a mean of unified modification and formal evaluation for code in object-oriented programming languages. We use refactoring patterns to define code modifications, and code metrics calculation to assess its characteristics. Our tool should help developers to make decisions connected with code quality and its modification necessity, automatize that change. Actually, it may be used in organizations and educational institutions. We have developed a domain specific language to unify the specification of object-oriented languages. Furthermore, a research prototype of the tool has been created. 3 object-oriented languages descriptions and 6 diverse refactoring patterns have been developed to demonstrate capabilities of the approach.

The study explores optimization methods for improving image processing performance on the RISC‑V platform with Lichee Pi 4A. The research focuses on real-time video processing within a microservice-based self-service system. Several existing optimization strategies are considered and evaluated, including neural network model optimization, hardware acceleration using RVV vector instructions and leveraging the built-in Neural Processing Unit (NPU). The profiling results on existing strategies indicate that object detection and feature extraction consume the most computation resources. In order to eliminate the performance gap, the model quantization to INT8 format is implemented, that allows to reduce memory usage and inference latency. Additionally, a modified ONNX Runtime version is deployed to support NPU acceleration. These improvements led to 75% reduction in model size and a 35% decrease in inference latency. The study concludes that hardware-aware optimizations significantly enchase performance on the RISC-V (Lichee Pi 4A) platform. The main issue encountered is the low processing speed on Lichee Pi 4A, with a current frame rate of only 0.05 FPS, which in unsuitable for practical usage.

Automatic code generation by large language models (LLMs) has achieved significant success, yet it still faces challenges when dealing with complex and large codebases, especially in languages like Java. The limitations of LLM context windows and the complexity of debugging generated code are key obstacles. This paper presents an approach aimed at improving Java code generation and debugging. We propose using the Associative Recurrent Memory Transformer (ARMT) model, which extends the context window and has enhanced memory capabilities, to address two tasks: 1) selecting the most relevant snippets from the existing codebase for generating new code; 2) selecting the most significant parts of stack traces and runtime data for iterative debugging. This approach is integrated with an iterative debugging loop, embodied in our developing system "JavaCapsule" (inspired by PyCapsule for Python), which includes compilation and test execution in a controlled Docker environment using Gradle. It is expected that the proposed method will enhance the accuracy and relevance of generated Java code, particularly in the context of large projects, and improve the automated debugging process. Such benchmarks like JavaBench further underscore the need for such focused advancements. This paper is an output of a research project implemented as part of the Basic Research Program at the National Research University Higher School of Economics (HSE University).

The paper presents a modified algorithm for local alignment of genetic sequences based on the Smith-Waterman algorithm, using window method and run-length encoding. an experimental comparison of the performance of the proposed approach with the classical algorithm by such metrics as execution time, average and peak memory usage is carried out. The results demonstrate the effectiveness of the modification while preserving the quality of alignment, especially in resource-constrained environments. The work has practical implications for bioinformatics tasks involving genome analysis, gene annotation and homologous site search.

Recently, the relevance of generative models has increased significantly, and their scope of application is becoming increasingly larger. However, the main problem with modern large language models is that there are jailbreak attacks that can force the model to produce prohibited information. Recent studies have presented adversarial vulnerabilities in the class of "jailbreak" attacks on large language models in a black-box, paraphrase-based scenario. We aim to continue and expand this research and develop models that are secure against such attacks using a "red-teaming" procedure. Moreover, we conduct extensive experiments that evaluate the quality of text generation of defended models on various benchmarks.

Currently, a huge amount of data is presented in the form of tables. They are widely used to solve various practical problems in different domains. Specialized methods and software are developed for semantic interpretation (annotation) of tables and construction of knowledge graphs based on them. Effective testing of such software requires the creation and use of Russian-language datasets. This paper proposes a Russian-language tabular dataset, called RF-200, containing 200 tables from 26 domains labeled using the Talisman platform. The results of testing the performance of our approach for fact extraction from Russian-language tables using RF-200 are presented, in which the F1 reached a value of 0.464, surpassing traditional methods of fact extraction from texts (F1 = 0.277). The results emphasize the importance of specialized solutions for working with structured data, especially for Russian-language sources. The practical significance of the work lies in the integration of the approach into the Talisman platform, which expands the capabilities of semantic analytics carried out on tables. The study contributes to the automation of table processing, solving the problem of semantic interpretation in the context of linguistic diversity, and opens up prospects for the integration of deep learning methods and scaling of the created dataset.

This study investigates the application of five requirements prioritization methods – MoSCoW, Kano Model, Weighted Scoring, RICE, and Cost of Delay (CoD) – in the development of a web application for personalized nutrition. The research addresses the challenge of managing limited resources (time, financial, and human) while maximizing user value and ensuring safety in a high-stakes domain. Through a comparative analysis, the strengths and weaknesses of each method are evaluated, revealing that a hybrid approach, tailored to different development phases, is most effective. Core functionalities such as allergen management and diet personalization consistently ranked as high priority across all methods. The study proposes a dynamic framework that integrates MoSCoW and Weighted Scoring for MVP definition, and RICE and Kano for scaling, emphasizing the importance of balancing safety, user satisfaction, and implementation complexity. The findings offer practical recommendations for developers and product managers in health-tech and other regulated domains.