• arXiv.cs.PL Pub Date : 2020-06-18
Pengyu Nie; Karl Palmskog; Junyi Jessy Li; Milos Gligoric

Should the final right bracket in a record declaration be on a separate line? Should arguments to the rewrite tactic be separated by a single space? Coq code tends to be written in distinct manners by different people and teams. The expressiveness, flexibility, and extensibility of Coq's languages and notations means that Coq projects have a wide variety of recognizable coding styles, sometimes explicitly

更新日期：2020-07-01
• arXiv.cs.PL Pub Date : 2020-06-29

This article presents liquid resource types, a technique for automatically verifying the resource consumption of functional programs. Existing resource analysis techniques trade automation for flexibility -- automated techniques are restricted to relatively constrained families of resource bounds, while more expressive proof techniques admitting value-dependent bounds rely on handwritten proofs. Liquid

更新日期：2020-06-30
• arXiv.cs.PL Pub Date : 2020-06-26
Joseph W. Cutler; Daniel R. Licata; Norman Danner

A typical way of analyzing the time complexity of functional programs is to extract a recurrence expressing the running time of the program in terms of the size of its input, and then to solve the recurrence to obtain a big-O bound. For recurrence extraction to be compositional, it is also necessary to extract recurrences for the size of outputs of helper functions. Previous work has developed techniques

更新日期：2020-06-29
• arXiv.cs.PL Pub Date : 2020-06-26
Carmine Abate; Matteo Busi

We discuss the relation between fully abstract and robust compilation (preservation of satisfaction of arbitrary hyperproperties under adversarial contexts) showing the former implies some variant of the latter.

更新日期：2020-06-29
• arXiv.cs.PL Pub Date : 2020-06-24
Di Wang; David M Kahn; Jan Hoffmann

This article presents a type-based analysis for deriving upper bounds on the expected execution cost of probabilistic programs. The analysis is naturally compositional, parametric in the cost model, and supports higher order functions and inductive data types. The derived bounds are multivariate polynomials that are functions of data structures. Bound inference is enabled by local type rules that reduce

更新日期：2020-06-26
• arXiv.cs.PL Pub Date : 2020-06-25
Alberto Simões; Ricardo Queirós

There are countless reasons cited in scientific studies to explain the difficulties in programming learning. The reasons range from the subject's complexity, the ineffective teaching and study methods, to psychological aspects such as demotivation. Still, learning programming often boils down to practice on exercise solving. Hence, it is essential to understand that the nature of a programming exercise

更新日期：2020-06-26
• arXiv.cs.PL Pub Date : 2020-06-24
Gábor Antal; Márton Keleti; Péter Hegedűs

Software security is undoubtedly a major concern in today's software engineering. Although the level of awareness of security issues is often high, practical experiences show that neither preventive actions nor reactions to possible issues are always addressed properly in reality. By analyzing large quantities of commits in the open-source communities, we can categorize the vulnerabilities mitigated

更新日期：2020-06-25
• arXiv.cs.PL Pub Date : 2020-06-24
Dan Frumin; Robbert Krebbers; Lars Birkedal

We present a new version of ReLoC: a relational logic for proving refinements of programs in a language with higher-order state, fine-grained concurrency, polymorphism and recursive types. The core of ReLoC is the refinement judgment $e \precsim e' : \tau$, which expresses that a program $e$ refines a program $e'$ at type $\tau$. In contrast to earlier work on refinements for languages with higher-order

更新日期：2020-06-25
• arXiv.cs.PL Pub Date : 2020-06-22
Somashekaracharya G. Bhaskaracharya; Julien Demouth; Vinod Grover

A commonly occurring computation idiom in neural networks is to perform some pointwise operations on the result of a matrix multiplication. Such a sequence of operations is typically represented as a computation graph in deep learning compilers. When compiling to a GPU target, these computations can be individually mapped to manually tuned implementations provided by libraries such as cuBLAS and cuDNN

更新日期：2020-06-24
• arXiv.cs.PL Pub Date : 2020-06-22
Ashish Tiwari; Arjun Radhakrishna; Sumit Gulwani; Daniel Perelman

Programming-by-example technologies are being deployed in industrial products for real-time synthesis of various kinds of data transformations. These technologies rely on the user to provide few representative examples of the transformation task. Motivated by the need to find the most pertinent question to ask the user, in this paper, we introduce the {\em significant questions problem}, and show that

更新日期：2020-06-24
• arXiv.cs.PL Pub Date : 2020-06-22
Luca Buratti; Saurabh Pujar; Mihaela Bornea; Scott McCarley; Yunhui Zheng; Gaetano Rossiello; Alessandro Morari; Jim Laredo; Veronika Thost; Yufan Zhuang; Giacomo Domeniconi

The Software Naturalness hypothesis argues that programming languages can be understood through the same techniques used in natural language processing. We explore this hypothesis through the use of a pre-trained transformer-based language model to perform code analysis tasks.

更新日期：2020-06-24
• arXiv.cs.PL Pub Date : 2020-06-20
Shu-Hung YouPLT@Northwestern; Robert Bruce FindlerPLT@Northwestern; Christos DimoulasPLT@Northwestern

The effectiveness of concolic testing deteriorates as the size of programs increases. A promising way out is to test programs modularly, e.g., on a per function or class basis. Alas, this idea hits a roadblock in modern programming languages In modern languages, components expect functions, objects, and even classes as inputs. The crux of the problem is that existing concolic testing techniques cannot

更新日期：2020-06-23
• arXiv.cs.PL Pub Date : 2020-06-20
Jongouk Choi; Qingrui Liu; Changhee Jung

This paper presents CoSpec, a new architecture/compiler co-design scheme that works for commodity in-order processors used in energy-harvesting systems. To achieve crash consistency without requiring unconventional architectural support, CoSpec leverages speculation assuming that power failure is not going to occur and thus holds all committed stores in a store buffer (SB), as if they were speculative

更新日期：2020-06-23
• arXiv.cs.PL Pub Date : 2020-06-18
Hossein Hajipour; Mateusz Malinowski; Mario Fritz

In this work, we investigate the problem of revealing the functionality of a black-box agent. Notably, we are interested in the interpretable and formal description of the behavior of such an agent. Ideally, this description would take the form of a program written in a high-level language. This task is also known as reverse engineering and plays a pivotal role in software engineering, computer security

更新日期：2020-06-19
• arXiv.cs.PL Pub Date : 2020-06-18
Davide Trotta; Margherita Zorzi

Embedded programming style allows to split the syntax in two parts, representing respectively a host language H and a core language C embedded in H. This formally models several situations in which a user writes code in a main language and delegates some tasks to an ad hoc domain specific language. Moreover, as showed in recent years, a particular case of the host-core approach allows a flexible management

更新日期：2020-06-19
• arXiv.cs.PL Pub Date : 2020-06-18
Animesh Jain; Shoubhik Bhattacharya; Masahiro Masuda; Vin Sharma; Yida Wang

A growing number of applications implement predictive functions using deep learning models, which require heavy use of compute and memory. One popular technique for increasing resource efficiency is 8-bit integer quantization, in which 32-bit floating point numbers (fp32) are represented using shorter 8-bit integer numbers. Although deep learning frameworks such as TensorFlow, TFLite, MXNet, and PyTorch

更新日期：2020-06-19
• arXiv.cs.PL Pub Date : 2020-06-17
Diego Elias Costa; Suhaib Mujahid; Rabe Abdalkareem; Emad Shihab

A decade after its first release, the Go programming language has become a major programming language in the development landscape. While praised for its clean syntax and C-like performance, Go also contains a strong static type-system that prevents arbitrary type casting and arbitrary memory access, making the language type-safe by design. However, to give developers the possibility of implementing

更新日期：2020-06-18
• arXiv.cs.PL Pub Date : 2020-06-17
Marisa Kirisame; Steven Lyubomirsky; Altan Haan; Jennifer Brennan; Mike He; Jared Roesch; Tianqi Chen; Zachary Tatlock

Checkpointing enables training larger models by freeing intermediate activations and recomputing them on demand. Previous checkpointing techniques are difficult to generalize to dynamic models because they statically plan recomputations offline. We present Dynamic Tensor Rematerialization (DTR), a greedy online algorithm for heuristically checkpointing arbitrary models. DTR is extensible and general:

更新日期：2020-06-18
• arXiv.cs.PL Pub Date : 2020-06-16

We introduce a new logic that combines Adjoint Logic with Graded Necessity Modalities. This results in a very expressive system capable of controlling when and how structural rules are used. We give a sequent calculus, natural deduction, and term assignment for Graded Adjoint Logic.

更新日期：2020-06-16
• arXiv.cs.PL Pub Date : 2020-06-15
Sahil Suneja; Yunhui Zheng; Yufan Zhuang; Jim Laredo; Alessandro Morari

We explore the applicability of Graph Neural Networks in learning the nuances of source code from a security perspective. Specifically, whether signatures of vulnerabilities in source code can be learned from its graph representation, in terms of relationships between nodes and edges. We create a pipeline we call AI4VA, which first encodes a sample source code into a Code Property Graph. The extracted

更新日期：2020-06-15
• arXiv.cs.PL Pub Date : 2020-06-15
Ryan Kavanagh

O-categories generalize categories of domains to provide just the structure required to compute fixed points of locally continuous functors. Parametrized fixed points are of particular interest to denotational semantics and are often given by "dagger operations". We generalize existing techniques to define a functorial dagger operation on locally continuous functors between O-categories. We show that

更新日期：2020-06-15
• arXiv.cs.PL Pub Date : 2020-06-15
Yujun Yan; Kevin Swersky; Danai Koutra; Parthasarathy Ranganathan; Milad Heshemi

A significant effort has been made to train neural networks that replicate algorithmic reasoning, but they often fail to learn the abstract concepts underlying these algorithms. This is evidenced by their inability to generalize to data distributions that are outside of their restricted training sets, namely larger inputs and unseen data. We study these generalization issues at the level of numerical

更新日期：2020-06-15
• arXiv.cs.PL Pub Date : 2020-06-13
Wenda Li; Lei Yu; Yuhuai Wu; Lawrence C. Paulson

Mathematical proofs can be mechanised using proof assistants to eliminate gaps and errors. However, mechanisation still requires intensive labour. To promote automation, it is essential to capture high-level human mathematical reasoning, which we address as the problem of generating suitable propositions. We build a non-synthetic dataset from the largest repository of mechanised proofs and propose

更新日期：2020-06-13
• arXiv.cs.PL Pub Date : 2020-06-13
Alexis Martín; Alejandro Ríos; Andrés Viso

It is well-known in the field of programming languages that dealing with variable names and binders may lead to conflicts such as undesired captures when implementing interpreters or compilers. This situation has been overcome by resorting to de Bruijn indices for calculi where binders capture only one variable name, like the $\lambda$-calculus. The advantage of this approach relies on the fact that

更新日期：2020-06-13
• arXiv.cs.PL Pub Date : 2020-06-11
Benjamin Kowarsch

The Modula-2 language was first specified in [Wir78] by N.Wirth at ETH Zurich in 1978 and then revised several times. The last revision [Wir88] was published in 1988. The resulting language reports included ambiguities and lacked a comprehensive standard library. To resolve the ambiguities and specify a comprehensive standard library an ISO/IEC working group was formed and commenced work in 1987. A

更新日期：2020-06-11
• arXiv.cs.PL Pub Date : 2020-06-11
Lianmin Zheng; Chengfan Jia; Minmin Sun; Zhao Wu; Cody Hao Yu; Ameer Haj-Ali; Yida Wang; Jun Yang; Danyang Zhuo; Koushik Sen; Joseph Gonzalez; Ion Stoica

High-performance tensor programs are crucial to guarantee efficient execution of deep learning models. However, obtaining performant tensor programs for different operators on various hardware platforms is notoriously difficult. Currently, deep learning systems rely on vendor-provided kernel libraries or various search strategies to get performant tensor programs. These approaches either require significant

更新日期：2020-06-11
• arXiv.cs.PL Pub Date : 2020-06-10
Włodzimierz Drabent

The s-semantics makes it possible to explicitly deal with variables in program answers. So it seems suitable for programs using nonground data structures, like open lists. However it is difficult to find examples of using the s-semantics to reason about particular programs. Here we apply s-semantics to prove correctness and completeness of Fr\"uhwirth's $n$ queens program. This is compared with a proof

更新日期：2020-06-10
• arXiv.cs.PL Pub Date : 2020-06-10
Bruce Collie; Michael O'Boyle

Symbolic holes are one of the fundamental building blocks of solver-aided and interactive programming. Unknown values can be soundly integrated into programs, and automated tools such as SAT solvers can be used to prove properties of programs containing them. However, supporting symbolic holes in a programming language is challenging; specifying interactions of holes with the type system and execution

更新日期：2020-06-10
• arXiv.cs.PL Pub Date : 2020-06-10
Mathias Bourgoin; Benjamin Canou; Emmanuel Chailloux; Adrien Jonquet; Philippe Wang

Objective Caml is a famous dialect of the ML family languages. It is well-known for its performance as a compiled programming language, notably thanks to its incremental generational automatic memory collection. However, for historical reasons, the latter was built for monocore processors. One consequence is the runtime library assumes there is effectively no more than one thread running at a time

更新日期：2020-06-10
• arXiv.cs.PL Pub Date : 2020-06-09
Pierre ClairambaultLIP, PLUME

In this paper we develop the theory of how to count, in thin concurrent games, the configurations of a strategy witnessing that it reaches a certain configuration of the game. This plays a central role in many recent developments in concurrent games, whenever one aims to relate concurrent strategies with weighted relational models. The difficulty, of course, is symmetry: in the presence of symmetry

更新日期：2020-06-09
• arXiv.cs.PL Pub Date : 2020-06-08
Markus N. Rabe; Dennis Lee; Kshitij Bansal; Christian Szegedy

We examine whether language modeling applied to mathematical formulas enables logical reasoning. We suggest several logical reasoning tasks that can be used to evaluate language models trained on formal mathematical statements, such as type inference, suggesting missing assumptions and completing equalities. To train language models for formal mathematics, we propose a novel skip-tree task, which outperforms

更新日期：2020-06-08
• arXiv.cs.PL Pub Date : 2020-06-08
Rinaldi Fabio; Dolci Daniele

In this paper we adapt the RBF Solver to work with quaternions by taking advantage of their Lie Algebra and exponential map. This will allow to work with quaternions as if they were normal vectors in R^3 and blend them in a very efficient way.

更新日期：2020-06-08
• arXiv.cs.PL Pub Date : 2020-06-06
Massimo Bartoletti; Stefano Lande; Roberto Zunino

Covenants are linguistic primitives that extend the Bitcoin script language, allowing transactions to constrain the scripts of the redeeming ones. Advocated as a way of improving the expressiveness of Bitcoin contracts while preserving the simplicity of the UTXO design, various forms of covenants have been proposed over the years. A common drawback of the existing descriptions is the lack of formalization

更新日期：2020-06-06
• arXiv.cs.PL Pub Date : 2020-06-06
Emery D. Berger

Existing profilers for scripting languages (a.k.a. "glue" languages) like Python suffer from numerous problems that drastically limit their usefulness. They impose order-of-magnitude overheads, report information at too coarse a granularity, or fail in the face of threads. Worse, past profilers---essentially variants of their counterparts for C---are oblivious to the fact that optimizing code in scripting

更新日期：2020-06-06
• arXiv.cs.PL Pub Date : 2020-06-05
Marie-Anne Lachaux; Baptiste Roziere; Lowik Chanussot; Guillaume Lample

A transcompiler, also known as source-to-source translator, is a system that converts source code from a high-level programming language (such as C++ or Python) to another. Transcompilers are primarily used for interoperability, and to port codebases written in an obsolete or deprecated language (e.g. COBOL, Python 2) to a modern one. They typically rely on handcrafted rewrite rules, applied to the

更新日期：2020-06-05
• arXiv.cs.PL Pub Date : 2020-06-04

Automatic indentation of source code is fundamentally a simple matter of parsing the code and then applying language- and style-specific rules about relative indentation of the various constructs. Yet, in practice, full parsing is not always an option, either because of quirks of the language, or because the code is temporarily syntactically incorrect, or because of an incomplete or broken grammar

更新日期：2020-06-04
• arXiv.cs.PL Pub Date : 2020-06-04
Bertrand PetitINRIA, France; Manuel SerranoINRIA, France

This paper presents Skini, a programming methodology and an execution environment for interactive structured music. With this system, the composer programs his scores in the HipHop.js synchronous reactive language. They are then executed, or played, in live concerts, in interaction with the audience. The system aims at helping composers to find a good balance between the determinism of the compositions

更新日期：2020-06-04
• arXiv.cs.PL Pub Date : 2020-06-04
Haichen Shen; Jared Roesch; Zhi Chen; Wei Chen; Yong Wu; Mu Li; Vin Sharma; Zachary Tatlock; Yida Wang

Modern deep neural networks increasingly make use of features such as dynamic control flow, data structures and dynamic tensor shapes. Existing deep learning systems focus on optimizing and executing static neural networks which assume a pre-determined model architecture and input data shapes--assumptions which are violated by dynamic neural networks. Therefore, executing dynamic models with deep learning

更新日期：2020-06-04
• arXiv.cs.PL Pub Date : 2020-06-04
Axel Legay; Dirk Nowotka; Danny Bøgsted Poulsen

In this work we present our work in developing a software verification tool for llvm-code - Lodin - that incorporates both explicit-state model checking, statistical model checking and symbolic state model checking algorithms.

更新日期：2020-06-04
• arXiv.cs.PL Pub Date : 2020-06-03
Dimitur Krustev

Supercompilation is a powerful program transformation technique with numerous interesting applications. Existing methods of supercompilation, however, are often very unpredictable with respect to the size of the resulting programs. We consider an approach for controlling result size, based on a combination of multi-result supercompilation and a specific generalization strategy, which avoids code duplication

更新日期：2020-06-03
• arXiv.cs.PL Pub Date : 2020-06-02
Sanket Tavarageri; Alexander Heinecke; Sasikanth Avancha; Gagandeep Goyal; Ramakrishna Upadrasta; Bharat Kaul

Deep Neural Networks (DNNs) have revolutionized many aspects of our lives. The use of DNNs is becoming ubiquitous including in softwares for image recognition, speech recognition, speech synthesis, language translation, to name a few. he training of DNN architectures however is computationally expensive. Once the model is created, its use in the intended application - the inference task, is computationally

更新日期：2020-06-02
• arXiv.cs.PL Pub Date : 2020-06-02
Sander Huyghebaert; Thomas Van Strydonck; Steven Keuchel; Dominique Devriese

This technical report describes a new extension to capability machines. Capability machines are a special type of processors that include better security primitives at the hardware level. In capability machines, every word has an associated tag bit that indicates whether the value it contains is a capability or a regular data value. Capabilities enable fine-grained control of the authority over memory

更新日期：2020-06-02
• arXiv.cs.PL Pub Date : 2020-06-02
Sandra Dylus

This thesis investigates effectful declarative programming with an emphasis on non-determinism as an effect. On the one hand, we are interested in developing applications using non-determinism as underlying implementation idea. We discuss two applications using the functional logic programming language Curry. The key idea of these implementations is to exploit the interplay of non-determinism and non-strictness

更新日期：2020-06-02
• arXiv.cs.PL Pub Date : 2020-06-02
Andreas Pavlogiannis

Pointer analysis is one of the fundamental problems in static program analysis. Given a set of pointers, the task is to produce a useful over-approximation of the memory locations that each pointer may point-to at runtime. The most common formulation is Andersen's Pointer Analysis (APA), defined as an inclusion-based set of $m$ pointer constraints over a set of $n$ pointers. Existing algorithms solve

更新日期：2020-06-02
• arXiv.cs.PL Pub Date : 2020-05-30
Xiang Fu

This document is the specification of the CC-Light instantiation of executable QASM (eQASM), a quantum instruction set architecture (QISA) developed in QuTech targeting to control a seven-qubit superconducting quantum processor. This document can serve as a reference manual for low-level programmers, compiler backend developers, and microarchitecture implementers of eQASM. The design of CC-Light eQASM

更新日期：2020-05-30
• arXiv.cs.PL Pub Date : 2020-05-29
Evandro Chagas Ribeiro da Rosa; Rafael de Santiago

We propose a runtime architecture that can be used in the development of a quantum programming language and its programming environment. The proposed runtime architecture enables dynamic interaction between classical and quantum data following the restriction that a quantum computer is available in the cloud as a batch computer, with no interaction with the classical computer during its execution.

更新日期：2020-05-29
• arXiv.cs.PL Pub Date : 2020-05-29
Luís Pedro Arrojado da Horta; João Santos Reis; Mário Pereira; Simão Melo de Sousa

This paper introduces WhylSon, a deductive verification tool for smart contracts written in Michelson, which is the low-level language of the Tezos blockchain. WhylSon accepts a formally specified Michelson contract and automatically translates it to an equivalent program written in WhyML, the programming and specification language of the Why3 framework. Smart contract instructions are mapped into

更新日期：2020-05-29
• arXiv.cs.PL Pub Date : 2020-05-28
Davide Ancona; Pietro Barbieri; Francesco Dagnino; Elena Zucca

The aim of the paper is to provide solid foundations for a programming paradigm natively supporting the creation and manipulation of cyclic data structures. To this end, we describe coFJ, a Java-like calculus where objects can be infinite and methods are equipped with a codefinition (an alternative body). We provide an abstract semantics of the calculus based on the framework of inference systems with

更新日期：2020-05-28
• arXiv.cs.PL Pub Date : 2020-05-28
Georgios Karachalias; Matija Pretnar; Amr Hany Saleh; Stien Vanderhallen; Tom Schrijvers

As popularity of algebraic effects and handlers increases, so does a demand for their efficient execution. Eff, an ML-like language with native support for handlers, has a subtyping-based effect system on which an effect-aware optimizing compiler could be built. Unfortunately, in our experience, implementing optimizations for Eff is overly error-prone because its core language is implicitly-typed,

更新日期：2020-05-28
• arXiv.cs.PL Pub Date : 2020-05-28
Darshak Chhatbar; Umair Z. Ahmed; Purushottam Kar

Automated compilation error repair, the problem of suggesting fixes to buggy programs that fail to compile, has generated significant interest in recent years. Apart from being a tool of general convenience, automated code repair has significant pedagogical applications for novice programmers who find compiler error messages cryptic and unhelpful. Existing approaches largely solve this problem using

更新日期：2020-05-28
• arXiv.cs.PL Pub Date : 2020-05-27
Ameer Haj-Ali; Hasan Genc; Qijing Huang; William Moses; John Wawrzynek; Krste Asanović; Ion Stoica

We explore applying the Monte Carlo Tree Search (MCTS) algorithm in a notoriously difficult task: tuning programs for high-performance deep learning and image processing. We build our framework on top of Halide and show that MCTS can outperform the state-of-the-art beam-search algorithm. Unlike beam search, which is guided by greedy intermediate performance comparisons between partial and less meaningful

更新日期：2020-05-27
• arXiv.cs.PL Pub Date : 2020-05-27
Žiga Lukšič; Matija Pretnar

Algebraic effects are computational effects that can be described with a set of basic operations and equations between them. As many interesting effect handlers do not respect these equations, most approaches assume a trivial theory, sacrificing both reasoning power and safety. We present an alternative approach where the type system tracks equations that are observed in subparts of the program, yielding

更新日期：2020-05-27
• arXiv.cs.PL Pub Date : 2020-05-27
Farzin Houshmand; Mohsen Lesani; Keval Vora

Graph analytics elicits insights from large graphs to inform critical decisions for business, safety and security. Several large-scale graph processing frameworks feature efficient runtime systems; however, they often provide programming models that are low-level and subtly different from each other. Therefore, end users can find implementation and specially optimization of graph analytics time-consuming

更新日期：2020-05-27
• arXiv.cs.PL Pub Date : 2020-05-27
Shaked Brody; Uri Alon; Eran Yahav

We address the problem of predicting edit completions based on a learned model that was trained on past edits. Given a code snippet that is partially edited, our goal is to predict a completion of the edit for the rest of the snippet. We refer to this task as the EditCompletion task and present a novel approach for tackling it. The main idea is to directly represent structural edits. This allows us

更新日期：2020-05-27
• arXiv.cs.PL Pub Date : 2020-05-27
N. Khammassi; I. Ashraf; J. v. Someren; R. Nane; A. M. Krol; M. A. Rol; L. Lao; K. Bertels; C. G. Almudever

With the potential of quantum algorithms to solve intractable classical problems, quantum computing is rapidly evolving and more algorithms are being developed and optimized. Expressing these quantum algorithms using a high-level language and making them executable on a quantum processor while abstracting away hardware details is a challenging task. Firstly, a quantum programming language should provide

更新日期：2020-05-27
• arXiv.cs.PL Pub Date : 2020-05-26
Mallku Soldevila; Beta Ziliani; Daniel Fridlender

We provide the semantics of garbage collection (GC) for the Lua programming language. Of interest are the inclusion of finalizers(akin to destructors in object-oriented languages) and weak tables (a particular implementation of weak references). The model expresses several aspects relevant to GC that are not covered in Lua's documentation but that, nevertheless, affect the observable behavior of programs

更新日期：2020-05-26
• arXiv.cs.PL Pub Date : 2020-05-26
Tobias Gysi; Christoph Müller; Oleksandr Zinenko; Stephan Herhut; Eddie Davis; Tobias Wicky; Oliver Fuhrer; Torsten Hoefler; Tobias Grosser

Traditional compilers operate on a single generic intermediate representation (IR). These IRs are usually low-level and close to machine instructions. As a result, optimizations relying on domain-specific information are either not possible or require complex analysis to recover the missing information. In contrast, multi-level rewriting instantiates a hierarchy of dialects (IRs), lowers programs level-by-level

更新日期：2020-05-26
• arXiv.cs.PL Pub Date : 2020-05-24
João Santos Reis; Paul Crocker; Simão Melo de Sousa

This paper introduces Tezla, an intermediate representation of Michelson smart contracts that eases the design of static smart contract analysers. This intermediate representation uses a store and preserves the semantics, ow and resource usage of the original smart contract. This enables properties like gas consumption to be statically verified. We provide an automated decompiler of Michelson smart

更新日期：2020-05-24
• arXiv.cs.PL Pub Date : 2020-05-24
Péter Bereczky; Dániel Horpácsi; Simon Thompson

Our research is part of a wider project that aims to investigate and reason about the correctness of scheme-based source code transformations of Erlang programs. In order to formally reason about the definition of a programming language and the software built using it, we need a mathematically rigorous description of that language. In this paper, we present our proof-assistant-based formalisation of

更新日期：2020-05-24
• arXiv.cs.PL Pub Date : 2020-05-24
Robert Griesemer; Raymond Hu; Wen Kokke; Julien Lange; Ian Lance Taylor; Bernardo Toninho; Philip Wadler; Nobuko Yoshida

We describe a design for generics in Go inspired by previous work on Featherweight Java by Igarashi, Pierce, and Wadler. Whereas subtyping in Java is nominal, in Go it is structural, and whereas generics in Java are defined via erasure, in Go we use monomorphisation. Although monomorphisation is widely used, we are one of the first to formalise it. Our design also supports a solution to The Expression

更新日期：2020-05-24
Contents have been reproduced by permission of the publishers.

down
wechat
bug