Produce Source Code Research Articles

Computing Education in the Era of Generative AI

Challenges and opportunities faced by computing educators and students adapting to LLMs capable of generating accurate source code from natural-language problem descriptions.

A novel approach to source code assembling in the field of algorithmic complexity

Computational complexity analysis plays an essential part in the education of computer and software engineers. For that reason, it is carefully studied in programming courses, as well as in the algorithms and data structures courses. The number of students who learn programming is rapidly growing, but the number of teachers cannot keep up with that trend. Therefore, it is necessary to develop tools that can ease and accelerate the daily tasks of teachers, especially for learning purposes and in the context of automating the processes of exam preparation. We propose a novel template- and rule-based approach and a corresponding software system for assembling synthetic source code segments of defined time complexity. Based on the developed grammar, the system can produce source code segments with a broad scope of different time complexities while guaranteeing the complexity of the generated segment. The system can be used for generating questions for exams as it can assemble a large number of different code segments that can be given as questions that have similar difficulty levels. The system was evaluated both by human experts and ChatGPT tool.

“It’s Weird That it Knows What I Want”: Usability and Interactions with Copilot for Novice Programmers

Recent developments in deep learning have resulted in code-generation models that produce source code from natural language and code-based prompts with high accuracy. This is likely to have profound effects in the classroom, where novices learning to code can now use free tools to automatically suggest solutions to programming exercises and assignments. However, little is currently known about how novices interact with these tools in practice. We present the first study that observes students at the introductory level using one such code auto-generating tool, Github Copilot, on a typical introductory programming (CS1) assignment. Through observations and interviews we explore student perceptions of the benefits and pitfalls of this technology for learning, present new observed interaction patterns, and discuss cognitive and metacognitive difficulties faced by students. We consider design implications of these findings, specifically in terms of how tools like Copilot can better support and scaffold the novice programming experience.

Automatic Differentiation in ROOT

In mathematics and computer algebra, automatic differentiation (AD) is a set of techniques to evaluate the derivative of a function specified by a computer program. AD exploits the fact that every computer program, no matter how complicated, executes a sequence of elementary arithmetic operations (addition, subtraction, multiplication, division, etc.), elementary functions (exp, log, sin, cos, etc.) and control flow statements. AD takes source code of a function as input and produces source code of the derived function. By applying the chain rule repeatedly to these operations, derivatives of arbitrary order can be computed automatically, accurately to working precision, and using at most a small constant factor more arithmetic operations than the original program. This paper presents AD techniques available in ROOT, supported by Cling, to produce derivatives of arbitrary C/C++ functions through implementing source code transformation and employing the chain rule of differential calculus in both forward mode and reverse mode. We explain its current integration for gradient computation in TFormula. We demonstrate the correctness and performance improvements in ROOT’s fitting algorithms.

Simulation of Rapidly-Exploring Random Trees in Membrane Computing with P-Lingua and Automatic Programming

Methods based on Rapidly-exploring Random Trees (RRTs) have been widely used in robotics to solve motion planning problems. On the other hand, in the membrane computing framework, models based on Enzymatic Numerical P systems (ENPS) have been applied to robot controllers, but today there is a lack of planning algorithms based on membrane computing for robotics. With this motivation, we provide a variant of ENPS called Random Enzymatic Numerical P systems with Proteins and Shared Memory (RENPSM) addressed to implement RRT algorithms and we illustrate it by simulating the bidirectional RRT algorithm. This paper is an extension of [21]a. The software presented in [21] was an ad-hoc simulator, i.e, a tool for simulating computations of one and only one model that has been hard-coded. The main contribution of this paper with respect to [21] is the introduction of a novel solution for membrane computing simulators based on automatic programming. First, we have extended the P-Lingua syntax –a language to define membrane computing models– to write RENPSM models. Second, we have implemented a new parser based on Flex and Bison to read RENPSM models and produce source code in C language for multicore processors with OpenMP. Finally, additional experiments are presented.

MULTILANGUAGE SOURCE CODE GENERATOR FOR DATABASE ORIENTED APPLICATION USING JSP

The goal of automated software engineering is to increase by order of magnitude both the quality and productivity factor. To date most successful approach is producing a special-purpose code generator, such as screen generator, report generator, swing builder, Meta programming etc., these software tools is produce source code for specific language. This study provides mechanism to make a generalized system of Multi-Language Source Code Generation (MLSCG). It takes database structure of metadata as input and produce source code in Java, Java script, JSP, PHP and ASP. We utilize the target output code for both web and pc-based application.

Automating the development of distributed control software

The Development Framework translates application-specific system specifications into parallel, hard real-time implementations, using methods that are both familiar to developers and optimal for the application. The Development Framework approach applies CASE tools-as well as several new tools-to the development of distributed systems, so designers can concentrate on the control-engineering aspects of their systems. The approach addresses three development phases: specification, software design, and implementation. In the specification phase, the control engineer refines behavioral requirements through simulation and analysis, thereby verifying that the system meets its functional requirements prior to implementation. Once the simulated behavior is satisfactory, the specified behavior is translated into a design. Finally, our tools produce source code, either by automatically generating it or by drawing it from a library. We describe the new and existing tools we apply during each phase. We then demonstrate our approach using an example of a linearized roll-pitch-yaw autopilot and airframe model. >