Read the abstract, see who wrote it and who cites it, and get the citation in APA, MLA, Chicago or Harvard.
About 1,336 papers for “First-generation programming language”
Delroy Brown · Zenodo (CERN European Organization for Nuclear Research) · 2025
Nexus++ v1.0_ Core Language Specification.pdf Nexus ++_ An AI-First Programming Language for Efficient Code Generation and Comprehension.pdf
Cited by 0Open access
Federico Cassano, John Gouwar, Daniel Nguyen et al. · IEEE Transactions on Software Engineering · 2023
Large language models have demonstrated the ability to generate both natural language and programming language text. Although contemporary code generation models are trained on corpora with several programming languages, they are tested using benchmarks that are typically monolingual. The most widely used code generation benchmarks only target Python, so there is little quantitative evidence of how code generation models perform on other programming languages. We propose MultiPL-E, a system for translating unit test-driven code generation benchmarks to new languages. We create the first massively multilingual code generation benchmark by using MultiPL-E to translate two popular Python code generation benchmarks to 18 additional programming languages. We use MultiPL-E to extend the HumanEval benchmark [1] and MBPP benchmark [2] to 18 languages that encompass a range of programming paradigms and popularity. Using these new parallel benchmarks, we evaluate the multi-language performance of three state-of-the-art code generation models: Codex [1], CodeGen [3]and InCoder [4]. We find that Codex matches or even exceeds its performance on Python for several other languages. The range of programming languages represented in MultiPL-E allow us to explore the impact of language frequency and language features on model performance. Finally, the MultiPL-E approach of compiling code generation benchmarks to new programming languages is both scalable and extensible, making it straightforward to evaluate new models, benchmarks, and languages.
Cited by 90Open access
Han Jipeng, Lichen Zhihang · arXiv (Cornell University) · 2022
Since the advent of LISP, the fifth generation programming language has developed for decades. However, compared with the fourth generation programming language, the fifth generation programming language has not been widely used because of its obscure semantics, rigorous representation of problems, and limited inference ability. For this reason, COOL (Constraint and Object Ordered Language), a fifth generation programming language proposed in this paper, overcomes the problems of intuitive semantics, rigorous restrictions on handling problem conditions, and improves the inference ability of previous fifth generation programming languages. Specific improvements are as follows: First, COOL supports process-oriented and object-oriented for easy application in production projects; Second, COOL supports expression as function declaration and function return, which improves language affinity for mathematical formulas, and supports embedding function parameters into function name strings to make function naming closer to natural languages. Make mathematical problems easier to describe; Third, COOL introduces a weighting mechanism and accelerates the inference process through cumulative weighting. Fourth, COOL introduces the concepts of forward and reverse functions in programming so that computers can infer and execute problems with logical sequential constraints. Fifth, the computer can deduce the reverse solution process by using the forward solution process through the back-tracking algorithm and the dynamic programming algorithm, so that the computer can deduce the problem with time-sequential constraints. Sixth, the pre-execution step is introduced to separate the inference and function query process of the program from the execution process, so as to improve the execution speed of the program.
Cited by 2Open access
Long Phan, Hieu Tran, Daniel Le et al. · 2021
We present CoTexT, a pre-trained, transformerbased encoder-decoder model that learns the representative context between natural language (NL) and programming language (PL). Using self-supervision, CoTexT is pretrained on large programming language corpora to learn a general understanding of language and code. CoTexT supports downstream NL-PL tasks such as code summarizing/documentation, code generation, defect detection, and code debugging. We train CoTexT on different combinations of available PL corpus including both "bimodal" and "unimodal" data. Here, bimodal data is the combination of text and corresponding code snippets, whereas unimodal data is merely code snippets. We first evaluate CoTexT with multi-task learning: we perform Code Summarization on 6 different programming languages and Code Refinement on both small and medium size featured in the CodeXGLUE dataset. We further conduct extensive experiments to investigate Co-TexT on other tasks within the CodeXGlue dataset, including Code Generation and Defect Detection. We consistently achieve SOTA results in these tasks, demonstrating the versatility of our models.
Cited by 98Open access
Peter Thiemann, Dirk Dussart · 1996
We have designed and implemented an offline partial evaluator for a higher-order language with first-class references. Its distinguishing feature over other partial evaluators is its ability to perform assignments to local and global references at specialization time for a higher-order language. The partial evaluator consists of a region-based monovariant binding-time analysis and a specializer in essentially continuation-passing store-passing style, thus generalizing type-based binding-time analysis and continuation-based partial evaluation. The partial evaluator yields good results for realistic problems such as object-oriented programming, unification, and specializer generation. Keywords: higher-order programming, program transformation, partial evaluation, state Categories: D.1.1 Applicative (Functional) Programming, D.1.2 Automatic Programming, D.3.1 Formal Definitions and Theory, Semantics, D.3.2 Language Classifications, Applicative languages, D.3.4 Processors, I.2.2 Automatic...
Cited by 0
Carissa Myers, Robert Schaefer · Defense Technical Information Center (DTIC) · 1983
Two general types of programming languges have been developed for computer based educational systems. The first type of language, which is patterned after such high order languages as PASCAL or FORTRAN, provides great programming flexibility. However, its structured, syntactical constructs require either that an experienced programmer be involved in lesson generation or that instructional personnel become skilled in sound programming techniques. To avoid these problems, the second type of language was developed. It allows instructional personnel to generate on-line instructional materials without acquiring sophisticated programming skills. This second category of languages is often thought of as being user friendly. They serve very well for many applications, but their use has not been without problems. This paper describes the OMEGSA authoring system, a lesson authoring approach that provides instructional personnel with the positive features of both of the above language types. The paper first relates some basic facts about computer systems in general, and then discusses the various aspects of user friendliness in the context of educational programming. It then describes and evaluates both the traditional and OMEGA approaches to user friendly authoring.
Cited by 0
Markus Voelter, Jos Warmer, Bernd Kolb · IEEE Software · 2014
Two innovations are enhancing programming languages' capabilities. First, modularity lets you combine independently developed languages without changing their respective definitions. A language is no longer a fixed quantity; you can extend it with domain-specific constructs as needed. Second, projectional editing lets you build editors and IDEs that don't require parsers. Such editors and IDEs support a range of tightly integrated notations, including textual, symbolic, tabular, and graphical notations. In addition, by avoiding parsers, they avoid grammar composition's well-known limitations. Three examples illustrate how these two innovations affect programming-language design. A set of modular extensions of C for embedded programming enables efficient code generation and formal analysis. A language for requirements engineering flexibly combines structured and unstructured (prose) data. Finally, a language for defining insurance rules uses mathematical notation. These examples all rely on the open source JetBrains MPS (Meta Programming System) language workbench. This article is part of a special issue on Software Architecture.
Cited by 22
Jingzhao Hu, Wenjing Bi, Yangtao Zhou et al. · Expert Systems with Applications · 2025
• Plang: A language blending natural prompt with control flow for precise LLM guidance. • Meta-prompt programming: Enables LLM to self-modify prompt programs during execution. • 40.75%-89.55% conciseness gain: Outperforms methods like LangChain in prompt coding. • Open-source solution: Enables multi-agent collaboration & tool use with minimal code. The advent of instruction-following large language models (LLMs), exemplified by ChatGPT, has significantly enhanced the performance of generative autoregressive natural language models on general tasks, marking a crucial milestone toward artificial general intelligence. While research has shown that LLM performance critically depends on prompt effectiveness, existing prompt construction approaches - including prompt string templates, prompt programming frameworks, and prompt programming syntactic sugar - suffer from limitations in imprecise generation control and deviation from natural language syntax, thereby impeding prompt engineering advancement. To address these challenges, we introduce PromptLanguage (Plang), a string-first programming language designed specifically for LLM prompt engineering. Our key innovation lies in utilizing font styles as syntax keywords to seamlessly integrate natural language prompt text with control flow code, enabling precise intervention in the generation process while maintaining the natural language affinity of prompt programs. Notably, Plang pioneers the concept of meta-prompt programming. Extensive experimental results across prompt engineering cases and quantitative analyses demonstrate that Plang-written prompt programs offer superior read/writability, intervention precision and up to 89.55% efficiency improvements. The Plang implementation is available as open-source software at https://github.com/HJZ-XDU/plang .
Cited by 0Open access
Andrés Muñetón, Carlos Mario Zapata Jaramillo, Fernando Arango · Dialnet (Universidad de la Rioja) · 2007
Automatic code generation from models has been one of the partially accomplished promises in software \ndevelopment. CASE Tools experiences, even so far from complete automatism, are complemented by some theoretic \nworks, which torn apart modeling standards. In this paper we propose code generation rules from metamodels of the UML \nclass, sequence, and state machine diagrams. The rules are defined on first-order logic, in order to allow the construction of \na specification where both ambiguity and the need of learning a programming language are avoided. We also represent the \napplication of transformation rules by means of a case study, and we generate source code of a class in the Java objectoriented programming language.
Cited by 7Open access
Hajipour, Hossein, Hassler, Keno, Holz, Thorsten et al. · CISPA Helmholtz Center · 2024
Large language models (LLMs) for automatic code generation have achieved breakthroughs in several programming tasks. Their advances in competition-level programming problems have made them an essential pillar of AI-assisted pair programming, and tools such as GitHub Copilot have emerged as part of the daily programming workflow used by millions of developers. The training data for these models is usually collected from the Internet (e.g., from open-source repositories) and is likely to contain faults and security vulnerabilities. This unsanitized training data can cause the language models to learn these vulnerabilities and propagate them during the code generation procedure. While these models have been extensively assessed for their ability to produce functionally correct programs, there remains a lack of comprehensive investigations and benchmarks addressing the security aspects of these models. In this work, we propose a method to systematically study the security issues of code language models to assess their susceptibility to generating vulnerable code. To this end, we introduce the first approach to automatically find generated code that contains vulnerabilities in black-box code generation models. To achieve this, we present an approach to approximate inversion of the black-box code generation models based on few-shot prompting. We evaluate the effectiveness of our approach by examining code language models in generating high-risk security weaknesses. Furthermore, we establish a collection of diverse non-secure prompts for various vulnerability scenarios using our method. This dataset forms a benchmark for evaluating and comparing the security weaknesses in code language models.
Cited by 0Open access
彭铸 · SHILAP Revista de lepidopterología · 2002
By the use of the properties of ergodicity, inherent stochastic property and regularity of chaos, a chaos optimization algorithm is proposed with the help of the optimization Toolbox of Matlab5.3.1 programming language. The programming is compiled with Matlab5.3.1. The problem of function generation for Planar four-link Mechanism is solved by chaos optimization method, and thus all solutions for this problem with maximum precision positions are obtained for first time.
Cited by 0Open access
M. Moser, Michael Pfeiffer, Josef Pichler · 2017
We describe the motivation, approach and first experience from reverse engineering Common Intermediate Language (CIL) for the purpose of documentation generation. Instead of parsing source code implemented in different programming languages, we reverse engineer CIL code and thereby enable documentation generation for all programming languages that can be compiled into CIL code. Initial results show that we are able to generate documents in the same quality as compared to directly analyzing source code. To overcome initial shortcomings we introduce additional preprocessing in form of AST refactoring which is not required when analyzing source code.
Cited by 1
Yannis Smaragdakis, Shan Huang, David Zook · 2004
Program generation is among the most promising techniques in the effort to increase the automation of programming tasks. In this paper, we discuss the potential impact and research value of program generation, we give examples of our research in the area, and we outline a future work direction that we consider most interesting. Specifically, we first discuss why program generators have significant applied potential. At the same time we argue that, as a research topic, meta-programming tools (i.e., language tools for writing program generators) may be of greater value. We then illustrate our views on generators and meta-programming tools with our latest work on the Meta-AspectJ meta-programming language and the GOTECH generator. Finally, we examine the problem of statically determining the safety of a generator and present its intricacies. We limit our focus to one particular kind of guarantee for generated code---ensuring that the generated program is free of compile-time errors. We believe that this research direction will see significant attention and will make a difference in the mainstream adoption of meta-programming technology.
Cited by 23
Wade Holst, Wade Holst, Duane Szafron et al. · 1993
A "first" implementation of the Modular Smalltalk object-oriented programming language is presented. The implementation includes an object-oriented parser, object-oriented representation for code fragments and an object-oriented C-code generator, all implemented in Smalltalk-80. This implementation validates two of the five design principles of the Modular Smalltalk language and provides a vehicle for validating the other three design principles. The macro-based C-code generator is easily adaptable to generating production code in other languages like assembler. In addition, the generation technique applies to source languages other than Modular Smalltalk. The implementation includes an efficient method dispatch based on new extensions to incremental cache table coloring. KEY WORDS: Modular Smalltalk, object-oriented, programming language, compiler, interpreter, method dispatch, code generation. - 2 - Modular Smalltalk Technical Report 93-07 1. Introduction Modular Smalltalk (MS) i...
Cited by 0
Jeffrey Mark Siskind, Barak A. Pearlmutter · 2008
We exhibit an aggressive optimizing compiler for a functionalprogramming language which includes a first-class forward automatic differentiation (AD) operator. The compiler’s performance is competitive with FORTRAN-based systems on our numerical examples, despite the potential inefficiencies entailed by support of a functional-programming language and a first-class AD operator. These results are achieved by combining (1) a novel formulation of forward AD in terms of a reflexive mechanism that supports firstclass nestable nonstandard interpretation with (2) the migration to compile-time of the conceptually run-time nonstandard interpretation by whole-program inter-procedural flow analysis. Categories and Subject Descriptors G.1.4 [Quadrature and Numerical Differentiation]: Automatic differentiation; D.3.2 [Language Classifications]: Applicative (functional) languages; D.3.4 [Processors]: Code generation, Compilers, Optimization; F.3.2 [Semantics of Programming Languages]: Partial evaluation, Program analysis
Cited by 6
Siskind, Jeffrey Mark, Pearlmutter, Barak A. · Purdue e-Pubs (Purdue University System) · 2008
We exhibit an aggressive optimizing compiler for a functionalprogramming language which includes a first-class forward automatic differentiation (AD) operator. The compiler’s performance is competitive with FORTRAN-based systems on our numerical examples, despite the potential inefficiencies entailed by support of a functional-programming language and a first-class AD operator. These results are achieved by combining (1) a novel formulation of forward AD in terms of a reflexive mechanism that supports firstclass nestable nonstandard interpretation with (2) the migration to compile-time of the conceptually run-time nonstandard interpretation by whole-program inter-procedural flow analysis. Categories and Subject Descriptors G.1.4 [Quadrature and Numerical Differentiation]: Automatic differentiation; D.3.2 [Language Classifications]: Applicative (functional) languages; D.3.4 [Processors]: Code generation, Compilers, Optimization; F.3.2 [Semantics of Programming Languages]: Partial evaluation, Program analysis
Cited by 1Open access
Siskind, Jeffrey M., Pearlmutter, Barak A. · Purdue e-Pubs (Purdue University System) · 2008
We exhibit an aggressive optimizing compiler for a functionalprogramming language which includes a first-class forward automatic differentiation (AD) operator. The compiler’s performance is competitive with FORTRAN-based systems on our numerical examples, despite the potential inefficiencies entailed by support of a functional-programming language and a first-class AD operator. These results are achieved by combining (1) a novel formulation of forward AD in terms of a reflexive mechanism that supports firstclass nestable nonstandard interpretation with (2) the migration to compile-time of the conceptually run-time nonstandard interpretation by whole-program inter-procedural flow analysis. Categories and Subject Descriptors G.1.4 [Quadrature and Numerical Differentiation]: Automatic differentiation; D.3.2 [Language Classifications]: Applicative (functional) languages; D.3.4 [Processors]: Code generation, Compilers, Optimization; F.3.2 [Semantics of Programming Languages]: Partial evaluation, Program analysis
Cited by 0Open access
Shruti Sandal, Raghuraj Singh, Abdul Jabbar Khilji et al. · AIP conference proceedings · 2010
This paper describe the relationship between C++ templates and partial evaluation. In C++, templates were designed to support generic programming, but not deliberately provided the ability to perform compile‐time computations and code generation. These features are completely deliberate, and as a result their syntax is ill at ease. After a review, these features in terms of partial evaluation, a much simpler syntax can be achieved. In C++, it may be regarded as a two‐level language in which types are first‐class values. Template instantiation resembles an offline partial assessor. In this paper, we explain groundwork in the direction of a single mechanism based on Partial Evaluation which unifies generic programming, compile‐time computation and code generation. The language Catat is introduced to demonstrate these ideas.
Cited by 0
Indraneil Paul, Goran Glavaš, Iryna Gurevych · arXiv (Cornell University) · 2024
Code understanding and generation have fast become some of the most popular applications of language models (LMs). Nonetheless, research on multilingual aspects of Code-LMs (i.e., LMs for code generation) such as cross-lingual transfer between different programming languages, language-specific data augmentation, and post-hoc LM adaptation, alongside exploitation of data sources other than the original textual content, has been much sparser than for their natural language counterparts. In particular, most mainstream Code-LMs have been pre-trained on source code files alone. In this work, we investigate the prospect of leveraging readily available compiler intermediate representations (IR) - shared across programming languages - to improve the multilingual capabilities of Code-LMs and facilitate cross-lingual transfer. To this end, we first compile SLTrans, a parallel dataset consisting of nearly 4M self-contained source code files coupled with respective intermediate representations. Next, starting from various base Code-LMs (ranging in size from 1.1B to 7.3B parameters), we carry out continued causal language modelling training on SLTrans, forcing the Code-LMs to (1) learn the IR language and (2) align the IR constructs with respective constructs of various programming languages. Our resulting models, dubbed IRCoder, display sizeable and consistent gains across a wide variety of code generation tasks and metrics, including prompt robustness, multilingual code completion, code understanding, and instruction following.
Cited by 0Open access
Matuszczak, Witold · Jagiellonian University Repository (Jagiellonian University)
History of programming languages begins in the mid-twentieth century, when the creation of the first tube and the development of computers von Neumann architecture. At the time of the creation of transistors, microcontrollers and mikroproceserów, the development of computers took off. Along with at once more computing power and at lower cost once the creation of a computer, followed the development of programming languages. In the 50s, the first procedural programming languages (eg Fortran), 10 years later, the first structural languages. Decade, however, was enough to have developed new languages, now called third-generation languages such as C + +, Delphi. In recent years, major development languages, as well as their specialization, the resulting language interpreted by the so-called virtual machines, languages for querying databases or languages of the definition of the user interface.The main aim of this work is to learn practical knowledge of problems associated with the process of compilation and definition of the language by creating a compiler that converts a program written in object-in low-level language code. Both the high-level language and low-level will be created for this work. The compiler and all the analyzers were written by the author in Object Pascal (Delphi).The work consists of six chapters and a book reading.Work begins admission, as the first chapter. It contains the goals and sub-objectives posed this work.The second chapter is devoted to the field problem and the elements of the theory of formal languages and automata. It contains information and definitions related to programming languages, grammars, compilation and interpretation.The third chapter contains a detailed description of the language concerned with the division of the offered opportunities, identifiers, literals and grammar.The fourth chapter describes the process of compilation and code generation. This chapter contains sections devoted to the analysis of lexical, structural, and semantic. Grammar used is described, and a dedicated component for the structural analysis of specially written for the created object-oriented language. Also describes the semantic shares executed at compile, process model validation and code generation for each instruction and command.The fifth chapter is devoted to the target language. Includes a list of possible instructions, description of registers and memory addressing modes.Work has been summarized in chapter six. This chapter contains observations, concluding remarks and plans for the development of compiler and language under consideration.
Cited by 0