• This research provides the first comprehensive systematic literature review on software engineering research specifically targeting Jupyter notebooks, identifying 199 primary studies published up to September 2025 and categorizing them into 11 core software engineering topics. • This research reveals that a large portion of the studies have been published outside traditional software engineering venues, with Human-Computer Interaction conferences like ACM Conference on Human Factors in Computing Systems (CHI) being the top publishing venues, highlighting the interdisciplinary nature of Jupyter Notebook research. • This research identifies a reusability gap in existing research, showing that only 82 out of 199 studies offer usable replication packages, and most are hosted on GitHub instead of permanent repositories, which violates open science best practices. • This research identifies that notebook-specific solutions for software engineering issues such as testing, refactoring, and documentation are relatively underexplored. Future directions include resolving duplicated execution numbers, refactoring inter-notebook clones, and generating grouped documentation for coherent-code cells are future directions derived from our study. • This research proposes the integration of modern AI-based solutions into Jupyter notebooks to support various software engineering topics, including code search and code generation. Additionally, future research should leverage advanced AI techniques (e.g., large language models), to improve conversational AI-powered assistants for automated code generation by multi-step workflow automation in data science notebooks. • Although the paper exceeds the recommended length due to the inclusion of detailed tables, figures, and categorized analyses (covering 11 topics and 21 subtopics), we believe that this extended content is essential for clearly and completely reporting our findings. As the first systematic literature review in this domain, we have carefully structured the paper to ensure readability. We believe the length is justified by the value and breadth of this paper’s contributions. Context : Jupyter Notebook has emerged as a versatile tool that transforms how researchers, developers, and data scientists conduct and communicate their work. As the adoption of Jupyter notebooks continues to rise, so does the interest from the software engineering research community in improving the software engineering practices for Jupyter notebooks. Objective : The purpose of this study is to analyze trends, gaps, and methodologies used in software engineering research on Jupyter notebooks. Method : We selected 199 relevant publications up to September 2025, following established systematic literature review guidelines. We explored publication trends, categorized them based on software engineering topics, and reported findings based on those topics. Results : The most popular venues for publishing software engineering research on Jupyter notebooks are related to human-computer interaction instead of traditional software engineering venues. Researchers have addressed a wide range of software engineering topics on notebooks, such as code reuse, readability, and execution environment. Although reusability is one of the research topics for Jupyter notebooks, only 82 of the 199 studies can be reused based on their provided URLs. Additionally, most replication packages are not hosted on permanent repositories for long-term availability and adherence to open science principles. Conclusion : Solutions specific to notebooks for software engineering issues, including testing, refactoring, and documentation, are underexplored. Future research opportunities exist in automatic testing frameworks, refactoring clones between notebooks, and generating group documentation for coherent code cells.

The increasing adoption of Large Language Models (LLMs) in software development has enabled automatic code generation from natural language, yet the influence of communicative factors such as prompt tone remains underexplored. This work introduces PromptTone, a controlled dataset designed to investigate how variations in prompt politeness affect LLM-based code generation in web development. The dataset is constructed through a structured experimental design combining three variables: programming paradigm (Vue.js Composition API vs. Options API), LLM provider (GPT, Claude, Gemini), and prompt tone (impolite, neutral, polite), resulting in 396 generated components across 22 implementations. Data were collected in an educational setting under a single-prompt constraint to capture first-shot model behavior, and are provided in both hierarchical and CSV formats, including prompts, generated code, and error annotations. Preliminary analysis reveals that prompt tone influences output characteristics such as verbosity, with model-specific patterns: for instance, some models exhibit increased output length with more polite prompts, while others remain stable. Differences also emerge across programming paradigms, suggesting an interaction between tone and code structure. These findings highlight that LLMs are sensitive not only to semantic content but also to pragmatic aspects of input. Overall, the dataset provides a novel benchmark for studying human–LLM interaction in code generation, supporting future research on prompt engineering, model evaluation, and socially-aware Artificial Intelligence (AI)-assisted development tools.

In High-Level Synthesis (HLS), refactoring a standard C/C++ code into its HLS-compatible version (HLS-C) still requires significant human effort. While various program scripts have been introduced to automate this process, the resulting code still contains many HLS-incompatible issues that need to be manually refactored and optimized by developers. Since Large Language Models (LLMs) have the ability to automate code generation, they can also be used for automated code refactoring and optimization in HLS. However, due to the limited training of LLMs, considering hardware and software simultaneously, hallucinations may occur when using LLMs for HLS, leading to synthesis failures. To address these challenges, we introduce HLSRewriter , an LLM-aided code refactoring and optimization framework that takes regular C/C++ code as input and automatically generates its corresponding optimized HLS-C code for hardware synthesis with minimal human intervention. To mitigate LLM hallucinations, a step-wise reasoning process is employed to analyze and detect HLS-incompatible errors. Afterwards, a repair library containing reference templates is efficiently created by scanning the HLS tool manual, followed by cooperation with a Retrieval-Augmented Generation (RAG) paradigm to guide the LLMs toward correct refactoring. In addition, a pipeline-aware decomposition strategy is introduced to progressively break down complex loop structures into smaller tasks with a balanced trade-off between latency and area, thereby enabling efficient pipelining and parallel execution. To further improve hardware efficiency, a bit width adjuster module is incorporated into this framework to optimize the precision of floating-point variables. Moreover, LLM-aided HLS optimization strategies are introduced to add/tune hardware directives in HLS-C code, thereby enhancing the performance of the final synthesized hardware. Experimental results demonstrate that the proposed LLM-aided framework can achieve higher refactoring pass rates and superior hardware performance in 24 real-world tasks compared with traditional approaches and the direct application of LLMs for code refactoring and optimization. The codes are open-sourced at this link: https://github.com/code-source1/catapult .

Enterprises adopting generative AI lack systematic frameworks to classify use cases by complexity, assess associated risks, and sequence implementation according to organizational readiness. We synthesize five perspectives from academic and industry literature—application context, value creation, strategic alignment, technical autonomy, and data governance—to develop a multi-dimensional taxonomy for generative AI deployment. Our taxonomy classifies use cases into four ascending complexity levels: (A) work assistants, (B) automated code generation, (C) system-integrated text generation, and (D) tool use. Each level builds upon prior capabilities while introducing distinct technical, organizational, and risk management requirements. We map these patterns across two application contexts: internal operational efficiency and external customer experience enhancement, showing how risk profiles differ between them. By cross-referencing our taxonomy with the five analytical perspectives, we demonstrate how enterprises can assess current maturity, identify strategically aligned use cases, and construct phased implementation roadmaps that balance innovation velocity with risk governance. This framework bridges technical feasibility assessments with business value realization, enabling evidence-based generative AI adoption across industries.

Abstract The emergence of generative AI marks a transformative shift in industrial automation. Traditional robot programming relies on manually written, low-level code that requires specialised expertise, limiting flexibility and accessibility. Recent advances in Large Language Models (LLMs) such as ChatGPT and Mistral introduce new paradigms for automated code generation. However, concerns about data security, model hallucinations, and the opaque reasoning of generative systems continue to hinder their adoption in industry. A promising approach to address these challenges is Retrieval-Augmented Generation (RAG), where the generative model draws on curated, domain-specific data sources controlled by the user. By combining structured knowledge retrieval with generative inference, RAG-based systems can produce robot code that is not only more accurate and context-aware but also verifiable and transparent. This approach enhances user trust and enables safer integration of AI in industrial settings. This paper explores the application of Retrieval-Augmented Generation (RAG)-based architectures - a method that combines information retrieval with LLMs - for robot code generation. RAG-based systems enable LLMs to access and utilise domain-specific data, thereby grounding their outputs in reliable knowledge. By leveraging these techniques, robotics developers can achieve more accurate and efficient code generation, potentially accelerating innovation in autonomous systems. Furthermore, it presents a conceptual framework for RAG-enhanced robot programming that balances autonomy with human oversight. The proposed framework enhances the adaptability and intelligence of automated programming by providing a transparent, controllable, and explainable alternative to conventional AI-driven methods, paving the way for more reliable and human-centric automation in future manufacturing environments.

In a globalized world where data play a critical role in system operation, process automation, and decision-making, the development of real-time control systems is essential, as it enables operators and supervisors to monitor the current status of a process based on its physical variables. Consequently, a wide range of software and hardware platforms is currently available for implementing real-time control systems, including Arduino, ESP32, and PIC microcontrollers. However, these platforms lack sufficiently robust hardware features for closed-loop control applications, as they were primarily designed for general-purpose use. To address the limitations of conventional embedded systems, this paper presents a novel approach for the implementation of digital controllers using Texas Instruments embedded systems applied to experimental plants designed with different control strategies. The proposed contribution focuses on the development of an experimental framework that integrates multi-platform programming, automatic code generation, and the use of dedicated real-time control modules, such as the Control Law Accelerator available in the LAUNCHXL-F28379D LaunchPad embedded system. The results highlight the capability of Texas Instruments microcontrollers to execute real-time control loops applied to different physical systems and operating under various control parameters. In conclusion, the findings demonstrate that Texas Instruments embedded systems equipped with advanced microcontroller architectures represent a promising alternative not only for scalable control applications but also for industrial-level control system development.

Artificial intelligence (AI) has the potential to transform healthcare by supporting more accurate diagnoses and personalized treatments. However, its adoption in practice remains constrained by fragmented data sources, strict privacy rules, and the technical complexity of building reliable clinical systems. To address these challenges, we introduce a model-driven engineering (MDE) framework designed specifically for healthcare AI. The framework relies on formal metamodels, domain-specific languages (DSLs), and automated transformations to move from high-level specifications to running software. At its core is the Medical Interoperability Language (MILA), a graphical DSL that enables clinicians and data scientists to define queries and machine learning pipelines using shared ontologies. When combined with a federated learning architecture, MILA allows institutions to collaborate without exchanging raw patient data, ensuring semantic consistency across sites while preserving privacy. We evaluate this approach in a multi-center cancer immunotherapy study. The generated pipelines delivered strong predictive performance, with best-performing models achieving up to 98.5% accuracy on selected prediction tasks, while substantially reducing manual coding effort. These findings suggest that MDE principles—metamodeling, semantic integration, and automated code generation—can provide a practical path toward interoperable, reproducible, and reliable digital health platforms.

Large language models (LLMs) have shown strong potential for automated code generation in software development, yet their effectiveness in embedded systems programming—requiring understanding of software logic and hardware constraints—has not been well studied. Existing evaluation frameworks do not comprehensively cover practical microcontroller development scenarios in real-world Internet of Things (IoT) projects. This study systematically evaluates 27 state-of-the-art LLMs across eight embedded systems scenarios of increasing complexity, from basic sensor reading to complete cloud database integration with visualization dashboards. Using ESP32 microcontrollers with environmental and motion sensors, we employed the Analytic Hierarchy Process with four weighted criteria: functional, instructions, output and creativity, evaluated independently by two expert reviewers. Top-performing models were Claude Sonnet 4.5, Claude Opus 4.1, and Gemini 2.5 Pro, with scores from 0.984 to 0.910. Performance degraded with complexity: 19–23 models generated compilable code for simple applications, but only 3–5 produced functional solutions for complex scenarios involving Grafana and cloud databases. The most frequent failure was hallucinated non-existent libraries or incorrect API usage, with functional capability as the primary barrier and instruction-following quality the key differentiator among competent models. These findings provide empirical guidance for embedded developers on LLM selection and identify limitations of zero-shot prompting for hardware-dependent IoT development.

Industrial PLC programming faces persistent difficulties: lengthy development cycles, low fault tolerance, and cross-platform incompatibility among vendors. While LLMs show promise for automated code generation, their direct application is hindered by the gap between ambiguous natural language and the strict determinism required by control logic. This paper proposes MPC-Coder, a dual-knowledge enhanced multi-agent system that addresses this gap. The system combines a structured knowledge graph that imposes hard constraints on process parameters and equipment specifications with a vector database that offers implementation references such as code templates and function blocks. These two knowledge sources form a symmetric complementary architecture. A closed-loop “generation–verification–repair” mechanism leverages formal verification tools to iteratively refine the generated code. Experiments demonstrate that MPC-Coder achieves 100% syntactic correctness and 78% functional consistency, significantly outperforming general-purpose LLMs. The results indicate that the complementary fusion of domain knowledge and closed-loop verification effectively enhances the reliability of code generation, offering a viable technical pathway for the reliable application of LLMs in industrial control systems.

This work presents a nonlinear control approach specifically tailored for a Multi-Drive Web Winding System (MDWWS), utilizing the Integral Backstepping Control (IBSC) technique. The proposed strategy is designed to improve the precision of both speed control and mechanical tension regulation across multiple coordinated drives. A detailed formulation of the control law is provided, grounded in the Backstepping framework and extended with integral action to enhance steady-state performance. The theoretical foundations of the IBSC method are thoroughly discussed, and its performance is benchmarked against the conventional Proportional-Integral (PI) controller. The comparative study focuses on evaluating the robustness and adaptability of each control method in the presence of system parameter variations and external disturbances. To validate the effectiveness of the proposed control strategy, a Processor-in-the-Loop (PIL) setup is implemented, integrating automatic code generation with hybrid simulation. This platform enables real-time execution of the control algorithm on the TMDSCNCD28379D DSP board while emulating the dynamic behavior of the web winding system in Simulink, thus providing a realistic and efficient environment for performance evaluation.

The e X tensible M arkup L anguage (XML) is a file format widely used for data transmission in modern software development. In recent years, embedding SQL statements in XML files (i.e., XML-SQL) has become a popular way for developing applications with database access capability. Typically, XML-SQL code snippets demonstrate similar functionalities and structures, leading to repetitive programming work. Therefore, leveraging pre-trained code models for automated code generation presents a promising way to alleviate duplicated efforts and enhance the efficiency of developing XML-SQL code. However, XML-SQL code has strong domain-specific characteristics that general pre-trained code models typically struggle to fully harness, thereby leading to limited overall performance of general pre-trained code models. In this article, we aim to address the challenge of handling this domain-specific knowledge. First, we propose a code updating task and construct the corresponding TwinXSQL dataset to better evaluate the model’s code generation performance in the XML-SQL domain. Then, we leverage the common characteristics of XML-SQL and other programming languages (i.e., all programming languages impose grammar constraints on behavior) to design a bipartite-grammar–aware training framework (named BGA) for unsupervised pre-training, thereby improving the transfer of general-purpose code models to the XML-SQL domain. Specifically, we divide the XML-SQL code into two types of grammatical components: structure components and value components. During pre-training, we undertake three tasks, each designed to learn the internal information of these grammatical components and the relationships between them, enabling the pre-training process to better incorporate previously unlearned domain-specific knowledge of XML-SQL code. Our experimental results show that our trained model XSQLT5-base (220M) improves accuracy by 13.8% compared to the similarly sized CodeT5-base (220M). Additionally, our experiments reveal that ChatGPT, due to its inability to fully learn the XML-SQL domain knowledge, achieves a much lower generation accuracy even with few-shot samples compared to our XSQLT5-base (220M) model.

The increasing reliance on automatic code generation integrated with Generative AI technology has raised new challenges for cybersecurity defense against code injection, insecure code templates, and adversarial manipulation of an AI model. These risks make developing advanced frameworks imperative to ensure secure, reliable, and privacy-preserving code generation processes. The paper presents a novel Hybrid Artificial Neural Network (ANN)-Interpretive Structural Modeling (ISM) Framework to alleviate the cybersecurity risks associated with the automatic code generation using Generative AI. The proposed framework integrates the predictive capability of ANN and structured analysis of ISM for the identification, evaluation, and treatment of common vulnerabilities and risks in automatic code generation. We first conduct a multivocal literature review (MLR) to identify cybersecurity risks and generative AI practices for addressing these risks in automatic code generation. Then we conduct a questionnaire survey to identify and validate the identified risks and practices. An expert panel review was then assigned for the process of ANN-ISM. The ANN model can predict potential security risks by learning from historical data and code generation patterns. ISM is used to (1) structure and visualize (2) relations between identified risks and mitigation approaches and (3) offer a combined, multi-layered risk management methodology. We then perform an in-depth examination of the framework with a case study of an AI-based code generation company. We further determine its practicality and usefulness in real-world settings. The case study results show that the framework efficiently handles the primary cybersecurity challenges, such as injection attacks, code quality, backdoors, and lack of input validation. The analysis characterizes the maturity of several mitigation practices and areas for improvement for security integration with automatic code generation functionality. Advanced risk mitigation is enabled in the framework across multiple process areas, where techniques such as static code analysis, automated penetration testing, and adversarial training hold much promise. The Hybrid ANN-ISM Mechanism is a stable and flexible solution for cybersecurity risk reduction in automatic code generation environments. The coupling of ANN and ISM, in terms of predictive analysis and structured risk management, respectively, contributes effectively towards the security of AI-based code generation tools. More research is required to improve the scalability, privacy preserving, and dynamic integration of the framework with cybersecurity threat intelligence.

Automated code generation using large language models (LLMs) has attracted significant attention due to its potential to enhance software development. However, ensuring both accuracy and efficiency in generated code remains challenging. Prior research has mainly advanced along two directions: (i) enhancing models through architectural improvements, larger parameter scaling, and domain-specific fine-tuning; and (ii) refining prompt engineering techniques to better structure inputs and guide outputs. In this work, we pursue the latter direction and introduce a prompt engineering-based approach for Java code generation. Rather than directly generating Java code from natural language specifications, we propose a two-step pipeline: (i) generating intermediate Python code and, (ii) translating Python into Java. This design leverages the strong performance of LLMs on Python while enabling systematic optimization of the translation stage. To achieve this, we propose a set of translation strategies combining prompt engineering principles — including explicit instructions, syntax guidance, and domain keyword constraints — with advanced reasoning strategies such as Zero-shot Chain of Thought (Zero-shot-CoT) to efficiently generate Java code. Experiments on the HumanEval-X benchmark using the CodeGeeX3 model show that the proposed strategies significantly improve the accuracy of Java code generation. We further evaluate across diverse programming tasks, including file operations, HTTP APIs, database connectivity, parallel computing, and graphical applications, confirming the robustness of our approach. Finally, we validate the generality of our findings using ChatGPT (GPT-4o), observing substantial improvements over baseline prompt designs.

In industrial control systems, the generation and verification of Programmable Logic Controller (PLC) code are crucial for ensuring operational efficiency and safety. While Large Language Models (LLMs) have made strides in automated code generation, they fall short in providing correctness guarantees and specialized support for PLC programming (which has its own programming language and clear logical structures). To address these challenges, this paper introduces Agents4PLC, a novel framework that not only automates PLC code generation but also introduces code-level verification and repair built upon an LLM-based multi-agent system, which together is capable of directly producing operational PLC code without any human interaction. To comprehensively evaluate our framework, we first establish a new benchmark specially designed for the critical area of <italic xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">verifiable PLC code generation</i>, which includes hundreds of natural language requirements, human-written and verified formal specifications, and finally reference PLC code. Then, we carefully designed a multi-agent workflow combining a set of expert agents responsible for different code generation tasks including planning, coding, validation and debugging towards generating correct PLC code. For each agent, we also incorporate optimization strategies such as Retrieval-Augmented Generation (RAG), advanced prompt engineering techniques, and Chain-of-Thought strategies which are shown to be effective to enhance the ability of these expert ‘agents’. Evaluation against the benchmark demonstrates that Agents4PLC significantly outperforms existing methods, achieving superior results across a series of increasingly rigorous evaluation metrics. This research highlights the potential of LLM agent-based code generation in real-world industrial control systems and the importance of code-level verification in generating correct code with formal guarantees.

• A joint energy consumption simulation code generation method based on an abstract syntax tree and templates is proposed. • A variable mapping table and automatic code generation method are used to achieve a flexible combination of different building automation systems and Energy Plus. • Using the proposed automatic code generation method, a visual joint simulation interactive platform is constructed, allowing joint simulation experiments to be conducted without writing code. Building energy consumption researchers are generally not proficient in programming, but require co-simulation tools and physical systems to validate energy-saving patterns and perform data analysis. This paper proposes a code-generation-based method for constructing a universal real-time co-simulation platform integrating EnergyPlus with building control systems. This method eliminates the need for writing code programs; through simple selection, it automatically generates code based on Abstract Syntax Tree (AST) design, enabling specific interactive functions between different EnergyPlus models and different building control systems.This paper first proposes an automatic code generation mode for energy consumption co-simulation, designing co-simulation tool integration template files and building control data communication templates. Utilizing this method, a universal co-simulation platform is implemented, providing building energy consumption researchers with a code-free universal co-simulation platform tool.Through evaluation across 30 experimental cases, the code generation approach proposed in this paper achieves over 95% time savings compared to manual coding, while ensuring the correctness and extensibility of the generated code. The platform has been tested with connections to 2 building control systems and 4 simulation models for joint operation. Each model contains 500 simulation monitoring points, enabling comparative analysis of over six months of actual building control and simulation model data, and provides a user-friendly comparative data interface for researchers.

The rapid evolution of large language models has revolutionized automated code generation. Even so, there are many ways to handle these types of issues individually; some methods try to improve generation quality by doing large-scale sampling, while other methods emphasize correctness by doing post-hoc testing, and yet other methods work to improve the efficiency of models by compressing them, but do not integrate these solutions into a complete system.We present CurricuForge, a comprehensive framework that synergistically combines curriculum reinforcement learning, test-driven development, symbolic execution, and multi-agent collaboration to achieve state-of-the-art performance in code generation tasks. Our approach introduces a novel architecture that progressively trains a distilled language model through carefully designed curriculum stages, where each stage incorporates increasingly complex programming constructs validated through symbolic execution and test-driven generation. The framework employs role-based collaborative agents that specialize in different aspects of code generation, from API schema interpretation to kernel-level optimization through fusion techniques. We further enhance the system with a Toolformer-inspired mechanism that enables dynamic tool invocation during code generation, allowing the model to leverage external resources and verification tools seamlessly. Extensive experiments across multiple benchmarks demonstrate that CurricuForge achieves significant improvements over baseline methods, with a 47.3% increase in functional correctness on HumanEval, 52.8% improvement on MBPP, and 41.2% enhancement on the CodeContests dataset. Our symbolic verification component reduces runtime errors by 68.4% while the curriculum learning strategy accelerates convergence by 3.2x compared to standard training approaches. The distilled model maintains 94.7% of the performance of its teacher model while reducing inference latency by 5.8x and model size by 7.2x, making it practical for deployment in resource-constrained environments. Through comprehensive ablation studies, we demonstrate that each component contributes significantly to the overall performance, with the curriculum learning and multi-agent collaboration showing particularly strong synergistic effects. Our work establishes a new paradigm for code generation systems that combines theoretical rigor with practical efficiency, paving the way for more reliable and scalable automated programming assistants.

As generative Artificial Intelligence (AI) models become increasingly integrated into software development workflows, understanding their efficiency and code quality is critical. This study offers a comprehensive comparison of three leading AI models—ChatGPT GPT-4-turbo, Claude Sonnet, and DeepSeek-V3—for automated code generation, focusing specifically on sorting algorithms. The models are evaluated across multiple metrics including execution time, memory usage, peak memory consumption, logical and physical file sizes, and code readability. Python implementations of Insertion Sort, Merge Sort, Quick Sort, and Heap Sort are generated by each model and benchmarked in a consistent Linux Docker environment. Results reveal that ChatGPT leads in overall efficiency, with the fastest average execution time, the lowest peak memory usage, and the highest readability scores. DeepSeek demonstrated competitive performance, especially in producing readable code, while Claude showed higher memory consumption and lower readability. This analysis provides practical insight into the trade-offs between code quality and system performance in AI-generated programming, offering valuable guidance for researchers and developers alike.

The Ordo-Causal Attribution Deficit: A Prudential Capital Framework for Autonomous Multi-Agent Coding Systems in Financial Infrastructure

DEScMaker: A tool for automated code generation for discrete event systems controllers

This paper presents a novel approach to Computer numerical control (CNC) process identification and program generation through automatic identification of features from computer-aided design (CAD) models. The system extracts geometric and topological features such as holes, pockets, and bosses from boundary representation data and accurately identifies them as machining operations such as milling, drilling, and turning. A rule-based classifier allocates these characteristics to their corresponding processes and an automated code generator produces machine-specific CNC programs through parametric templates and post-processing. A no manual programming framework integrates, significantly reduces human error, and enhances efficiency in CNC manufacturing processes. Experimental verification on six industrially relevant mechanical components confirms robustness of the system and attains high accuracy in feature recognition and process classification. Apart from this, the approach reduces programming time by over 60% compared to conventional manual coding, which proves its feasibility for use in real-world digital manufacturing environments. The results show that the proposed feature-based approach offers an intelligent and scalable solution for CAD-to-CNC automation.