Imperative Programming Languages Research Articles

Analysis of Datasets and Large Language Models for Vulnerability Detection in Imperative Programming Language Code

Large language models are machine learning models that enable the classification and generation of both natural language text and code in various programming languages. These models have billions of parameters and are trained on vast datasets. In recent years, such models have been successfully applied to a wide range of tasks in software engineering. The paper presents data on publication activity on the topic under study, which is obtained on the basis of statistical analysis of search results for relevant key queries. In addition, a review of recent publications in the field of using large language models to detect vulnerabilities in program code is carried out, and the results of the analysis of data sets that are used in training neural network models to search for vulnerabilities in program code are presented.

Semantics, Specification Logic, and Hoare Logic of Exact Real Computation

We propose a simple imperative programming language, ERC, that features arbitrary real numbers as primitive data type, exactly. Equipped with a denotational semantics, ERC provides a formal programming language-theoretic foundation to the algorithmic processing of real numbers. In order to capture multi-valuedness, which is well-known to be essential to real number computation, we use a Plotkin powerdomain and make our programming language semantics computable and complete: all and only real functions computable in computable analysis can be realized in ERC. The base programming language supports real arithmetic as well as implicit limits; expansions support additional primitive operations (such as a user-defined exponential function). By restricting integers to Presburger arithmetic and real coercion to the `precision' embedding $\mathbb{Z}\ni p\mapsto 2^p\in\mathbb{R}$, we arrive at a first-order theory which we prove to be decidable and model-complete. Based on said logic as specification language for preconditions and postconditions, we extend Hoare logic to a sound (w.r.t. the denotational semantics) and expressive system for deriving correct total correctness specifications. Various examples demonstrate the practicality and convenience of our language and the extended Hoare logic.

Towards determinism in PDL: relations and proof theory

Abstract Guarded Kleene Algebra with Tests (GKAT) was presented as a fragment of KAT to abstract imperative programming languages, where only if-then-else and while-do statements are allowed in the language. The loss of expressiveness is, nevertheless, compensated by a clear advantage over KAT: it allows almost linear decidability of program equivalence. In this work, we give the first step to optimizing the complexity of dynamic logic equivalence, which is EXPTIME-complete in propositional dynamic logic (PDL). First, and based on strict deterministic PDL, we present guarded propositional dynamic logic (GPDL), a fragment of PDL where programs correspond to GKAT terms. It comes embedded, as expected, with a semantics over relational models and a sound axiomatisation. Then, we present a Natural Deduction system for GPDL, proving its soundness and completeness, concerning the axiomatisation. Based on Smolka et al. (2019, Proceedings of the ACM Programming Language 4), we obtain the main result of this work—the equivalence of GPDL programs can be established in almost linear time.

Static Program Analysis for IoT Risk Mitigation in Space-Air-Ground Integrated Networks

The space-air-ground integrated networks(SAGINs) are pivotal for modern communication and surveillance, with a growing number of connected devices. The proliferation of IoT devices within these networks introduces new risks due to potential erroneous synergistic interactions that could compromise system integrity and security. This paper addresses the challenges in coordination, synchronization, and security within SAGINs by introducing a novel static program analysis (SPA) technique using zero-knowledge (ZK) proofs. This approach ensures the detection of risky interactions without compromising sensitive source code, thus safeguarding intellectual property and privacy. The proposed method overcomes the incompatibility between SPA and ZK systems by developing an imperative programming language for SAGINs and a specialized abstract domain for interaction threats. The system translates network control algorithms into arithmetic circuits suitable for ZK analysis, maintaining high accuracy in detecting risks. Evaluations on real-world scenarios demonstrate the system's efficacy in identifying risky interactions with minimal computational overhead. This research presents the first ZK-based SPA scheme for SAGINs, enhancing security and confidentiality in network analysis while adhering to privacy regulations.

Positive Almost-Sure Termination: Complexity and Proof Rules

We study the recursion-theoretic complexity of Positive Almost-Sure Termination ( PAST ) in an imperative programming language with rational variables, bounded nondeterministic choice, and discrete probabilistic choice. A program terminates positive almost-surely if, for every scheduler, the program terminates almost-surely and the expected runtime to termination is finite. We show that PAST for our language is complete for the (lightface) co-analytic sets (Π 1 1 -complete). This is in contrast to the related notions of Almost-Sure Termination ( AST ) and Bounded Termination ( BAST ), both of which are arithmetical (Π 2 0 - and Σ 2 0 -complete respectively). Our upper bound implies an effective procedure to reduce reasoning about probabilistic termination to non-probabilistic fair termination in a model with bounded nondeterminism, and to simple program termination in models with unbounded nondeterminism. Our lower bound shows the opposite: for every program with unbounded nondeterministic choice, there is an effectively computable probabilistic program with bounded choice such that the original program is terminating if, and only if, the transformed program is PAST . We show that every program has an effectively computable normal form, in which each probabilistic choice either continues or terminates execution immediately, each with probability 1/2. For normal form programs, we provide a sound and complete proof rule for PAST . Our proof rule uses transfinite ordinals. We show that reasoning about PAST requires transfinite ordinals up to ω 1 CK ; thus, existing techniques for probabilistic termination based on ranking supermartingales that map program states to reals do not suffice to reason about PAST .

LTL-specification for development and verification of control programs

This work continues the series of articles on development and verification of control programs based on the LTL-specification. The essence of the approach is to describe the behavior of programs using formulas of linear temporal logic LTL of a special form. The developed LTL-specification can be directly verified by using a model checking tool. Next, according to the LTL-specification, the program code in the imperative programming language is unambiguously built. The translation of the specification into the program is carried out using a template. The novelty of the work consists in the proposal of two LTL-specifications of a new form — declarative and imperative, as well as in a more strict formal justification for this approach to program development and verification. A transition has been made to a more modern verification tool for finite and infinite systems — nuXmv. It is proposed to describe the behavior of control programs in a declarative style. For this purpose, a declarative LTL-specification is intended, which defines a labelled transition system as a formal model of program behavior. This method of describing behavior is quite expressive — the theorem on the Turing completeness of the declarative LTL-specification is proved. Next, to construct program code in an imperative language, the declarative LTL-specification is converted into an equivalent imperative LTL-specification. An equivalence theorem is proved, which guarantees that both specifications specify the same behavior. The imperative LTL-specification is translated into imperative program code according to the presented template. The declarative LTL-specification, which is subject to verification, and the control program built on it are guaranteed to specify the same behavior in the form of a corresponding transition system. Thus, during verification, a model is used that is adequate to the real behavior of the control program.

Assessing the Usability of Two Declarative Programming Languages to Model Geometric Events

When space missions plan scientific actions for robotic spacecraft to execute, they frequently do so within a geometric context called an opportunity. Although there are geometric software libraries that let users write code to search for opportunities, they require knowledge of algorithms and imperative programming languages, which is a condition that might exclude a potentially large population of scientists. Additionally, there might be more user-friendly software systems for scientists to model and search for opportunities, but those might exclude other missions due to export concerns or an inability to maintain such software due to lack of staff or funding. To address these concerns, we designed two different computer languages to model opportunities. In this paper, we present these two languages, our study to evaluate their relative readability and usability, and results obtained in our research along with an interpretation of the same. The metric for this study has been a questionnaire with active exercises, statements with corresponding responses on a Likert scale, and open-ended questions to elicit qualitative responses. The study’s quantitative results provide us with relative and absolute quantification of the usability and readability of each language, while the study’s qualitative results help us direct future language design decisions.

Alias Analysis and Calculus based on Segmentation Address Memory Model

We present a straightforward implementation of a simplified imperative programming language with direct memory access and address arithmetic, and a simple static analyzer for memory leaks. Our study continues a line of research attempted (in Innopolis University in years 2016-2022) on alias calculi for imperative programming languages with decidable pointer arithmetic but differs by memory address model – we study segmented memory model instead linear one.

IsQ: An Integrated Software Stack for Quantum Programming

We introduce isQ, a new software stack for quantum programming in an imperative programming language, also named isQ. The aim of isQ is to make programmers write quantum programs as conveniently as possible. In particular: <list list-type="ordered" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink"> <list-item><label>1)</label> The isQ language and its compiler contain many useful features, including but not limited to: classical control flow, such as recursion; decomposition of self-defined unitary gates; and oracle programming and its circuit realization. </list-item> <list-item><label>2)</label> To make it flexible, an isQ program can be compiled into several different kinds of intermediate representation and assemblies, including QIR, eQASM, OpenQASM 3.0, and QCIS (specially tailored for the superconducting quantum hardware at USTC). </list-item> <list-item><label>3)</label> Besides interfacing isQ with real superconducting hardware, a QIR simulator is also developed for the demonstration and testing of isQ programs. </list-item> </list> <p xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">isQ software stack encompasses abundant compiler optimizations of high-level quantum programs. To realize it, a distinct MLIR dialect name isQ-IR is proposed.

Metamodel-based Language Definition with Python

Most of the parser tools are concentrated on concrete syntax and grammar definition. This paper describes a language definition tool that uses a metamodel specification instead of grammar as the basis of the language definition. Inspired by a similar Java tool known as YAJCo, the metamodel is defined using usual object-oriented techniques—as classes in the Python programming language, and the result of the parsing process is a graph of objects. The tool is demonstrated in a case study of a simple imperative programming language. We explain our design decisions and also demonstrate the suitability of a dynamic language such, as Python, for this task.

A Type Discipline for Message Passing Parallel Programs

We presentParTypes, a type discipline for parallel programs. The model we have in mind comprises a fixed number of processes running in parallel and communicating via collective operations or point-to-point synchronous message exchanges. A type describes a protocol to be followed by each processes in a given program. We present the type theory, a core imperative programming language and its operational semantics, and prove that type checking is decidable (up to decidability of semantic entailment) and that well-typed programs do not deadlock and always terminate. The article is accompanied by a large number of examples drawn from the literature on parallel programming.

Reversing an imperative concurrent programming language

We introduce a method of reversing the execution of imperative concurrent programs. Given an irreversible program, we describe the process of producing two versions. The first performs forward execution and saves information necessary for reversal. The second uses this saved information to simulate reversal. We propose using identifiers to capture statement execution order, and to use this to correctly undo data races via backtracking reversibility. We prove this reversibility to be correct, showing that the initial program state is restored and that all saved information is used (garbage-clean). • Reversal of a concurrent imperative programming language that stores minimal data to undo irreversible steps • Identifiers assigned to statements as they execute that determines reverse control flow and ensures correct reversibility • Proof of correctness confirms the method of reversal restores program states and does not produce garbage • Reversibility illustrated on an implementation of a parallel sorting algorithm, with forward and reverse execution described

Artificial Intelligence in the American Healthcare Industry: Looking Forward to 2030

Artificial Intelligence in the American Healthcare Industry: Looking Forward to 2030

OpenQASM 3: A Broader and Deeper Quantum Assembly Language

Quantum assembly languages are machine-independent languages that traditionally describe quantum computation in the circuit model. Open quantum assembly language (OpenQASM 2) was proposed as an imperative programming language for quantum circuits based on earlier QASM dialects. In principle, any quantum computation could be described using OpenQASM 2, but there is a need to describe a broader set of circuits beyond the language of qubits and gates. By examining interactive use cases, we recognize two different timescales of quantum-classical interactions: real-time classical computations that must be performed within the coherence times of the qubits, and near-time computations with less stringent timing. Since the near-time domain is adequately described by existing programming frameworks, we choose in OpenQASM 3 to focus on the real-time domain, which must be more tightly coupled to the execution of quantum operations. We add support for arbitrary control flow as well as calling external classical functions. In addition, we recognize the need to describe circuits at multiple levels of specificity, and therefore we extend the language to include timing, pulse control, and gate modifiers. These new language features create a multi-level intermediate representation for circuit development and optimization, as well as control sequence implementation for calibration, characterization, and error mitigation.

A Preliminary Data-driven Analysis of Common Errors Encountered by Novice SPARC Programmers

Answer Set Programming (ASP), a modern development of Logic Programming, enables a natural integration of Computing with STEM subjects. This integration addresses a widely acknowledged challenge in K-12 education, and early empirical results on ASP-based integration are promising. Although ASP is considered a simple language when compared with imperative programming languages, programming errors can still be a significant barrier for students. This is particularly true for K-12 students who are novice users of ASP. Categorizing errors and measuring their difficulty has yielded insights into imperative languages like Java. However, little is known about the types and difficulty of errors encountered by K-12 students using ASP. To address this, we collected high school student programs submitted during a 4-session seminar teaching an ASP language known as SPARC. From error messages in this dataset, we identify a collection of error classes, and measure how frequently each class occurs and how difficult it is to resolve.

Towards the Design and Implementation of a Programming Language (Beex)

Software Engineers, Computer Scientists, and Software Experts alike are faced to decide which programming language is best suited for a certain purpose as the use of programming languages grows. When we consider the various types of programming languages available today, such as Domain Specific Languages (DSL), General Purpose Languages (GPL), Functional Programming Languages (FPL), Imperative Programming Languages (IPL), amongst others, this becomes complicated. In this study, we introduce BeeX, an interpreted language, with the aim of showing the process and principles involved in language design and consider various choices faced by language designers of various programming languages. BeeX was created with simplicity in mind, thus the study focused on architectural design options. We look at the implementation standpoint and try to figure out what the basic building parts of most programming languages are, such as lexical analysis, syntax analysis, and evaluation phase. To achieve this, we created an interactive command interface that evaluated various BeeX language constructs(conditional logic statements, arithmetic expressions, loop constructs etc.) which allowed students to easily experiment with the proposed language. The results of the tests showed that students and programmers alike can use the BeeX programming language to create a variety of code structures that are simple to use.

Development of CrystarPack numerical package for solving computational fluid dynamics problems

A computational package CrystarPack developed by the author is presented, which is designed to solve problems of continuum mechanics according to an implicit scheme using finite difference and finite volume methods on a Cartesian grid with a refined step, as well as a modified iterative Newton method with global convergence. The package has the form of a dll-library and is flexible and easy to customize for various physical problems, allowing its functionality to be included in the user-written code in any of the imperative programming languages.

A Generalized Search Construct for Imperative Languages to Facilitate Declarative Programming

Search is one of the more common strategies used by problem-solving agents. For many hard problems, a backtracking search can be the most effective approach for finding a solution. Logic programming languages provide, as a core feature of the language, the mechanics for the search behind the scenes without requiring the user to specify the algorithm. However, this functionality has been generally left out of the core features of imperative programming languages. In this work, we propose integrating a search agent into an imperative programming language through a search construct in the syntax. By doing so, our intention is that the user may apply a declarative approach to problem solving. We extend the Go programming language with this search construct and develop an agent to perform the search. The algorithm behind the search is implicitly handled by the agent. We demonstrate the effectiveness of this search construct through solutions to an exhaustive search over a file-system, the NQueens problem, and the monkey and the bananas problem. To evaluate the performance of our agent, we compare its runtime performance against two of the common Prolog implementations, SWI-Prolog and GNU Prolog.

Computable model discovery and high-level-programming approximations to algorithmic complexity

Motivated by algorithmic information theory, the problem of program discovery can help find candidates of underlying generative mechanisms of natural and artificial phenomena. The uncomputability of such inverse problem, however, significantly restricts a wider application of exhaustive methods. Here we present a proof of concept of an approach based on IMP, a high-level imperative programming language. Its main advantage is that conceptually complex computational routines are more succinctly expressed, unlike lower-level models such as Turing machines or cellular automata. We investigate if a more expressive higher-level programming language can be more efficient at generating approximations to algorithmic complexity of recursive functions.

Modeling Asymptotic Complexity Using ACL2

The theory of asymptotic complexity provides an approach to characterizing the behavior of programs in terms of bounds on the number of computational steps executed or use of computational resources. We describe work using ACL2 to prove complexity properties of programs implemented in a simple imperative programming language embedding via an operational semantics in ACL2. We simultaneously prove functional properties of a program and its complexity. We illustrate our approach by describing proofs about a binary search algorithm, proving both that it implements binary search on a sorted list and that it is O(log(n)), where n is the length of the list.