Automatic Code Research Articles

Automating modern code review processes with code similarity measurement

Context:Modern code review is a critical component in software development processes, as it ensures security, detects errors early and improves code quality. However, manual reviews can be time-consuming and unreliable. Automated code review can address these issues. Although deep-learning methods have been used to recommend code review comments, they are expensive to train and employ. Instead, information retrieval (IR)-based methods for automatic code review are showing promising results in efficiency, effectiveness, and flexibility. Objective:Our main objective is to determine the optimal combination of the vectorization method and similarity to measure what gives the best results in an automatic code review, thereby improving the performance of IR-based methods. Method:Specifically, we investigate different vectorization methods (Word2Vec, Doc2Vec, Code2Vec, and Transformer) that differ from previous research (TF-IDF and Bag-of-Words), and similarity measures (Cosine, Euclidean, and Manhattan) to capture the semantic similarities between code texts. We evaluate the performance of these methods using standard metrics, such as Blue, Meteor, and Rouge-L, and include the run-time of the models in our results. Results:Our results demonstrate that the Transformer model outperforms the state-of-the-art method in all standard metrics and similarity measurements, achieving a 19.1% improvement in providing exact matches and a 6.2% improvement in recommending reviews closer to human reviews. Conclusion:Our findings suggest that the Transformer model is a highly effective and efficient approach for recommending code review comments that closely resemble those written by humans, providing valuable insight for developing more efficient and effective automated code review systems.

TyBox: An Automatic Design and Code Generation Toolbox for TinyML Incremental On-Device Learning

Incremental on-device learning is one of the most relevant and interesting challenges in the field of Tiny Machine Learning (TinyML). Indeed, differently from traditional TinyML solutions where the training is typically carried out on the Cloud and inference only occurs on the tiny devices (e.g., embedded systems or Internet-of-Things units), incremental on-device TinyML allows both the inference and the training of TinyML models directly on tiny devices. This ability paves the way for TinyML-enabled intelligent devices that can learn directly on the field and adapt to evolving environments, different working conditions, or specific users. The literature in this field is quite limited with very few solutions focusing only on the incremental fine-tuning of machine learning models, whereas a general solution encompassing algorithms and code generation for incremental on-device TinyML is still perceived as missing. The aim of this article is to introduce, to the best of our knowledge for the first time in the literature, a toolbox called TyBox for the automatic design and code generation of incremental on-device TinyML classification models. In more detail, starting from a “static” TinyML model, TyBox is able to (i) automatically design the “incremental” on-device version of the TinyML model that has been suitably designed to take into account the technological constraint on the RAM memory of the target tiny device, and (ii) autonomously provide the C++ codes and libraries to support the inference and learning of the incremental on-device TinyML model directly on the tiny devices. TyBox has been extensively compared with a state-of-the-art incremental learning solution for TinyML and tested on an off-the-shelf tiny device (i.e., the Arduino Nano 33 BLE) in three relevant TinyML application tasks and scenarios: binary image classification, multi-class image classification, and ultra-wide-band human activity recognition. In addition, TyBox is released to the scientific community as a public repository.

Investigating large language models capabilities for automatic code repair in Python

Investigating large language models capabilities for automatic code repair in Python

UniSparse: An Intermediate Language for General Sparse Format Customization

The ongoing trend of hardware specialization has led to a growing use of custom data formats when processing sparse workloads, which are typically memory-bound. These formats facilitate optimized software/hardware implementations by utilizing sparsity pattern- or target-aware data structures and layouts to enhance memory access latency and bandwidth utilization. However, existing sparse tensor programming models and compilers offer little or no support for productively customizing the sparse formats. Additionally, because these frameworks represent formats using a limited set of per-dimension attributes, they lack the flexibility to accommodate numerous new variations of custom sparse data structures and layouts. To overcome this deficiency, we propose UniSparse, an intermediate language that provides a unified abstraction for representing and customizing sparse formats. Unlike the existing attribute-based frameworks, UniSparse decouples the logical representation of the sparse tensor (i.e., the data structure) from its low-level memory layout, enabling the customization of both. As a result, a rich set of format customizations can be succinctly expressed in a small set of well-defined query, mutation, and layout primitives. We also develop a compiler leveraging the MLIR infrastructure, which supports adaptive customization of formats, and automatic code generation of format conversion and compute operations for heterogeneous architectures. We demonstrate the efficacy of our approach through experiments running commonly-used sparse linear algebra operations with specialized formats on multiple different hardware targets, including an Intel CPU, an NVIDIA GPU, an AMD Xilinx FPGA, and a simulated processing-in-memory (PIM) device.

AI based Identification of Students Dress Code in Schools and Universities

Automatic dress code verification (ADCV) uses advanced technology to quickly and fairly check if people are following the dress code. It is more accurate than humans and does not have personal biases. This can be helpful in places like schools, universities, and offices where dress codes are important for safety. One of the great things about it is that it saves time and money. It does not require people to manually check the dress codes, which can be slow and not always consistent. This technology can be adjusted to fit different dress code rules, whether it's a formal office dress or a school uniform. The technology can be customized for different dress code rules, from formal office attire to school uniforms. One notable advantage of ADCV is its capacity to save both time and financial resources. The system gets rid of the requirement for people to manually check dress codes, which can be slow and inconsistent. The technology's flexibility extends to customization for different dress code rules, addressing the unique needs of diverse settings. It is important to highlight the evolution of ADCV from previous models, where limitations existed in terms of singular application focus. In earlier iterations, functionalities such as face recognition or object detection could only be implemented individually, creating a gap in the comprehensive identification of individuals that encompassed both facial features and attire. The proposed system aims to rectify these shortcomings by integrating capabilities, ensuring a more holistic approach to dress code verification. This enhancement signifies a significant stride toward a more versatile and effective solution for monitoring and enforcing dress codes in various environments. In the previous models the only one application could be designed. For instance, the face recognition or the object detection is only possible individually. It cannot do both identification of person’s face and attire of the person. Considering these disadvantages, the rectification of these problems will be achieved through the implementation of the proposed system. ADCV's impact extends beyond its immediate application in dress code enforcement. As a pioneering example of the intersection between computer vision and artificial intelligence.

Would ChatGPT-facilitated programming mode impact college students’ programming behaviors, performances, and perceptions? An empirical study

ChatGPT, an AI-based chatbot with automatic code generation abilities, has shown its promise in improving the quality of programming education by providing learners with opportunities to better understand the principles of programming. However, limited empirical studies have explored the impact of ChatGPT on learners’ programming processes. This study employed a quasi-experimental design to explore the possible impact of ChatGPT-facilitated programming mode on college students’ programming behaviors, performances, and perceptions. 82 college students were randomly divided into two classes. One class employed ChatGPT-facilitated programming (CFP) practice and the other class utilized self-directed programming (SDP) mode. Mixed methods were utilized to collect multidimensional data. Data analysis uncovered some intriguing results. Firstly, students in the CFP mode had more frequent behaviors of debugging and receiving error messages, as well as pasting console messages on the website and reading feedback. At the same time, students in the CFP mode had more frequent behaviors of copying and pasting codes from ChatGPT and debugging, as well as pasting codes to ChatGPT and reading feedback from ChatGPT. Secondly, CFP practice would improve college students’ programming performance, while the results indicated that there was no statistically significant difference between the students in CFP mode and the SDP mode. Thirdly, student interviews revealed three highly concerned themes from students' user experience about ChatGPT: the services offered by ChatGPT, the stages of ChatGPT usage, and experience with ChatGPT. Finally, college students’ perceptions toward ChatGPT significantly changed after CFP practice, including its perceived usefulness, perceived ease of use, and intention to use. Based on these findings, the study proposes implications for future instructional design and the development of AI-powered tools like ChatGPT.

Customized designs, preparations, and characterizations of high-performance multilayer VO2-based thermochromic smart coatings

VO2-based thermochromic coatings have gained much attention in temperature-adaptive smart windows, and constructing multilayer film structures is the main way to obtain high thermochromic performances. Based on the self-developed objective-orientated automatic optimization code, the present research realized customized designs of thermochromic multilayer coatings composed of VO2, TiO2, and SiO2 from the objectives of visible luminance (Tlum) and solar light modulation (ΔTsol). The TiO2/VO2/s, VO2/TiO2/s, TiO2/VO2/TiO2/s, and SiO2/TiO2/VO2/TiO2/s (s denotes substrate) multilayer film systems were then prepared by magnetron sputtering and vacuum controllable heating, with their structures, insulator-metallic transition, and thermochromic properties being carefully studied. The result showed that the best trade-off between high Tlum and high ΔTsol was achieved for these film assemblies, and solar light modulation was mainly limited at the near-IR wavelength region of the solar spectrum, with the difference between cool- and hot-state Tlum being greatly reduced. In the case of the four-layer SiO2/TiO2/VO2/TiO2/s, very high average Tlum (60%) and high ΔTsol (14%) were obtained. A 100 × 100 mm2 of the SiO2/TiO2/VO2/TiO2/s was also prepared, and it showed an obvious temperature adjustment, and the service life can last for 14 years under normal weather conditions. Not limited to the prepared multilayer film systems, the methodology used here is also suitable for the fast development of other multilayer film systems.

A framework for embedded software portability and verification: from formal models to low-level code

AbstractPorting software to new target architectures is a common challenge, particularly when dealing with low-level functionality in drivers or OS kernels that interact directly with hardware. Traditionally, adapting code for different hardware platforms has been a manual and error-prone process. However, with the growing demand for dependability and the increasing hardware diversity in systems like the IoT, new software development approaches are essential. This includes rigorous methods for verifying and automatically porting Real-Time Operating Systems (RTOS) to various devices. Our framework addresses this challenge through formal methods and code generation for embedded RTOS. We demonstrate a hardware-specific part of a kernel model in Event-B, ensuring correctness according to the specification. Since hardware details are only added in late modeling stages, we can reuse most of the model and proofs for multiple targets. In a proof of concept, we refine the generic model for two different architectures, also ensuring safety and liveness properties. We then showcase automatic low-level code generation from the model. Finally, a hardware-independent factorial function model illustrates more potential of our approach.

Initial flight test verification of software and hardware in the loop simulations of the flight stabilization system

PurposeThis paper aims to present assessment of models and simulation results used in the development process of flight stabilisation system that uses trim tabs for PZL-130 Orlik turboprop military trainer aircraft. Flight test of the system allowed to compare software and hardware simulation results with real flight recordings.Design/methodology/approachProposed flight stabilisation system was developed using modern techniques of model-based design, automatic code generation, software and hardware in the loop testing. The project reached flight testing stage which allowed to gather data to verify models and simulation results and asses their quality.FindingsResults of the comparison showed that the trim tab actuator model used in simulation can be improved by adding play. This reduced the difference between simulation and real flight system output – actuator angle. The influence of airloads on the flying actuator angle compared to hardware in the loop simulation in lab is less than ± 0.6°.Originality/valueProposed flight stabilisation system that uses trim tabs has several benefits over classic automatic flight system in terms of weight, energy consumption and structure simplicity and does not need aircraft primary control modification. It was developed using modern techniques of model-based design, automatic code generation and hardware in the loop simulations.

A Clustering-Based Computational Model to Group Students With Similar Programming Skills From Automatic Source Code Analysis Using Novel Features

Throughout a programming course, students develop various source code tasks. Using these tasks to track students' progress can provide clues to the strengths and weaknesses found in each learning topic. This practice allows the teacher to intervene in learning in the first few weeks of class and maximize student gains. However, the biggest challenge is to overcome the amount of work required of the teacher in the manual analysis of all tasks. In this context, our main research objective is to automatically group students with similar programming skills based on the analysis of their submitted source codes. Our research is applied and uses an experimental procedure. First, we prepared the database, with more than 700 real-world source code tasks written in C Language, and distributed it in five different learning topics. Afterward, we define a set of features to be extracted from each learning topic. We defined and extracted 23 features from the source code for five learning topics. Then, we preprocess our database and extract the proposed features. Finally, we grouped the students. After performing the grouping, we obtained four groups of students, which were analyzed using a cluster midpoint calculation. Our results support the monitoring of students throughout the term, offering the teacher the freedom to create new exercises and waiving the obligation of any specific programming environment. We believe that these results can support the teacher in pedagogical decisions closer to the needs of each group of students.

Accelerating Optimal Power Flow with Structure-aware Automatic Differentiation and Code Generation

Accelerating Optimal Power Flow with Structure-aware Automatic Differentiation and Code Generation

Impact of C‐coding self‐assessment exercises on exam performance: A study in engineering education

AbstractThe Bologna process has brought about a revolution in university studies since, among other things, it encourages continuous evaluations throughout the academic period. This situation causes already depleted teaching teams to have an additional workload, so automatic tools are needed to evaluate the new assignments. In the computer science field, the ideal evaluation technique would be to use automatic code evaluators (i.e., Java, C, C++, etc.). The main objective of this work is to analyze whether the use of C‐coding self‐assessment exercises correlates with an improvement in exam performance. For this purpose, we have collected self‐assessment exercises carried out on the AulaWeb platform belonging to the Degree in Organizational Engineering and Degree in Chemical Engineering, taken in the last 5 and 3 years, respectively, in the course of Programming Fundamentals (Fundamentos de Programación) in an engineering school of the Universidad Politécnica de Madrid. In total, 688 students completed these assignments. The most important results are: (a) regarding the January final exam, self‐assessment exercises have influence on the final grade and (b) regarding the June final exam, there are academic years where students forget to carry out programming problem of greater complexity making a negative correlation between self‐assessment performance and final scores achieved.

The Good, the Bad, and the Missing: Neural Code Generation for Machine Learning Tasks

Machine learning (ML) has been increasingly used in a variety of domains, while solving ML programming tasks poses unique challenges due to the fundamental difference in the nature and the construct of general programming tasks, especially for developers who do not have ML backgrounds. Automatic code generation that produces a code snippet from a natural language description can be a promising technique to accelerate ML programming tasks. In recent years, although many deep learning-based neural code generation models have been proposed with high accuracy, the fact that most of them are mainly evaluated on general programming tasks calls into question their effectiveness and usefulness in ML programming tasks. In this article, we set out to investigate the effectiveness of existing neural code generation models on ML programming tasks. For our analysis, we select six state-of-the-art neural code generation models and evaluate their performance on four widely used ML libraries, with newly created 83K pairs of natural-language described ML programming tasks. Our empirical study reveals some good, bad, and missing aspects of neural code generation models on ML tasks, with a few major ones listed below. ( Good ) Neural code generation models perform significantly better on ML tasks than on non-ML tasks with an average difference of 10.6 points in BLEU-4 scores. ( Bad ) More than 80% of the generated code is semantically incorrect. ( Bad ) Code generation models do not have significance in improving developers’ completion time. ( Good ) The generated code can help developers write correct code by providing developers with clues for using correct APIs. ( Missing ) The observation from our user study reveals the missing aspects of code generation for ML tasks, e.g., decomposing code generation for divide-and-conquer into API sequence identification and API usage generation.

VeriBypasser: An automatic image verification code recognition system based on CNN

The rapid development of network technology has brought great convenience to people’s daily life in recent years. The application of network technology in finance, economy, and education is flourishing, dramatically improving people’s quality of life and promoting society’s development. However, the development of network technology brought some new technical problems. Authenticating and controlling access to shared resources has become a significant problem, which limits the development of smart cities. Nowadays, most websites use accounts and passwords for authentication. In order to prevent violent scanning, image-based human–machine inspection solutions are widely used on major platforms. Nonetheless, some human–computer verification schemes can be bypassed or attacked by artificial intelligence. This paper proposes an improved generation method of image verification code and an automatic recognition system based on Cellular Neural Network (CNN), which can achieve an accuracy of 85.20% for a mix of the visual reasoning Completely Automated Public Turing test to tell Computers and Humans Apart (CAPTCHA) containing 4-bit case-insensitive letters and digits, the slider CAPTCHA containing one slide, and inference puzzle CAPTCHA containing a 4 × 2 grid. A brief evaluation of system threat assignment with such verification approaches based on four machine learning methods is also proposed.

Autovesk: Automatic Vectorized Code Generation from Unstructured Static Kernels Using Graph Transformations

Leveraging the SIMD capability of modern CPU architectures is mandatory to take full advantage of their increased performance. To exploit this capability, binary executables must be vectorized, either manually by developers or automatically by a tool. For this reason, the compilation research community has developed several strategies for transforming scalar code into a vectorized implementation. However, most existing automatic vectorization techniques in modern compilers are designed for regular codes, leaving irregular applications with non-contiguous data access patterns at a disadvantage. In this article, we present a new tool, Autovesk, that automatically generates vectorized code from scalar code, specifically targeting irregular data access patterns. We describe how our method transforms a graph of scalar instructions into a vectorized one, using different heuristics to reduce the number or cost of instructions. Finally, we demonstrate the effectiveness of our approach on various computational kernels using Intel AVX-512 and ARM SVE. We compare the speedups of Autovesk vectorized code over GCC, Clang LLVM, and Intel automatic vectorization optimizations. We achieve competitive results on linear kernels and up to 11× speedups on irregular kernels.

RoseNNa: A performant, portable library for neural network inference with application to computational fluid dynamics

The rise of neural network-based machine learning ushered in high-level libraries, including TensorFlow and PyTorch, to support their functionality. Computational fluid dynamics (CFD) researchers have benefited from this trend and produced powerful neural networks that promise shorter simulation times. For example, multilayer perceptrons (MLPs) and Long Short Term Memory (LSTM) recurrent-based (RNN) architectures can represent sub-grid physical effects, like turbulence. Implementing neural networks in CFD solvers is challenging because the programming languages used for machine learning and CFD are mostly non-overlapping, We present the roseNNa library, which bridges the gap between neural network inference and CFD. RoseNNa is a non-invasive, lightweight (1000 lines), and performant tool for neural network inference, with focus on the smaller networks used to augment PDE solvers, like those of CFD, which are typically written in C/C++ or Fortran. RoseNNa accomplishes this by automatically converting trained models from typical neural network training packages into a high-performance Fortran library with C and Fortran APIs. This reduces the effort needed to access trained neural networks and maintains performance in the PDE solvers that CFD researchers build and rely upon. Results show that RoseNNa reliably outperforms PyTorch (Python) and libtorch (C++) on MLPs and LSTM RNNs with less than 100 hidden layers and 100 neurons per layer, even after removing the overhead cost of API calls. Speedups range from a factor of about 10 and 2 faster than these established libraries for the smaller and larger ends of the neural network size ranges tested. Program summaryProgram Title: RoseNNaCPC Library link to program files:https://doi.org/10.17632/srbrfx8k74.1Developer's repository link:https://github.com/comp-physics/roseNNaLicensing provisions: MITProgramming language: Fortran90 and PythonNature of problem: Neural network applications in computational fluid dynamics exhibit high promise. However, they are often not deployed on HPC systems due to limited deep-learning support in Fortran or C/C++. Previous attempts to solve this issue rely on significant manual intervention. This leaves researchers with no practical solution for conveniently porting their trained models for use in performant HPC codebases.Solution method: RoseNNa converts trained neural networks from popular machine learning frameworks to Fortran/C code for inference, requiring minimal manual intervention. Metaprogramming enables automatic code creation, and ONNX ensures flexible machine learning library support.

A conic programming approach to the wrinkling of pneumatic membranes using convex potentials

This paper presents a novel conic programming approach for modeling the wrinkling of isotropic hyperelastic membranes subject to nonlinear loading and finite strains, employing convex potentials derived from tension field theory. The incompressible neo-Hookean strain energy is recast as a minimization problem over a set of cones, with a semidefinite constraint on the deformed surface metric. To address pneumatic membranes, a linearized volumetric potential is introduced, reestablishing convexity for follower forces, and Boyle's law is expressed as a minimization problem over the exponential cone.The primal–dual interior point method solves the total potential energy minimization problem, with convergence verified using the analytical solution of a sheared planar membrane. The proposed model, applied to examples of increasing complexity, reveals intriguing membrane behaviors rarely discussed in existing literature. The method is shown to be robust, even when handling highly wrinkled membranes, which are challenging to address using direct nonlinear equilibrium analysis or nonlinear interior point methods.Implementation using high-level automatic code generation tools (FEniCS) results in concise, extensible code. The findings point to several avenues for future research, such as exploring complex material models, mesh refinement, dynamics, and parametric design. Additionally, the linearization process implies potential applicability of the methods to nonlinear problems beyond membrane mechanics.

Архитектура драйвера контроллера взаимодействия с плоскопанельным дисплеем для ОС Linux

This paper discusses the development of a driver architecture for display transmitter link controller. The architecture ensures the implementation of protocols for interaction with flat panel displays in the case when the controller has its own registers and configuration system. Unlike the known solutions, the proposed architecture makes it possible to reduce the amount of changes in the implementation code in the event of hardware upgrade, and also does not require the use of automatic driver code generation based on high-level descriptions or the development of special tools, such as domain-specific languages. This paper analyses drivers that are based on Direct Rendering Management subsystem and available in open source, as well as previously described approaches to the development of display transmitter link controller drivers. The paper also presents a logical comparator model for testing phase-locked loop devices, which are an integral part of all display output stacks. Based on this model, an IP block was developed, which was used to test the Display Serial Interface driver. Evaluation of the results was carried out in the development of the MIPI Display Serial Interface driver for a promising controller. This driver was tested together with a device prototype and a panel that supports the MIPI Display Serial Interface 1.3 standard. The results provided in this paper can be used both to develop new drivers for existing controllers and new controllers with new drivers.

Code Swarm: A Code Generation Tool based on the Automatic Derivation of Transformation Rule Set

Automatic generation of software code from system design models remains an actively explored research area for the past several years. A number of tools are currently available to facilitate and automate the task of generating code from software models. To the best of our knowledge, existing software tools rely on an explicitly defined transformation rule set to perform the model-to-code transformation process. In this paper, we introduce a novel tool named Code Swarm, abbreviated as CodS, that automatically generates implementation code from system design models by utilizing a swarm-based approach. Specifically, CodS is capable of generating Java code from the class and state models of the software system by making use of the previously solved model-to-code transformation examples. Our tool enables the designers to specify behavioural actions in the input models using the Action Specification Language (ASL). We use an industrial case study of the Elevator Control System (ECS) to perform the experimental validation of our tool. Our results indicate that the code generated by CodS is correct and consistent with the input design models. CodS performs the process of automatic code generation without taking the explicit transformation rule set or languages metamodels’ information as input, which distinguishes it from all the existing automatic code generation tools.

A novel code generator for graphical user interfaces

Graphical user interfaces (GUIs) are widely used in human–computer interaction, providing a convenient interface for operation. Automating the conversion of GUI design images into source code can significantly reduce the coding workload for front-end developers. Detecting elements in GUI images is a key challenge in achieving automatic GUI code generation and is crucial for tasks such as GUI automation and testing. However, current state-of-the-art methods do not fully consider the unique characteristics of GUI images and elements, and they lack the required high localization accuracy, resulting in low detection accuracy for GUI element boxes. In this paper, we propose GUICG, an automatic GUI code generator that combines deep neural networks with image processing techniques to efficiently detect GUI elements from GUI images and generate front-end code. We empirically investigate various deep learning approaches and image processing methods for GUI component detection. Based on a comprehensive understanding of their performance and characteristics, we design GUICG by fusing image processing with a deep learning-based target detection model, achieving state-of-the-art performance. GUICG outperforms existing methods in accuracy and F1 score for component detection tasks, while producing human-readable code with a logical structure. Furthermore, we conduct an ablation study to quantitatively assess the impact of each key element in GUICG.