Imperative Programming Research Articles

A modular cost analysis for probabilistic programs

We present a novel methodology for the automated resource analysis of non-deterministic, probabilistic imperative programs, which gives rise to a modular approach . Program fragments are analysed in full independence. Moreover, the established results allow us to incorporate sampling from dynamic distributions , making our analysis applicable to a wider class of examples, for example the Coupon Collector’s problem . We have implemented our contributions in the tool , exploiting a constraint-solver over iterative refineable cost functions facilitated by off-the-shelf SMT solvers. We provide ample experimental evidence of the prototype’s algorithmic power. Our experiments show that our tool runs typically at least one order of magnitude faster than comparable tools. On more involved examples, it may even be the case that execution times of seconds become milliseconds. At the same time we retain the precision of existing tools. The extensions in applicability and the greater efficiency of our prototype, yield scalability of sorts. This effects into a wider class of examples, whose expected cost analysis can be thus be performed fully automatically.

From Big-Step to Small-Step Semantics and Back with Interpreter Specialisation

We investigate representations of imperative programs as constrained Horn clauses. Starting from operational semantics transition rules, we proceed by writing interpreters as constrained Horn clause programs directly encoding the rules. We then specialise an interpreter with respect to a given source program to achieve a compilation of the source language to Horn clauses (an instance of the first Futamura projection). The process is described in detail for an interpreter for a subset of C, directly encoding the rules of big-step operational semantics for C. A similar translation based on small-step semantics could be carried out, but we show an approach to obtaining a small-step representation using a linear interpreter for big-step Horn clauses. This interpreter is again specialised to achieve the translation from big-step to small-step style. The linear small-step program can be transformed back to a big-step non-linear program using a third interpreter. A regular path expression is computed for the linear program using Tarjan's algorithm, and this regular expression then guides an interpreter to compute a program path. The transformation is realised by specialisation of the path interpreter. In all of the transformation phases, we use an established partial evaluator and exploit standard logic program transformation to remove redundant data structures and arguments in predicates and rename predicates to make clear their link to statements in the original source program.

Generalized derivatives of computer programs

ABSTRACT A method for evaluating lexicographical directional (LD)-derivatives of functional programs is presented, extending previous methods to programs containing conditional branches and loops. A language for imperative programs is given, and conditions under which LD-derivatives can be calculated automatically for conditional branches and loops are described, along with a full description of the source transformation procedures necessary.

Dedicative Verification of Reflex Programs

This paper presents a new two-step verification method for control software. The novelty of the method is that it reduces the verification of the temporal properties of a control program to the deductive verification of an imperative program in the Hoare style, which explicitly models the time and history of the control program. The method is applied to programs written in the Reflex language, a domain-specific extension of C developed as an alternative to the languages of the IEC 61131-3 standard. Reflex is a process-oriented language that describes control programs in terms of communicating processes controlled by operator events, including the events generated by operations on discrete time intervals. At the first step, an annotated Reflex program is translated into an equivalent annotated imperative program on a bounded subset of C, which is extended with the logical type bool, supertype value (which combines the values that can return Reflex functions and operators), and statement havoc x (which assigns an arbitrary value to the variable x). At the second step, the resulting imperative program undergoes deductive verification. The proposed method is illustrated by the example of deductive verification of a Reflex program that controls a hand dryer. The example includes the original Reflex program, a set of requirements, the resulting annotated program, the correctness conditions generated, and results of verifying these conditions in Z3py, an interface to the Z3 SMT solver implemented in Python.

Reasoning about Partial Correctness Assertions in Isabelle/HOL

Hoare Logic has a long tradition in formal verification and has been continuously developed and used to verify a broad class of programs, including sequential, object-oriented and concurrent programs. The purpose of this work is to provide a detailed and accessible exposition of the several ways the user can conduct, explore and write proofs of correctness of sequential imperative programs with Hoare logic and the ISABELLE proof assistant. With the proof language Isar, it is possible to write structured, readable proofs that are suitable for human understanding and communication.

Nested data structures in array frameworks

The need for nested data structures and combinatorial operations on arbitrary length lists has prevented particle physicists from adopting array-based data analysis frameworks, such as R, MATLAB, Numpy, and Pandas. These array frameworks work well for purely rectangular tables and hypercubes, but arrays of variable length arrays, called “jagged arrays,” are out of their scope. However, jagged arrays are a fundamental feature of particle physics data, as well as combining them to search for particle decays. To bridge this gap, we developed the awkward-array library, and in this paper we present feedback from some of the first physics groups using it for their analyses. They report similar computational performance to analysis code written in C++, but are split on the ease-of-use of array syntax. In a series of four phone interviews, all users noted how different array programming is from imperative programming, but whereas some found it easier in all aspects, others said it was more difficult to write, yet easier to read.

The Evolution of Imperative Programming Paradigms as a Search for New Ways to Reduce Code Duplication

The cause for imperative programming paradigm shift is the impossibility of developing software systems of a new level of complexity. We consider the evolution of programming paradigms: structured, procedural, and object-oriented. We demonstrate new ways of code duplication reducing have appeared with the shift of paradigm. We conclude the factor of code duplication reducing determines the direction of programming paradigm evolution. We discover the constraints, which were introduced in the paradigms, simplify the development of software systems. We conclude the new constraints allow the development of more complex software systems. The main reason for the code duplication is the low qualification of programmers. Therefore, in the process of learning programming, one should pay attention to code duplication and ways to reduce it.

Teaching Cobots in Learning Factories – User and Usability-Driven Implications

Up to now, industrial robots were considered as machines working for humans. In this sense, programming required special coding knowledge and skills as teaching approaches were based on imperative programming methods, formulating the solving of a problem line by line. As novel work principles consider the robot rather a tool, assisting or collaborating with the human, declarative approaches are needed, that allow for intuitiveness and modifiability. Collaborative robot (cobot) control requires intuitive interfaces, not only for ease of use but also for modifying existing execution programs. Furthermore, the increasingly diverse personnel also requires a more democratic approach to robot programming. However, there is no standard or guideline for intuitive cobot control, and it can be noticed that the usability of the diverse interfaces and systems provided on the market is rather poor. This paper compares three systems with their advantages and disadvantages concerning usability and presents the results of the standard usability score (SUS) test, which was conducted in the Vienna learning factory “TU Wien Pilot Factory for Industry 4.0”. Additionally, the paper presents an approach on how to teach different levels of cobot interaction and control addressing the skill sets needed in their individual working environments.

Guarded Kleene algebra with tests: verification of uninterpreted programs in nearly linear time

Guarded Kleene Algebra with Tests (GKAT) is a variation on Kleene Algebra with Tests (KAT) that arises by restricting the union (+) and iteration (*) operations from KAT to predicate-guarded versions. We develop the (co)algebraic theory of GKAT and show how it can be efficiently used to reason about imperative programs. In contrast to KAT, whose equational theory is PSPACE-complete, we show that the equational theory of GKAT is (almost) linear time. We also provide a full Kleene theorem and prove completeness for an analogue of Salomaa’s axiomatization of Kleene Algebra.

Tÿcho

Many application areas for embedded systems, such as DSP, media coding, and image processing, are based on stream processing. Stream programs in these areas are often naturally described as graphs, where nodes are computational kernels that send data over the edges. This structure also exhibits large amounts of concurrency, because the kernels can execute independently as long as there are data to process on the edges. The explicit data dependencies also help making efficient sequential implementations of such programs, allowing programs to be more portable between platforms with various degrees of parallelism. The kernels can be expressed in many different ways; for example, as imperative programs with read and write statements for the communication or as a set of actions that can be performed and conditions for when these actions can be executed. Traditionally, there has been a tension between how the kernels are expressed and how efficiently they can be implemented. There are very efficient implementation techniques for stream programs with restricted expressiveness, such as synchronous dataflow. In this article, we present a framework for building stream program compilers that we call Tÿcho. At the core of this framework is a common kernel representation, based on a machine model for stream program kernels called actor machine , on which transformations and optimizations are performed. Both imperative and action-based kernels are translated to this common representation, making the same optimizations applicable to different kinds of kernels, and even across source language boundaries. An actor machine is described by the steps of execution that a kernel can take, and the conditions for taking them, together with a controller that decides how the conditions are tested and the steps are taken. We outline how kernels of an imperative process language and an action-based language are decomposed and translated to the common kernel representation, and we describe a simple backend that generates sequential C code from this representation. We present optimization heuristics of the decision process in the controller that we evaluate using a few dozen kernels from a video decoder with various degrees of complexity. We also present kernel fusion, by merging the controllers of actor machines, as a way of scheduling kernels on the same processor, which we compare to prior art.

Smartlog – A declarative language for distributed programming in smart grids

In the control and supervision of smart grids, the objective is to handle any change in the system as fast as possible, with as few resources as possible. In this context, this paper proposes a new language, called Smartlog, designed with a declarative approach. This avoids collecting and analyzing data presenting no interest, and thus being less efficient in bandwidth usage and computational time. Smartlog is designed for operating smart grids defined as abstract structures of large and scalable distributed databases. From its definition, some major properties of this language, such as simplicity, incremental capacity, and scalability are highlighted. The language is tested on the application of the secondary control of an isolated microgrid using a real-time simulator connected to Raspberry Pis. The characteristics of Smartlog are illustrated thanks to a comparison with an imperative programming implementation of the same regulation.

A Denotational Semantics for Low-Level Probabilistic Programs with Nondeterminism

Probabilistic programming is an increasingly popular formalism for modeling randomness and uncertainty. Designing semantic models for probabilistic programs has been extensively studied, but is technically challenging. Particular complications arise when trying to account for (i) unstructured control-flow, a natural feature in low-level imperative programs; (ii) general recursion, an extensively used programming paradigm; and (iii) nondeterminism, which is often used to represent adversarial actions in probabilistic models, and to support refinement-based development. This paper presents a denotational-semantics framework that supports the three features mentioned above, while allowing nondeterminism to be handled in different ways. To support both probabilistic choice and nondeterministic choice, the semantics is given over control-flow hyper-graphs. The semantics follows an algebraic approach: it can be instantiated in different ways as long as certain algebraic properties hold. In particular, the semantics can be instantiated to support nondeterminism among either program states or state transformers. We develop a new formalization of nondeterminism based on powerdomains over sub-probability kernels. Semantic objects in the powerdomain enjoy a notion we call generalized convexity, which is a generalization of convexity. As an application, the paper sketches an algebraic framework for static analysis of probabilistic programs, which has been proposed in a companion paper.

Complex Program Induction for Querying Knowledge Bases in the Absence of Gold Programs

Recent years have seen increasingly complex question-answering on knowledge bases (KBQA) involving logical, quantitative, and comparative reasoning over KB subgraphs. Neural Program Induction (NPI) is a pragmatic approach toward modularizing the reasoning process by translating a complex natural language query into a multi-step executable program. While NPI has been commonly trained with the ‘‘gold’’ program or its sketch, for realistic KBQA applications such gold programs are expensive to obtain. There, practically only natural language queries and the corresponding answers can be provided for training. The resulting combinatorial explosion in program space, along with extremely sparse rewards, makes NPI for KBQA ambitious and challenging. We present Complex Imperative Program Induction from Terminal Rewards (CIPITR), an advanced neural programmer that mitigates reward sparsity with auxiliary rewards, and restricts the program space to semantically correct programs using high-level constraints, KB schema, and inferred answer type. CIPITR solves complex KBQA considerably more accurately than key-value memory networks and neural symbolic machines (NSM). For moderately complex queries requiring 2- to 5-step programs, CIPITR scores at least 3× higher F1 than the competing systems. On one of the hardest class of programs (comparative reasoning) with 5–10 steps, CIPITR outperforms NSM by a factor of 89 and memory networks by 9 times. 1

Combining model finder and genetic programming into a general purpose automatic program synthesizer

Program synthesis aims to mechanize the task of programming from the user intent (expressed in various forms like pre/post conditions, examples, sketches, etc). There are many approaches to program synthesis that are usually implemented in isolation: deductive, syntax-based, inductive, etc. In this paper, we describe PSMF2, a program synthesizer that combines model finder and genetic programming. PSMF2 takes as user intent examples and a soft sketch: a new kind of user intent defined as a set of commands that must appear in the synthesized program (and that are in no particular order of execution). The output of PSMF2 is a general purpose imperative program. The combination of inductive synthesis and genetic programming has allowed PSMF2 to synthesize 7 programs (IntSQRT, Majority of 5, Majority of 8, Max of 4, Modulo, Factorial, and Fibonacci) found in the SyGuS competition, the iJava and IntroClass, and the Genetic programming communities. We carried out an empirical evaluation on the synthesis time of these 7 programs and the mean time varied from 56.4 seconds (Majority of 5) to 15.9 minutes (Fibonacci).

A survey on the use of access permission-based specifications for program verification

Verifying the correctness and reliability of imperative and object-oriented programs is one of the grand challenges in computer science. In imperative programming models, programmers introduce concurrency manually by using explicit concurrency constructs such as multi-threading. Multi-threaded programs are prone to synchronization problems such as data races and dead-locks, and verifying API protocols in object-oriented programs is a non-trivial task due to improper and unexpected state transition at run time. This is in part due to the unexpected sharing of program states in such programs. With these considerations in mind, access permissions have been investigated as a means to reasoning about the correctness of such programs. Access permissions are abstract capabilities that characterize the way a shared resource can be accessed by multiple references.This paper provides a comprehensive survey of existing access permission-based verification approaches. We describe different categories of permissions and permission-based contracts. We elaborate how permission-based specifications have been used to ensure compliance of API protocols and to avoid synchronization problems in concurrent programs. We compare existing approaches based on permission usage, analysis performed, language and/or tool supported, and properties being verified. Finally, we provide insight into the research challenges posed by existing approaches and suggest future directions.

Situational planning and operational adjustment of the route of the Autonomous robotic underwater vehicle

Currently, missions (tasks) for the underwater robot formed using imperative programming methods (both text and graphic), describing in detail the sequence of robot actions that need performed to achieve the desired goal. At the same time, only the operator of the underwater robot, which makes up the mission, for example, the delivery of cargo to the target point, has an idea of the goal itself. Such technology is effective if the robot's mission carried out within a priori scenario. In other cases, it can either not be executed at all, or it can be executed with large violations and a threat to the safety of the device.When assessing the effectiveness of an underwater robot, the degree of its information autonomy, i.e. the ability to act independently in an unknown or insufficiently defined environment, is of fundamental importance. Therefore, the "intellectualization" of the Autonomous control system of the underwater robot is extremely important for the mission in unforeseen circumstances. For this propose to use intelligent decision support system. Two ways to implement optimal decision-making strategies based on the mathematical apparatus of the theory of Markov and semi-Markov processes using the Bellman optimality principle propose. The considered ways of implementation of optimal strategies of decision - making process relate to the strategy for a short finite time of cargo delivery, which is the most common in practice, and for a long interval of cargo delivery relative to the entire task. In addition, the article discusses ways to find optimal strategies when the time of making single decisions is fixed or when the time of translation is implement randomly.Hence, the situational approach to decision-making in the planning of the route ARPA is very relevant and allows not only to assess the possible situation on the route, but also to determine the control solutions for the operational adjustment of the route using the intelligent decision support system (ISPR). The development of models of the routing process based on the representation of the situational model in the form of nodes of the graph, the transitions of which correspond to the control solutions.The paper proposes two ways to implement optimal strategies of decision - making based on the mathematical apparatus of the theory of Markov and semi-Markov processes using the Bellman principle of optimality.

Imperative Program Synthesis from Answer Set Programs

Our research concerns generating imperative programs from Answer Set Programming Specifications. ASP is highly declarative and is ideal for writing specifications. Further with negation-as-failure it is easy to succinctly represent combinatorial search problems. We are currently working on synthesizing imperative programs from ASP programs by turning the negation into useful computations. This opens up a novel way to synthesize programs from executable specifications.

Mechanized relational verification of concurrent programs with continuations

Concurrent higher-order imperative programming languages with continuations are very flexible and allow for the implementation of sophisticated programming patterns. For instance, it is well known that continuations can be used to implement cooperative concurrency. Continuations can also simplify web server implementations. This, in particular, helps simplify keeping track of the state of server’s clients. However, such advanced programming languages are very challenging to reason about. One of the main challenges in reasoning about programs in the presence of continuations is due to the fact that the non-local flow of control breaks the bind rule, one of the important modular reasoning principles of Hoare logic. In this paper we present the first completely formalized tool for interactive mechanized relational verification of programs written in a concurrent higher-order imperative programming language with continuations (call/cc and throw). We develop novel logical relations which can be used to give mechanized proofs of relational properties. In particular, we prove correctness of an implementation of cooperative concurrency with continuations. In addition, we show that that a rudimentary web server implemented using the continuation-based pattern is contextually equivalent to one implemented without the continuation-based pattern. We introduce context-local reasoning principles for our calculus which allows us to regain modular reasoning principles for the fragment of the language without non-local control flow. These novel reasoning principles can be used in tandem with our (non-context-local) Hoare logic for reasoning about programs that do feature non-local control flow. Indeed, we use the combination of context-local and non-context-local reasoning to simplify reasoning about the examples.

Linear capabilities for fully abstract compilation of separation-logic-verified code

Separation logic is a powerful program logic for the static modular verification of imperative programs. However, dynamic checking of separation logic contracts on the boundaries between verified and untrusted modules is hard, because it requires one to enforce (among other things) that outcalls from a verified to an untrusted module do not access memory resources currently owned by the verified module. This paper proposes an approach to dynamic contract checking by relying on support for capabilities, a well-studied form of unforgeable memory pointers that enables fine-grained, efficient memory access control. More specifically, we rely on a form of capabilities called linear capabilities for which the hardware enforces that they cannot be copied. We formalize our approach as a fully abstract compiler from a statically verified source language to an unverified target language with support for linear capabilities. The key insight behind our compiler is that memory resources described by spatial separation logic predicates can be represented at run time by linear capabilities. The compiler is separation-logic-proof-directed: it uses the separation logic proof of the source program to determine how memory accesses in the source program should be compiled to linear capability accesses in the target program. The full abstraction property of the compiler essentially guarantees that compiled verified modules can interact with untrusted target language modules as if they were compiled from verified code as well.

Algorithmic Completeness of Imperative Programming Languages

According to the Church-Turing Thesis, effectively calculable functions are functions computable by a Turing machine. Models that compute these functions are called Turing-complete. For example, we know that common imperative languages (such as C, Ada or Python) are Turing complete (up to unbounded memory). Algorithmic completeness is a stronger notion than Turing-completeness. It focuses not only on the input-output behavior of the computation but more importantly on the step-by-step behavior. Moreover, the issue is not limited to partial recursive functions, it applies to any set of functions. A model could compute all the desired functions, but some algorithms (ways to compute these functions) could be missing (see [10, 27] for examples related to primitive recursive algorithms). This paper’s purpose is to prove that common imperative languages are not only Turing-complete but also algorithmically complete, by using the axiomatic definition of the Gurevich’s Thesis and a fair bisimulation between the Abstract State Machines of Gurevich (defined in [16]) and a version of Jones’ While programs. No special knowledge is assumed, because all relevant material will be explained from scratch.