• arXiv.cs.PL Pub Date : 2020-11-23
Truc Lam Bui; Krishnendu Chatterjee; Tushar Gautam; Andreas Pavlogiannis; Viktor Toman

The verification of concurrent programs remains an open challenge due to the non-determinism in inter-process communication. Instead of exploring concrete executions, stateless model-checking (SMC) techniques partition the execution space into equivalence classes, and explore each class as opposed to each execution. For the relaxed memory models of TSO and PSO (total/partial store order), the standard

更新日期：2020-11-25
• arXiv.cs.PL Pub Date : 2020-11-22
Eli Sennesh

Humans surpass the cognitive abilities of most other animals in our ability to "chunk" concepts into words, and then combine the words to combine the concepts. In this process, we make "infinite use of finite means", enabling us to learn new concepts quickly and nest concepts within each-other. While program induction and synthesis remain at the heart of foundational theories of artificial intelligence

更新日期：2020-11-25
• arXiv.cs.PL Pub Date : 2020-11-21
Philipp Klaus Krause

Lifetime-optimal speculative partial redundancy elimination (lospre) is the most advanced currently known redundancy elimination technique. It subsumes many previously known approaches, such as common subexpression elimination, global common subexpression elimination, and loop-invariant code motion. However, previously known lospre algorithms have high time complexity; faster but less powerful approaches

更新日期：2020-11-25
• arXiv.cs.PL Pub Date : 2020-11-20
Meven Lennon-Bertrand; Kenji Maillard; Nicolas Tabareau; Éric Tanter

Acknowledging the ordeal of a fully formal development in a proof assistant such as Coq, we investigate gradual variations on the Calculus of Inductive Construction (CIC) for swifter prototyping with imprecise types and terms. We observe, with a no-go theorem, a crucial tradeoff between graduality and the key properties of normalization and closure of universes under dependent product that CIC enjoys

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

Formal semantics provides rigorous, mathematically precise definitions of programming languages, with which we can argue about program behaviour and program equivalence by formal means; in particular, we can describe and verify our arguments with a proof assistant. There are various approaches to giving formal semantics to programming languages, at different abstraction levels and applying different

更新日期：2020-11-23
• arXiv.cs.PL Pub Date : 2020-11-18
Ankush Das; Di Wang; Jan Hoffmann

Session types guarantee that message-passing processes adhere to predefined communication protocols. Prior work on session types has focused on deterministic languages but many message-passing systems, such as Markov chains and randomized distributed algorithms, are probabilistic. To model and analyze such systems, this article introduces probabilistic session types and explores their application in

更新日期：2020-11-19
• arXiv.cs.PL Pub Date : 2020-11-18
GongmingGabriel; Luo; Vishnu Reddy; Marcelo Almeida; Yingying Zhu; Ke Du; Cyrus Omar

Rust is a systems programming language that guarantees memory safety without the need for a garbage collector by statically tracking ownership and borrowing events. The associated rules are subtle and unique among industry programming languages, which can make learning Rust more challenging. Motivated by the challenges that Rust learners face, we are developing RustViz, a tool that allows teachers

更新日期：2020-11-19
• arXiv.cs.PL Pub Date : 2020-11-17
Andrei Diaconu

Inductive programming (IP) is a field whose main goal is synthesising programs that respect a set of examples, given some form of background knowledge. This paper is concerned with a subfield of IP, inductive functional programming (IFP). We explore the idea of generating modular functional programs, and how those allow for function reuse, with the aim to reduce the size of the programs. We introduce

更新日期：2020-11-19
• arXiv.cs.PL Pub Date : 2020-11-16
Richard Lin; Björn Hartmann

Board-level hardware description languages (HDLs) are one approach to increasing automation and raising the level of abstraction for designing electronics. These systems borrow programming languages concepts like generators and type systems, but also must be designed with human factors in mind to serve existing hardware engineers. In this work, we look at one recent prototype system, and discuss open

更新日期：2020-11-18
• arXiv.cs.PL Pub Date : 2020-11-16
Denis MerigouxPROSECCO, Inria; Raphaël MonatSU, CNRS; Jonathan ProtzenkoMSR

In France, income tax is computed from taxpayers' individual returns, using an algorithm that is authored, designed and maintained by the French Public Finances Directorate (DGFiP). This algorithm relies on a legacy custom language and compiler originally designed in 1990, which unlike French wine, did not age well with time. Owing to the shortcomings of the input language and the technical limitations

更新日期：2020-11-17
• arXiv.cs.PL Pub Date : 2020-11-15
Georg Stefan SchmidEPFL; Olivier BlanvillainEPFL; Jad HamzaEPFL; Viktor KunčakEPFL

Type-level programming is an increasingly popular way to obtain additional type safety. Unfortunately, it remains a second-class citizen in the majority of industrially-used programming languages. We propose a new dependently-typed system with subtyping and singleton types whose goal is to enable type-level programming in an accessible style. At the heart of our system lies a non-deterministic choice

更新日期：2020-11-17
• arXiv.cs.PL Pub Date : 2020-11-15
Michael Coblenz; Ariel Davis; Megan Hofmann; Vivian Huang; Siyue Jin; Max Krieger; Kyle Liang; Brian Wei; Mengchen Sam Yong; Jonathan Aldrich

Recently, user-centered methods have been proposed to improve the design of programming languages. In order to explore what benefits these methods might have for novice programming language designers, we taught a collection of user-centered programming language design methods to a group of eight students. We observed that natural programming and usability studies helped the students refine their language

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

Many software development problems can be addressed by program analysis tools, which traditionally are based on precise, logical reasoning and heuristics to ensure that the tools are practical. Recent work has shown tremendous success through an alternative way of creating developer tools, which we call neural software analysis. The key idea is to train a neural machine learning model on numerous code

更新日期：2020-11-17
• arXiv.cs.PL Pub Date : 2020-11-12
Will Crichton

Ownership is the concept of tracking aliases and mutations to data, useful for both memory safety and system design. The Rust programming language implements ownership via the borrow checker, a static analyzer that extends the core type system. The borrow checker is a notorious learning barrier for new Rust users. In this paper, I focus on the gap between understanding ownership in theory versus its

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

Differential privacy is a mathematical framework for developing statistical computations with provable guarantees of privacy and accuracy. In contrast to the privacy component of differential privacy, which has a clear mathematical and intuitive meaning, the accuracy component of differential privacy does not have a generally accepted definition; accuracy claims of differential privacy algorithms vary

更新日期：2020-11-13
• arXiv.cs.PL Pub Date : 2020-11-11
Dominic Orchard; Mistral Contrastin; Matthew Danish; Andrew Rice

This extended abstract reports on previous work of the CamFort project in which we developed an external units-of-measure type system for Fortran code, targeted at scientists. Our approach can guide the programmer in adding specifications (type annotations) to existing code, with the aim of easing adoption on legacy code. Pertinent to the topics of the HATRA workshop, we discuss the human-aspects of

更新日期：2020-11-13
• arXiv.cs.PL Pub Date : 2020-11-11
Ryan Doenges; Mina Tahmasbi Arashloo; Santiago Bautista; Alexander Chang; Newton Ni; Samwise Parkinson; Rudy Peterson; Alaia Solko-Breslin; Amanda Xu; Nate Foster

P4 is a domain-specific language for programming and specifying packet-processing systems. It is based on an elegant design with high-level abstractions like parsers and match-action pipelines that can be compiled to efficient implementations in software or hardware. Unfortunately, like many industrial languages, P4 has developed without a formal foundation. The P4 Language Specification is a 160-page

更新日期：2020-11-12
• arXiv.cs.PL Pub Date : 2020-11-11
Ian Rogers

In a compiler, an essential component is the register allocator. Two main algorithms have dominated implementations, graph coloring and linear scan, differing in how live values are modeled. Graph coloring uses an edge in an `interference graph' to show that two values cannot reside in the same register. Linear scan numbers all values, creates intervals between definition and uses, and then intervals

更新日期：2020-11-12
• arXiv.cs.PL Pub Date : 2020-11-11
Pascal Baumann; Rupak Majumdar; Ramanathan S. Thinniyam; Georg Zetzsche

Dynamic networks of concurrent pushdown systems (DCPS) are a theoretical model for multi-threaded recursive programs with shared global state and dynamical creation of threads. The (global) state reachability problem for DCPS is undecidable in general, but Atig et al. (2009) showed that it becomes decidable, and is in 2EXPSPACE, when each thread is restricted to a fixed number of context switches.

更新日期：2020-11-12
• arXiv.cs.PL Pub Date : 2020-11-10
Nobuko Yoshida; Simon Castellan; Léo Stefanesco

Game semantics has proven to be a robust method to give compositional semantics for a variety of higher-order programming languages. However, due to the complexity of most game models, game semantics has remained unapproachable for non-experts. In this paper, we aim at making game semantics more accessible by viewing it as a syntactic translation into a session typed pi-calculus, referred to as metalanguage

更新日期：2020-11-12
• arXiv.cs.PL Pub Date : 2020-11-05
Michał J. Gajda

Network latency distributions, their algebra, and use examples. This paper considers modeling of capacity-insensitive processes and distributed systems. It provides algebraic properties of the latency distribution algebra and Haskell code to implement the model.

更新日期：2020-11-12
• arXiv.cs.PL Pub Date : 2020-11-10
Jayaraj Poroor

A domain specific language (DSL), named MotePy is presented. The DSL offers a high level syntax with low overheads for ML/data processing in time constrained or memory constrained systems. The DSL-to-C compiler has a novel static memory allocator that tracks object lifetimes and reuses the static memory, which we call the compiler-managed heap.

更新日期：2020-11-12
• arXiv.cs.PL Pub Date : 2020-11-10
Zvonimir Pavlinovic; Yusen Su; Thomas Wies

Refinement types enable lightweight verification of functional programs. Algorithms for statically inferring refinement types typically work by reduction to solving systems of constrained Horn clauses extracted from typing derivations. An example is Liquid type inference, which solves the extracted constraints using predicate abstraction. However, the reduction to constraint solving in itself already

更新日期：2020-11-12
• arXiv.cs.PL Pub Date : 2020-11-09
Thomas DupriezCNRS, CRIStAL, RMOD; Steven CostiouCNRS, CRIStAL, RMOD; Stéphane DucasseCNRS, CRIStAL, RMOD

As applications get developed, bugs inevitably get introduced. Often, it is unclear why a given code change introduced a given bug. To find this causal relation and more effectively debug, developers can leverage the existence of a previous version of the code, without the bug. But traditional debug-ging tools are not designed for this type of work, making this operation tedious. In this article, we

更新日期：2020-11-12
• arXiv.cs.PL Pub Date : 2020-11-08
Pritam Choudhury; Harley Eades III; Richard A. Eisenberg; Stephanie C Weirich

Graded Type Theory provides a mechanism to track and reason about resource usage in type systems. In this paper, we develop a novel version of such a graded dependent type system, including functions, tensor products, additive sums, and a unit type. Since standard operational semantics is resource-agnostic, we develop a heap-based operational semantics and prove a soundness theorem that shows correct

更新日期：2020-11-12
• arXiv.cs.PL Pub Date : 2020-11-07
Yue NiuCarnegie Mellon University; Robert HarperCarnegie Mellon University

Although computational complexity is a fundamental aspect of program behavior, it is often at odds with common type theoretic principles such as function extensionality, which identifies all functions with the same $\textit{input-output}$ behavior. We present a computational type theory called $\mathbf{CATT}$ that has a primitive notion of cost (the number of evaluation steps). We introduce a new dependent

更新日期：2020-11-12
• arXiv.cs.PL Pub Date : 2020-11-05
Michał J. Gajda; Hai Nguyen Quang; Do Ngoc Khanh; Vuong Hai Thanh

We propose reformulation of discovery of data structure within a web page as relations between sets of document nodes. We start by reformulating web page analysis as finding expressions in extension of XPath. Then we propose to automatically discover these XPath expressions with InferXPath meta-language. Our goal is to automate laborious process of conversion of manually created web pages that serve

更新日期：2020-11-12
• arXiv.cs.PL Pub Date : 2020-11-05
Michał J. Gajda

Property testing is the cheapest and most precise way of building up a test suite for your program. Especially if the datatypes enjoy nice mathematical laws. But it is also the easiest way to make it run for an unreasonably long time. We prove connection between deeply recursive data structures, and epidemic growth rate, and show how to fix the problem, and make Arbitrary instances run in linear time

更新日期：2020-11-12
• arXiv.cs.PL Pub Date : 2020-11-05
Michał J. Gajda; Dmitry Krylov

The paper presents and compares a range of parsers with and without data mapping for conversion between XML and Haskell. The best performing parser competes favorably with the fastest tools available in other languages and is, thus, suitable for use in large-scale data analysis. The best performing parser also allows software developers of intermediate-level Haskell programming skills to start processing

更新日期：2020-11-12
• arXiv.cs.PL Pub Date : 2020-11-09
Pascal Baumann; Rupak Majumdar; Ramanathan S. Thinniyam; Georg Zetzsche

We study context-bounded verification of liveness properties of multi-threaded, shared-memory programs, where each thread can spawn additional threads. Our main result shows that context-bounded fair termination is decidable for the model; context-bounded implies that each spawned thread can be context switched a fixed constant number of times. Our proof is technical, since fair termination requires

更新日期：2020-11-12
• arXiv.cs.PL Pub Date : 2020-11-09
Sérgio Medeiros; Carlos Olarte

Parsing Expression Grammars (PEGs) are a recognition-based formalism which allows to describe the syntactical and the lexical elements of a language. The main difference between Context-Free Grammars (CFGs) and PEGs relies on the interpretation of the choice operator: while the CFGs' unordered choice e | e' is interpreted as the union of the languages recognized by e and e, the PEGs' prioritized choice

更新日期：2020-11-12
• arXiv.cs.PL Pub Date : 2020-11-06
Niranjan Hasabnis; Justin Gottschlich

Software debugging has been shown to utilize upwards of 50% of developers' time. Machine programming, the field concerned with the automation of software (and hardware) development, has recently made progress in both research and production-quality automated debugging systems. In this paper, we present ControlFlag, a system that detects possible idiosyncratic violations in software control structures

更新日期：2020-11-12
• arXiv.cs.PL Pub Date : 2020-11-06
Yusuke Izawa; Hidehiko Masuhara

Many modern virtual machines, such as JVMs, .NET Framework and V8, employ a just-in-time (JIT) compiler to achieve their high-performance. There are two major compilation strategies; trace-based compilation and method-based compilation. They have their own advantages and disadvantages, so we presume that applying suitable strategies for different program parts is essential for faster execution. This

更新日期：2020-11-09
• arXiv.cs.PL Pub Date : 2020-11-05
Michał J. Gajda

We present a principled theoretical framework for inferring and checking the union types, and show its work in practice on JSON data structures. The framework poses a union type inference as a learning problem from multiple examples. The categorical framework is generic and easily extensible.

更新日期：2020-11-09
• arXiv.cs.PL Pub Date : 2020-11-05
Michał J. Gajda; Vitor Vitali Barrozzi; Gabriel Araujo

We present industry experience from implementing retargetable cloud API binding generator. The analysis is implemented in Haskell, using type classes, types a la carte, and code generation monad. It also targets Haskell, and allows us to bind cloud APIs on short notice, and unprecedented scale.

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

Denning's lattice model provided secure information flow analyses with an intuitive mathematical foundation: the lattice ordering determines permitted flows. We examine how this framework may be extended to support the flow of information between autonomous organisations, each employing possibly quite different security lattices and information flow policies. We propose a connection framework that

更新日期：2020-11-09
• arXiv.cs.PL Pub Date : 2020-11-05
R. Peschke; K. Nishimura; G. Varner

We present a High-Level Python-based Hardware Description Language (ARGG-HDL), It uses Python as its source language and converts it to standard VHDL. Compared to other approaches of building converters from a high-level programming language into a hardware description language, this new approach aims to maintain an object-oriented paradigm throughout the entire process. Instead of removing all the

更新日期：2020-11-06
• arXiv.cs.PL Pub Date : 2020-10-30
Umang Mathur; Andreas Pavlogiannis; Mahesh Viswanathan

Concurrent programs are notoriously hard to write correctly, as scheduling nondeterminism introduces subtle errors that are both hard to detect and to reproduce. The most common concurrency errors are (data) races, which occur when memory-conflicting actions are executed concurrently. Consequently, considerable effort has been made towards developing efficient techniques for race detection. The most

更新日期：2020-11-02
• arXiv.cs.PL Pub Date : 2020-10-30
Long Pham; Jan Hoffmann

Being a fully automated technique for resource analysis, automatic amortized resource analysis (AARA) can fail in returning worst-case cost bounds of programs, fundamentally due to the undecidability of resource analysis. For programmers who are unfamiliar with the technical details of AARA, it is difficult to predict whether a program can be successfully analyzed in AARA. Motivated by this problem

更新日期：2020-11-02
• arXiv.cs.PL Pub Date : 2020-10-30
Katsumi Okuda; Shigeru Chiba

Context: An island parser reads an input text and builds the parse (or abstract syntax) tree of only the programming constructs of interest in the text. These constructs are called islands and the rest of the text is called water, which the parser ignores and skips over. Since an island parser does not have to parse all the details of the input, it is often easy to develop but still useful enough for

更新日期：2020-11-02
• arXiv.cs.PL Pub Date : 2020-10-30
Michail Papadimitriou; Juan Fumero; Athanasios Stratikopoulos; Foivos S. Zakkak; Christos Kotselidis

In recent years, heterogeneous computing has emerged as the vital way to increase computers? performance and energy efficiency by combining diverse hardware devices, such as Graphics Processing Units (GPUs) and Field Programmable Gate Arrays (FPGAs). The rationale behind this trend is that different parts of an application can be offloaded from the main CPU to diverse devices, which can efficiently

更新日期：2020-11-02
• arXiv.cs.PL Pub Date : 2020-10-30
Hsiang-Shang Ko

In dependently typed programming, proofs of basic, structural properties can be embedded implicitly into programs and do not need to be written explicitly. Besides saving the effort of writing separate proofs, a most distinguishing and fascinating aspect of dependently typed programming is that it makes the idea of interactive type-driven development much more powerful, where expressive type information

更新日期：2020-11-02
• arXiv.cs.PL Pub Date : 2020-10-30
Humberto Rodriguez Avila; Joeri De Koster; Wolfgang De Meuter

Context: Actor-based programming languages offer many essential features for developing modern distributed reactive systems. These systems exploit the actor model's isolation property to fulfill their performance and scalability demands. Unfortunately, the reliance of the model on isolation as its most fundamental property requires programmers to express complex interaction patterns between their actors

更新日期：2020-11-02
• arXiv.cs.PL Pub Date : 2020-10-30
Gabriel HondetDEDUCTEAM, Inria, LSV, ENS Paris Saclay, CNRS; Frédéric BlanquiDEDUCTEAM, Inria, LSV, ENS Paris Saclay, CNRS

Dedukti is a type-checker for the $\lambda$$\Pi$-calculus modulo rewriting, an extension of Edinburgh's logicalframework LF where functions and type symbols can be defined by rewrite rules. It thereforecontains an engine for rewriting LF terms and types according to the rewrite rules given by the user.A key component of this engine is the matching algorithm to find which rules can be fired. In thispaper

更新日期：2020-11-02
• arXiv.cs.PL Pub Date : 2020-10-30
Walther NeuperJohannes Kepler University Linz, Austria

Software tools of Automated Reasoning are too sophisticated for general use in mathematics education and respective reasoning, while Lucas-Interpretation provides a general concept for integrating such tools into educational software with the purpose to reliably and flexibly check formal input of students. This paper gives the first technically concise description of Lucas-Interpretation at the occasion

更新日期：2020-11-02
• arXiv.cs.PL Pub Date : 2020-10-29
Hongbo Rong; Xiaochen Hao; Yun Liang; Lidong Xu; Hong H Jiang; Pradeep Dubey

We propose a language and compiler to productively build high-performance {\it software systolic arrays} that run on GPUs. Based on a rigorous mathematical foundation (uniform recurrence equations and space-time transform), our language has a high abstraction level and covers a wide range of applications. A programmer {\it specifies} a projection of a dataflow compute onto a linear systolic array,

更新日期：2020-11-02
• arXiv.cs.PL Pub Date : 2020-10-30
Frédéric BlanquiLSV,ENS Paris Saclay

The expressiveness of dependent type theory can be extended by identifying types modulo some additional computation rules. But, for preserving the decidability of type-checking or the logical consistency of the system, one must make sure that those user-defined rewriting rules preserve typing. In this paper, we give a new method to check that property using Knuth-Bendix completion.

更新日期：2020-11-02
• arXiv.cs.PL Pub Date : 2020-10-28
Nick Brown

The Epiphany is a many-core, low power, low on-chip memory architecture and one can very cheaply gain access to a number of parallel cores which is beneficial for HPC education and prototyping. The very low power nature of these architectures also means that there is potential for their use in future HPC machines, however there is a high barrier to entry in programming them due to the associated complexities

更新日期：2020-10-30
• arXiv.cs.PL Pub Date : 2020-10-27
Kevin Batz; Benjamin Lucien Kaminski; Joost-Pieter Katoen; Christoph Matheja

We study a syntax for specifying quantitative "assertions" - functions mapping program states to numbers - for probabilistic program verification. We prove that our syntax is expressive in the following sense: Given any probabilistic program $C$, if a function $f$ is expressible in our syntax, then the function mapping each initial state $\sigma$ to the expected value of $f$ evaluated in the final

更新日期：2020-10-30
• arXiv.cs.PL Pub Date : 2020-10-27
Nick Brown; Ludovic Capelli; J. Mark Bull

Writing parallel codes is difficult and exhibits a fundamental trade-off between abstraction and performance. The high level language abstractions designed to simplify the complexities of parallelism make certain assumptions that impacts performance and scalability. On the other hand lower level languages, providing many opportunities for optimisation, require in-depth knowledge and the programmer

更新日期：2020-10-30
• arXiv.cs.PL Pub Date : 2020-10-27
Felipe Bañados Schwerter; Alison M. Clark; Khurram A. Jafery; Ronald Garcia

Abstracting Gradual Typing (AGT) is a systematic approach to designing gradually-typed languages. Languages developed using AGT automatically satisfy the formal semantic criteria for gradual languages identified by Siek et al. [2015]. Nonetheless, vanilla AGT semantics can still have important shortcomings. First, a gradual language's runtime checks should preserve the space-efficiency guarantees inherent

更新日期：2020-10-30
• arXiv.cs.PL Pub Date : 2020-10-27
Robert SisonUniversity of MelbourneCSIRO's Data61UNSW Sydney; Toby MurrayUniversity of Melbourne

Proving only over source code that programs do not leak sensitive data leaves a gap between reasoning and reality that can only be filled by accounting for the behaviour of the compiler. Furthermore, software does not always have the luxury of limiting itself to single-threaded computation with resources statically dedicated to each user to ensure the confidentiality of their data. This results in

更新日期：2020-10-30
• arXiv.cs.PL Pub Date : 2020-10-26
Zesen Qian; G. A. Kavvos; Lars Birkedal

We introduce coexponentials, a new set of modalities for Classical Linear Logic. As duals to exponentials, the coexponentials codify a distributed form of the structural rules of weakening and contraction. This makes them a suitable logical device for encapsulating the pattern of a server receiving requests from an arbitrary number of clients on a single channel. Guided by this intuition we formulate

更新日期：2020-10-30
• arXiv.cs.PL Pub Date : 2020-10-26
Artem Khyzha; Ori Lahav

We study the formal semantics of non-volatile memory in the x86-TSO architecture. We show that while the explicit persist operations in the recent model of Raad et al. from POPL'20 only enforce order between writes to the non-volatile memory, it is equivalent, in terms of reachable states, to a model whose explicit persist operations mandate that prior writes are actually written to the non-volatile

更新日期：2020-10-30
• arXiv.cs.PL Pub Date : 2020-10-25
Andrew K. Hirsch; Ethan Cecchetti

Type systems designed for information-flow control commonly use a program-counter label to track the sensitivity of the context and rule out data leakage arising from effectful computation in a sensitive context. Currently, type-system designers reason about this label informally except in security proofs, where they use ad-hoc techniques. We develop a framework based on monadic semantics for effects

更新日期：2020-10-30
• arXiv.cs.PL Pub Date : 2020-10-24
Beniamino Accattoli; Ugo Dal Lago; Gabriele Vanoni

Evaluating higher-order functional programs through abstract machines inspired by the geometry of the interaction is known to induce $\textit{space}$ efficiencies, the price being $\textit{time}$ performances often poorer than those obtainable with traditional, environment-based, abstract machines. Although families of lambda-terms for which the former is exponentially less efficient than the latter

更新日期：2020-10-30
• arXiv.cs.PL Pub Date : 2020-10-23
Leif Andersen; Michael Ballantyne; Matthias Felleisen

Many programming problems call for turning geometrical thoughts into code: tables, hierarchical structures, nests of objects, trees, forests, graphs, and so on. Linear text does not do justice to such thoughts. But, it has been the dominant programming medium for the past and will remain so for the foreseeable future. This paper proposes a novel mechanism for conveniently extending textual programming

更新日期：2020-10-30
• arXiv.cs.PL Pub Date : 2020-10-23
František Farka; Aleksandar Nanevski; Anindya Banerjee; Germán Andrés Delbianco; Ignacio Fábregas

Concurrent separation logic is distinguished by transfer of state ownership upon parallel composition and framing. The algebraic structure that underpins ownership transfer is that of partial commutative monoids (PCMs). Extant research considers ownership transfer primarily from the logical perspective while comparatively less attention is drawn to the algebraic considerations. This paper provides

更新日期：2020-10-30
• arXiv.cs.PL Pub Date : 2020-10-23
Nariyoshi Chida; Tachio Terauchi

A regular expression is called vulnerable if there exist input strings on which the usual backtracking-based matching algorithm runs super linear time. Software containing vulnerable regular expressions are prone to algorithmic-complexity denial of service attack in which the malicious user provides input strings exhibiting the bad behavior. Due to the prevalence of regular expressions in modern software

更新日期：2020-10-26
• arXiv.cs.PL Pub Date : 2020-10-23
Christian Uldal Graulund; Dmitrij Szamozvancev; Neel Krishnaswami

Most interaction with a computer is done via a graphical user interface. Traditionally, these are implemented in an imperative fashion using shared mutable state and callbacks. This is efficient, but is also difficult to reason about and error prone. Functional Reactive Programming (FRP) provides an elegant alternative which allows GUIs to be designed in a declarative fashion. However, most FRP languages

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

down
wechat
bug