Code Generation Research Articles

Minotaur: A SIMD-Oriented Synthesizing Superoptimizer

A superoptimizing compiler—-one that performs a meaningful search of the program space as part of the optimization process—-can find optimization opportunities that are missed by even the best existing optimizing compilers. We created Minotaur: a superoptimizer for LLVM that uses program synthesis to improve its code generation, focusing on integer and floating-point SIMD code. On an Intel Cascade Lake processor, Minotaur achieves an average speedup of 7.3% on the GNU Multiple Precision library (GMP)’s benchmark suite, with a maximum speedup of 13%. On SPEC CPU 2017, our superoptimizer produces an average speedup of 1.5%, with a maximum speedup of 4.5% for 638.imagick. Every optimization produced by Minotaur has been formally verified, and several optimizations that it has discovered have been implemented in LLVM as a result of our work.

SparseAuto: An Auto-scheduler for Sparse Tensor Computations using Recursive Loop Nest Restructuring

Automated code generation and performance enhancements for sparse tensor algebra have become essential in many real-world applications, such as quantum computing, physical simulations, computational chemistry, and machine learning. General sparse tensor algebra compilers are not always versatile enough to generate asymptotically optimal code for sparse tensor contractions. This paper shows how to generate asymptotically better schedules for complex sparse tensor expressions using kernel fission and fusion. We present generalized loop restructuring transformations to reduce asymptotic time complexity and memory footprint. Furthermore, we present an auto-scheduler that uses a partially ordered set (poset)-based cost model that uses both time and auxiliary memory complexities to prune the search space of schedules. In addition, we highlight the use of Satisfiability Module Theory (SMT) solvers in sparse auto-schedulers to approximate the Pareto frontier of better schedules to the smallest number of possible schedules, with user-defined constraints available at compile-time. Finally, we show that our auto-scheduler can select better-performing schedules and generate code for them. Our results show that the auto-scheduler provided schedules achieve orders-of-magnitude speedup compared to the code generated by the Tensor Algebra Compiler (TACO) for several computations on different real-world tensors.

Statically Contextualizing Large Language Models with Typed Holes

Large language models (LLMs) have reshaped the landscape of program synthesis. However, contemporary LLM-based code completion systems often hallucinate broken code because they lack appropriate code context, particularly when working with definitions that are neither in the training data nor near the cursor. This paper demonstrates that tighter integration with the type and binding structure of the programming language in use, as exposed by its language server, can help address this contextualization problem in a token-efficient manner. In short, we contend that AIs need IDEs, too! In particular, we integrate LLM code generation into the Hazel live program sketching environment. The Hazel Language Server is able to identify the type and typing context of the hole that the programmer is filling, with Hazel's total syntax and type error correction ensuring that a meaningful program sketch is available whenever the developer requests a completion. This allows the system to prompt the LLM with codebase-wide contextual information that is not lexically local to the cursor, nor necessarily in the same file, but that is likely to be semantically local to the developer's goal. Completions synthesized by the LLM are then iteratively refined via further dialog with the language server, which provides error localization and error messages. To evaluate these techniques, we introduce MVUBench, a dataset of model-view-update (MVU) web applications with accompanying unit tests that have been written from scratch to avoid data contamination, and that can easily be ported to new languages because they do not have large external library dependencies. These applications serve as challenge problems due to their extensive reliance on application-specific data structures. Through an ablation study, we examine the impact of contextualization with type definitions, function headers, and errors messages, individually and in combination. We find that contextualization with type definitions is particularly impactful. After introducing our ideas in the context of Hazel, a low-resource language, we duplicate our techniques and port MVUBench to TypeScript in order to validate the applicability of these methods to higher-resource mainstream languages. Finally, we outline ChatLSP, a conservative extension to the Language Server Protocol (LSP) that language servers can implement to expose capabilities that AI code completion systems of various designs can use to incorporate static context when generating prompts for an LLM.

A new plastic global analysis approach for the fire design of steel and stainless steel structures

The new generation of structural codes for stainless steel allow carrying out global plastic analyses on certain types of stainless steel structures with plastic cross-sections at room temperature if the joints conforming the structure are classified as full-strength joints, a capability that has been long recognised for carbon steel structures. However, the requirements for the fire design of carbon and stainless steel structures in current and upcoming European design standards are still primarily based on the resistance of individual members, disregarding the redistribution of internal forces and strain hardening effects. Recent studies have proven that carbon and stainless steel frames with plastic cross-sections and full-strength joints are capable of redistributing internal forces at elevated temperatures, and failed describing global plastic collapse mechanisms under fire situation, suggesting that system effects are also relevant at elevated temperatures and could be taken into account for more efficient designs. On this basis, this paper develops an extensive numerical study focused on carbon and stainless steel frames under fire situation, and proposes a new methodology based on plastic global analysis to estimate the resistance of such structures under fire situation accounting for their redistribution capacity, improving the accuracy of the predicted fire time resistances significantly for the two materials.

Trajectory analysis and flight modeling of combat aircrafts ejection seats

In this study, it is aimed to develop a generic model which calculates the trajectory of the ejection seat from the jet aircraft, by taking into account the parameters that will affect the seat movement such as the seat’s launch speed, ejection direction, ejection angle, altitude of the aircraft, distance/height from the aircraft rudder and canopy, pilot and ejection seat weight. With the model algorithm proposed, the ejection seat trajectory model was developed on MATLAB. The ejection seat trajectory model is based on point mass trajectory mathematical model. In this study, an analytical study of the problem has been made for modeling the flight trajectory of the ejection seat after it has been ejected. Past studies were used as a basis for validation and simulation. By writing a generic MATLAB code, a user interface was developed and presented to the user as a module. This generic code that has been developed could be used for simulations by users in the future by revising it in accordance with their own job descriptions.

On the Effectiveness of Large Language Models in Domain-Specific Code Generation

Large language models (LLMs) such as ChatGPT have shown remarkable capabilities in code generation. Despite significant achievements, they rely on enormous training data to acquire a broad spectrum of open-domain knowledge. Besides, their evaluation revolves around open-domain benchmarks like HumanEval, which primarily consist of programming contests. Therefore, it is hard to fully characterize the intricacies and challenges associated with particular domains (e.g., web, game, and math). In this paper, we conduct an in-depth study of the LLMs in domain-specific code generation. Our results demonstrate that LLMs exhibit sub-optimal performance in generating domain-specific code, due to their limited proficiency in utilizing domain-specific libraries. We further observe that incorporating API knowledge as prompts can empower LLMs to generate more professional code. Based on these findings, we further investigate how to effectively incorporate API knowledge into the code generation process. We experiment with three strategies for incorporating domain knowledge, namely, external knowledge inquirer, chain-of-thought prompting, and chain-of-thought fine-tuning. We refer to these strategies as a new code generation approach called DomCoder . Experimental results show that all strategies of DomCoder improve the effectiveness of domain-specific code generation under certain settings.

SNN eXpress: Streamlining Low‐Power AI‐SoC Development With Unsigned Weight Accumulation Spiking Neural Network

AbstractSoCs with analog‐circuit‐based unsigned weight‐accumulating spiking neural networks (UWA‐SNNs) are a highly promising solution for achieving low‐power AI‐SoCs. This paper addresses the challenges that must be overcome to realize the potential of UWA‐SNNs in low‐power AI‐SoCs: (i) the absence of UWA‐SNN learning methods and the lack of an environment for developing applications based on trained SNN models and (ii) the inherent issue of testing and validating applications on the system being nearly impractical until the final chip is fabricated owing to the mixed‐signal circuit implementation of UWA‐SNN‐based SoCs. This paper argues that, by integrating the proposed solutions, the development of an EDA tool that enables the easy and rapid development of UWA‐SNN‐based SoCs is feasible, and demonstrates this through the development of the SNN eXpress (SNX) tool. The developed SNX automates the generation of RTL code, FPGA prototypes, and a software development kit tailored for UWA‐SNN‐based application development. Comprehensive details of SNX development and the performance evaluation and verification results of two AI‐SoCs developed using SNX are also presented.

ChatGeoAI: Enabling Geospatial Analysis for Public through Natural Language, with Large Language Models

Large Language Models (LLMs) such as GPT, BART, and Gemini stand at the forefront of Generative Artificial Intelligence, showcasing remarkable prowess in natural language comprehension and task execution. This paper proposes a novel framework developed on the foundation of Llama 2, aiming to bridge the gap between natural language queries and executable code for geospatial analyses within the PyQGIS environment. It empowers non-expert users to leverage GIS technology without requiring deep knowledge of geospatial programming or tools. Through cutting-edge Natural Language Processing (NLP) techniques, including tailored entity recognition and ontology mapping, the framework accurately interprets user intents and translates them into specific GIS operations. Integration of geospatial ontologies enriches semantic comprehension, ensuring precise alignment between user descriptions, geospatial datasets, and geospatial analysis tasks. A code generation module empowered by Llama 2 converts these interpretations into PyQGIS scripts, enabling the execution of geospatial analysis and results visualization. Rigorous testing across a spectrum of geospatial analysis tasks, with incremental complexity, evaluates the framework and the performance of such a system, with LLM at its core. The proposed system demonstrates proficiency in handling various geometries, spatial relationships, and attribute queries, enabling accurate and efficient analysis of spatial datasets. Moreover, it offers robust error-handling mechanisms and supports tasks related to map styling, visualization, and data manipulation. However, it has some limitations, such as occasional struggles with ambiguous attribute names and aliases, which leads to potential inaccuracies in the filtering and retrieval of features. Despite these limitations, the system presents a promising solution for applications integrating LLMs into GIS and offers a flexible and user-friendly approach to geospatial analysis.

Devika AI: An Open-Source Revolution In AI-Powered Code Generation

Devika AI is an innovative open-source platform designed to revolutionize software development through AIpowered code generation. Leveraging advanced natural language processing (NLP), machine learning algorithms, and a modular architecture, Devika AI translates high-level human instructions into executable code across multiple programming languages. This paper presents a comprehensive overview of Devika AI's architecture, methodologies, and functionalities. We discuss its ability to improve developer productivity, reduce coding errors, and facilitate collaborative development. Experimental results demonstrate Devika AI's effectiveness in various coding tasks, highlighting its potential as a free and accessible alternative to proprietary AI coding assistants. The implications of Devika AI's adoption on the future of software development are also explored

A comparative study of AI code bots: Efficiency, features, and use cases

This article thus provides a comparative study of AI code bots, in terms of their performances, characteristics and applications. It looks at how via application of artificial learning and NLP for software development, these bots help in coding, debugging, and optimizing. The work also analyses AI code bots including GitHub Copilot, Tabnine, Replit Ghostwriter, Amazon CodeWhisperer, and others as well as strengths, weaknesses, and versatility of such software depending on the programming language and the development environment used. Although these tools work well in improving productivity, reducing on-task redundancies and forming a more accurate code, they do not contain self-authorization, especially for intricate occasions. The study shows that the employment of AI code bots has advantages and drawbacks that should be investigated further in the future emphasizing on the possibilities of enhancing the filters on errors, the degree of personalization and considering the ethical aspect of employing AI code generation.

Development of Smart Simulator for Electronic Fuel Injection (EFI) fuel system based on Quick Response Code (QR Code) for Learning Media

This research aims to develop learning media in the form of an intelligent fuel system simulator, namely electronic fuel injection (EFI) on motorbikes, which focuses on developing the addition of Quick Response (QR) codes as additional information from the simulator, which is connected to video on the YouTube platform. With the help of the QR code, it is scanned using a smartphone so that the QR code can be connected directly to YouTube, providing additional information about the Smart simulator EFI system on motorbikes. This research was carried out by applying the Research and Development method and following the Plomp model, which consists of the following stages: (1) preliminary investigation, (2) designing and making a prototype, and (3) assessment. The existing simulator was developed by adding a QR code, and the QR code will be connected to videos that have been uploaded on the YouTube platform. QR codes are created using the online QR code generator platform. Assessment of the smart simulator is carried out through a questionnaire filled out by media experts and subject experts, as well as through observation sheets during smart simulator testing. The research results are a smart simulator product for EFI fuel on motorbikes equipped with a QR code. Evaluation by media and material experts shows that the smart simulator is declared valid. Meanwhile, the results of observations during product testing show that the smart simulator can describe the characteristics of the EFI fuel system on a motorbike according to the actual situation.

Navigating delayed diagnoses, self-neglect, and lost livelihoods: a qualitative exploration of fisherfolk’s health perspectives and management of non-communicable diseases in Kerala, India

IntroductionNon-Communicable Diseases (NCDs) place a significant burden on India's healthcare system, accounting for approximately 62% of all deaths in the country in 2017. The southern Indian state - Kerala - has some of the highest rates of NCDs. Within the state, the fisherfolk community has a high prevalence of risk factors such as tobacco use and alcohol consumption. Working in the fisheries industry demands physical exertion, night shifts alongside extended periods of time at sea (for seafaring fisherfolk). Evidence is scant on how these conditions relate to the health-seeking experiences of fisherfolk, particularly in the context of NCDs. We conducted a qualitative study in two districts of Kerala to fill this gap.MethodsIn-depth individual and small group interviews– as per participant preference – with male and female fishing community members living with NCDs were conducted between October 2022 and February 2023 in two districts of Kerala. Interviews were conducted to explore community members’ experiences with health-seeking for NCDs. Transliterated English transcripts were coded using ATLAS.ti software and analysed using thematic analysis with inductive generation of codes, with indexing against Levesque, Harris, and Russell’s 2013 access to healthcare framework.ResultsThirty-three interviews with 42 participants were conducted. We found that NCDs were usually diagnosed late- either when admitted/consulted for other illnesses or when the symptoms became unbearable. Health-seeking patterns differed between seafaring and inland fishing subgroups, who were sampled from two districts in the state. Seafaring fisherfolk preferred public facilities for regular checkups and medicines while in-land fisherfolk relied on private facilities, although it was considered expensive. Ability to seek care was impacted by the working hours of the health centre which did not suit their working hours. Health constaints and related expenses also impacted their financial status and occupation, with some opting for less strenuous jobs.ConclusionThis study highlights the NCD-related health-seeking experiences of the fisherfolk community in Kerala, India. Fisherfolk reported self neglect, delayed diagnosis, cost and livelihood constraints owing to the onset of NCDs, even as dual practice and medicine access in the public sector were appreciated. Overall, larger studies and policymaking processes should consider in depth the experiences faced by particular economic groups like fisherfolk, who may face unique health and care-seeking challenges.

Self-Planning Code Generation with Large Language Models

Although large language models (LLMs) have demonstrated impressive ability in code generation, they are still struggling to address the complicated intent provided by humans. It is widely acknowledged that humans typically employ planning to decompose complex problems and schedule solution steps prior to implementation. To this end, we introduce planning into code generation to help the model understand complex intent and reduce the difficulty of problem-solving. This paper proposes a self-planning code generation approach with large language models, which consists of two phases, namely planning phase and implementation phase. Specifically, in the planning phase, LLM plans out concise solution steps from the intent combined with few-shot prompting. Subsequently, in the implementation phase, the model generates code step by step, guided by the preceding solution steps. We conduct extensive experiments on various code-generation benchmarks across multiple programming languages. Experimental results show that self-planning code generation achieves a relative improvement of up to 25.4% in Pass@1 compared to direct code generation, and up to 11.9% compared to Chain-of-Thought of code generation. Moreover, our self-planning approach also enhances the quality of the generated code with respect to correctness, readability, and robustness, as assessed by humans.

An Empirical Study of the Non-determinism of ChatGPT in Code Generation

An Empirical Study of the Non-determinism of ChatGPT in Code Generation

Managing and editing UML documents: structure, integration, automation

Unified Modeling Language (UML) plays an important role in the modern software development process by offering standardized methods for visual modeling, analysis, and design of complex systems. This paper discusses the main aspects of storing, editing, and integrating UML documents with integrated development environments (IDEs). The main focus is on comparing the two main formats for storing UML models – XML Metadata Interchange (XMI) and JavaScript Object Notation (JSON). XMI, being an official standard developed by Object Management Group, provides a high degree of detail and compatibility with various UML tools, making it preferable for large and complex projects that require support for the full UML specification. At the same time, JSON is simple and flexible, which makes it suitable for projects where speed of development and ease of integration are important, although it is inferior to XMI in describing complex aspects of UML models. The paper analyzes in detail the methods of editing UML documents, including manual editing and automated approaches, using APIs and scripts. Manual editing is useful when you need to make small changes to the structure of a UML document, but it can be time-consuming and error-prone when working with large projects. Automation, on the other hand, provides effective tools for mass editing and generating UML elements, which significantly speeds up development and minimizes the likelihood of errors, especially since modern tools such as StarUML offer the necessary tools for programmatically modifying UML documents by integrating them into development processes. Combining of UML documents with integrated development environments also plays a key role in increasing development efficiency, as this allows automating code generation based on UML models, maintaining synchronization between code and diagrams, and facilitating visualization and documentation of architectural solutions. Despite the significant advantages, there are challenges associated with limited support for all UML features and potential conflicts between models and code. This only emphasizes the need for further research in this area. Prospects for further research include the development of new methods and tools for working with UML documents, improving their integration with development environments, and using artificial intelligence to automate the analysis and design of UML models. Attention should also be paid to the using of UML with continuous integration processes, which can significantly increase the flexibility and adaptability of software development. Thus, the study of the structure of storing, editing, and integrating UML documents is an important area for optimizing the design and development of modern software systems.

Geometrically nonlinear analysis of layered beams using symbolic approach

This study presents a novel layered spatial beam model with discrete connections between layers, developed to accurately capture large displacements and rotations as well as finite strains. The formulation is characterized by simplicity, robustness and compatibility with automatic code generation, making it suitable for various applications. Key features of the model include the use of a piecewise constant strain field, the inclusion of discrete unknowns such as strains and stress resultants, and the efficient numerical implementation using the automatic code generation. The discrete connections between the layers of the model enable an efficient description of the interlaminar behaviour and the consideration of nonlinear constitutive properties. Numerical examples demonstrate the effectiveness and accuracy of the proposed approach and illustrate its potential for practical engineering applications.

Linguacodus: a synergistic framework for transformative code generation in machine learning pipelines

In the ever-evolving landscape of machine learning, seamless translation of natural language descriptions into executable code remains a formidable challenge. This article introduces Linguacodus, an innovative framework designed to tackle this challenge by deploying a dynamic pipeline that iteratively transforms natural language task descriptions into code through high-level data-shaping instructions. The core of Linguacodus is a fine-tuned large language model, empowered to evaluate diverse solutions for various problems and select the most fitting one for a given task. This article details the fine-tuning process and sheds light on how natural language descriptions can be translated into functional code. Linguacodus represents a substantial leap towards automated code generation, effectively bridging the gap between task descriptions and executable code. It holds great promise for advancing machine learning applications across diverse domains. Additionally, we propose an algorithm capable of transforming a natural description of an ML task into code with minimal human interaction. In extensive experiments on a vast machine learning code dataset originating from Kaggle, we showcase the effectiveness of Linguacodus. The investigations highlight its potential applications across diverse domains, emphasizing its impact on applied machine learning in various scientific fields.

A search-and-fill strategy to code generation for complex software requirements

Context:The realm of software development has seen significant transformations with the rise of Low-Code Development (LCD) and the integration of Artificial Intelligence (AI), particularly large language models, into coding practices. The proliferation of open-source software also offers vast resources for developers. Objective:We aim to combine the benefits of modifying retrieved code with the use of an extensive code repository to tackle the challenges of complex control structures and multifunctional requirements in software development. Method:Our study introduces a Search-and-Fill strategy that utilizes natural language processing (NLP) to dissect complex software requirements. It extracts control structures and identifies atomic function points. By leveraging large-scale pre-trained models, the strategy searches for these elements to fill in the automatically transformed program structures derived from descriptions of control structures. This process generates a code snippet that includes program control structures and the implementations of various function points, thereby facilitating both code reuse and efficient development. Results:We have validated the effectiveness of our strategy in generating code snippets. For natural language requirements involving multifunctional complex structures, we constructed two datasets: the Basic Complex Requirements Dataset (BCRD) and the Advanced Complex Requirements Dataset (ACRD). These datasets are based on natural language descriptions and Python code that were randomly extracted and combined. For the code snippets to be generated, we achieved the best results with the ACRD dataset, with BLEU-4 scores reaching up to 0.6326 and TEDS scores peaking at 0.7807. Conclusion:The Search-and-Fill strategy successfully generates a comprehensive code snippets, integrating essential control structures and functions to streamline the development process. Experimental results substantiate our strategy’s efficacy in optimizing code reuse by effectively integrating preprocessing and selection optimization approach. Future research will focus on enhancing the recognition of complex software requirements and further refining the code snippets.

Efficient Data Exchange between WebAssembly Modules

In the past two decades, there has been a noticeable decoupling of machines and operating systems. In this context, WebAssembly has emerged as a promising alternative to traditional virtual machines. Originally designed for execution in web browsers, it has expanded to executing code in restricted and secure environments, and it stands out for its rapid startup, small footprint, and portability. However, WebAssembly presents significant challenges in data transfer and the management of interactions with the module. Its specification requires each module to have its own memory, resulting in a “share-nothing” architecture. This restriction, combined with the limitations of importing and exporting functions that only handle numerical values, and the absence of an application binary interface (ABI) for sharing more complex data structures, leads to efficiency problems; these are exacerbated by the variety of programming languages that can be compiled and executed in the same environment. To address this inefficiency, the Karmem was designed and developed. It includes a new interface description language (IDL) aimed at facilitating the definition of data, functions, and relationships between modules. Additionally, a proprietary protocol—an optimized ABI for efficient data reading and minimal decoding cost—was created. A code generator capable of producing code for various programming languages was also conceived, ensuring harmonious interaction with the ABI and the foreign function interface. Finally, the compact runtime of Karmem, built atop a WebAssembly runtime, enables communication between modules and shared memory. Results of the experiments conducted show that Karmem represents an innovation in data communication for WASM in multiple environments and demonstrates the ability to overcome challenges of efficiency and interoperability.

Generating Java code pairing with ChatGPT

The Large Language Models (LLMs) like ChatGPT 3.5 have created a new era of automatic code generation. However, the existing research primarily focuses on generating simple code based on datasets (such as HumanEval, etc.). Most of approaches pay less attention to complex and practical code generation. Therefore, in this paper, we propose a new approach called “Xd-CodeGen” which can be used to generate large scale Java code. This approach is composed of four phases: requirement analysis, modeling, code generation, and code verification. In the requirement analysis phase, ChatGPT 3.5 is utilized to decompose and restate user requirements. To do so, a knowledge graph is developed to describe entities and their relationship in detail. Further, Propositional Projection Temporal Logic (PPTL) formulas are employed to define the properties of requirements. In the modeling phase, we use knowledge graphs to enhance prompts and generate UML class and activity diagrams for each sub-requirement using ChatGPT 3.5. In the code generation phase, based on established UML models, we make use of prompt engineering and knowledge graph to generate Java code. In the code verification phase, a runtime verification at code level approach is employed to verify generated Java code. Finally, we apply the proposed approach to develop a practical Java web project.