• arXiv.cs.PL Pub Date : 2020-09-22
Shivam Handa; Martin Rinard

We present a new framework and associated synthesis algorithms for program synthesis over noisy data, i.e., data that may contain incorrect/corrupted input-output examples. This framework is based on an extension of finite tree automata called {\em weighted finite tree automata}. We show how to apply this framework to formulate and solve a variety of program synthesis problems over noisy data. Results

更新日期：2020-09-23
• arXiv.cs.PL Pub Date : 2020-09-22
Finn TeegenKiel University

In this research summary we present our recent work on implementing functional patterns with inverse functions in the lazy functional-logic programming language Curry. Our goal is the synthesis of the inverse of any given function in Curry itself. The setting of a functional-logic language especially allows the inversion of non-injective functions. In general, inverse computation is a non-trivial problem

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

Recursively defined structures and properties about them are naturally expressed in first-order logic with least fixpoint definitions (FO+lfp), but automated reasoning for such logics has not seen much progress. Such logics, unlike pure FOL, do not even admit complete procedures, let alone decidable ones. In this paper, we undertake a foundational study of finding proofs that use induction to reason

更新日期：2020-09-23
• arXiv.cs.PL Pub Date : 2020-09-22
Pedro CabalarUniversity of Coruña, Spain; Jorge FandinnoUniversity of Potsdam, Germany; Brais MuñizCITIC, University of Coruña, Spain

We present xclingo, a tool for generating explanations from ASP programs annotated with text and labels. These annotations allow tracing the application of rules or the atoms derived by them. The input of xclingo is a markup language written as ASP comment lines, so the programs annotated in this way can still be accepted by a standard ASP solver. xclingo translates the annotations into additional

更新日期：2020-09-23
• arXiv.cs.PL Pub Date : 2020-09-22
Paul TarauUniversity of North Texas; Valeria de PaivaTopos Institute

The problem we want to solve is how to generate all theorems of a given size in the implicational fragment of propositional intuitionistic linear logic. We start by filtering for linearity the proof terms associated by our Prolog-based theorem prover for Implicational Intuitionistic Logic. This works, but using for each formula a PSPACE-complete algorithm limits it to very small formulas. We take a

更新日期：2020-09-23
• arXiv.cs.PL Pub Date : 2020-09-22
Joaquín Arias; Manuel Carro; Zhuo Chen; Gopal Gupta

Ethical and legal concerns make it necessary for programs that may directly influence the life of people (via, e.g., legal or health counseling) to justify in human-understandable terms the advice given. Answer Set Programming has a rich semantics that makes it possible to very concisely express complex knowledge. However, justifying why an answer is a consequence from an ASP program may be non-trivial

更新日期：2020-09-23
• arXiv.cs.PL Pub Date : 2020-09-19
Yutaka Nagashima

Proof by induction is a long-standing challenge in Computer Science. Induction tactics of proof assistants facilitate proof by induction, but rely on humans to manually specify how to apply induction. In this paper, we present SeLFiE, a domain-specific language to encode experienced users' expertise on how to apply the induct tactic in Isabelle/HOL: when we apply an induction heuristic written in SeLFiE

更新日期：2020-09-22
• arXiv.cs.PL Pub Date : 2020-09-18
Roger Scott; Joseph Ranieri; Lucja Kot; Vineeth Kashyap

Programmers often add meaningful information about program semantics when naming program entities such as variables, functions, and macros. However, static analysis tools typically discount this information when they look for bugs in a program. In this work, we describe the design and implementation of a static analysis checker called SwapD, which uses the natural language information in programs to

更新日期：2020-09-22
• arXiv.cs.PL Pub Date : 2020-09-05
Nghi D. Q. Bui; Yijun Yu; Lingxiao Jiang

Recently program learning techniques have been proposed to process source code based on syntactical structures (e.g., Abstract Syntax Trees) and/or semantic information (e.g., Dependency Graphs). Although graphs may be better at capturing various viewpoints of code semantics than trees, constructing graph inputs from code needs static code semantic analysis that may not be accurate and introduces noise

更新日期：2020-09-22
• arXiv.cs.PL Pub Date : 2020-09-19
Francesco RiccaUniversity of Calabria; Alessandra RussoImperial College London; Sergio GrecoUniversity of Calabria; Nicola LeoneUniversity of Calabria; Alexander ArtikisUniversity of Piraeus; Gerhard FriedrichUniversität Klagenfurt; Paul FodorStony Brook University; Angelika KimmigCardiff University; Francesca LisiUniversity of Bari Aldo Moro; Marco MarateaUniversity of Genova; Alessandra MileoINSIGHT

Since the first conference held in Marseille in 1982, ICLP has been the premier international event for presenting research in logic programming. Contributions are solicited in all areas of logic programming and related areas, including but not restricted to: - Foundations: Semantics, Formalisms, Answer-Set Programming, Non-monotonic Reasoning, Knowledge Representation. - Declarative Programming: Inference

更新日期：2020-09-22
• arXiv.cs.PL Pub Date : 2020-09-18
Edward McDaid; Sarah McDaid

We present Zoea Visual which is a visual programming language based on the Zoea composable inductive programming language. Zoea Visual allows users to create software directly from a specification that resembles a set of functional test cases. Programming with Zoea Visual involves the definition of a data flow model of test case inputs, optional intermediate values, and outputs. Data elements are represented

更新日期：2020-09-21
• arXiv.cs.PL Pub Date : 2020-09-17
Aaron BembenekHarvard University; Michael GreenbergPomona College; Stephen ChongHarvard University

Satisfiability modulo theories (SMT) solving has become a critical part of many static analyses, including symbolic execution, refinement type checking, and model checking. We propose Formulog, a domain-specific language that makes it possible to write a range of SMT-based static analyses in a way that is both close to their formal specifications and amenable to high-level optimizations and efficient

更新日期：2020-09-20
• arXiv.cs.PL Pub Date : 2020-09-17
Zorica SavanovićIMT School for Advanced Studies Lucca; Letterio GallettaIMT School for Advanced Studies Lucca; Hugo Torres VieiraC4 - University of Beira Interior

Component-based development is challenging in a distributed setting, for starters considering programming a task may involve the assembly of loosely-coupled remote components. In order for the task to be fulfilled, the supporting interaction among components should follow a well-defined protocol. In this paper we address a model for message passing component-based systems where components are assembled

更新日期：2020-09-20
• arXiv.cs.PL Pub Date : 2020-09-16
Julien LangeRoyal Holloway, University of London; Anastasia MavridouKBR/NASA Ames Research Center; Larisa SafinaINRIA; Alceste ScalasDTU Compute, Technical University of Denmark

This volume contains the proceedings of ICE'20, the 13th Interaction and Concurrency Experience, which was held online on the 19th of June 2020, as a satellite event of DisCoTec'20. The ICE workshop series features a distinguishing review and selection procedure, allowing PC members to interact anonymously with authors. As in the past 12 editions, this interaction considerably improved the accuracy

更新日期：2020-09-18
• arXiv.cs.PL Pub Date : 2020-09-16
Juan Cruz-BenitoIBM Quantum; Sanjay VishwakarmaElectrical and Computer Engineering. Carnegie Mellon University; Francisco Martin-FernandezIBM Quantum; Ismael FaroIBM Quantum

In recent years, the use of deep learning in language models, text auto-completion, and text generation has made tremendous progress and gained much attention from the research community. Some products and research projects claim that they can generate text that can be interpreted as human-writing, enabling new possibilities in many application areas. Among the different areas related to language processing

更新日期：2020-09-18
• arXiv.cs.PL Pub Date : 2020-09-16
Rafael Ravedutti L. MachadoChair for System Simulation at University of Erlangen-Nürnberg; Jonas SchmittChair for System Simulation at University of Erlangen-Nürnberg; Sebastian EiblChair for System Simulation at University of Erlangen-Nürnberg; Jan EitzingerRegional Computer Center Erlangen at University of Erlangen-Nürnberg; Roland LeißaSaarland Informatics Campus at Saarland University; Sebastian

This paper investigates the suitability of the AnyDSL partial evaluation framework to implement tinyMD: an efficient, scalable, and portable simulation of pairwise interactions among particles. We compare tinyMD with the miniMD proxy application that scales very well on parallel supercomputers. We discuss the differences between both implementations and contrast miniMD's performance for single-node

更新日期：2020-09-18
• arXiv.cs.PL Pub Date : 2020-08-29
Md Rafiqul Islam Rabin; Arjun Mukherjee; Omprakash Gnawali; Mohammad Amin Alipour

Source code representations are key in applying machine learning techniques for processing and analyzing programs. A popular approach in representing source code is neural source code embedding that represents programs with high-dimensional vectors computed by training deep neural networks on a large volume of programs. Although successful, there is little known about the contents of these vectors

更新日期：2020-09-18
• arXiv.cs.PL Pub Date : 2020-09-15
Małgorzata BiernackaInstitute of Computer Science, University of Wrocław, Poland; Dariusz BiernackiInstitute of Computer Science, University of Wrocław, Poland; Witold CharatonikInstitute of Computer Science, University of Wrocław, Poland; Tomasz DrabInstitute of Computer Science, University of Wrocław, Poland

We present an abstract machine that implements a full-reducing (a.k.a. strong) call-by-value strategy for pure $\lambda$-calculus. It is derived using Danvy et al.'s functional correspondence from Cr\'egut's KN by: (1) deconstructing KN to a call-by-name normalization-by-evaluation function akin to Filinski and Rohde's, (2) modifying the resulting normalizer so that it implements the right-to-left

更新日期：2020-09-16
• arXiv.cs.PL Pub Date : 2020-09-15
David Rushing Dewhurst

A structural time series model additively decomposes into generative, semantically-meaningful components, each of which depends on a vector of parameters. We demonstrate that considering each generative component together with its vector of parameters as a single latent structural time series node can simplify reasoning about collections of structural time series components. We then introduce a formal

更新日期：2020-09-16
• arXiv.cs.PL Pub Date : 2020-09-14
Drew Zagieboylo; G. Edward Suh; Andrew C. Myers

Virtual memory has been a standard hardware feature for more than three decades. At the price of increased hardware complexity, it has simplified software and promised strong isolation among colocated processes. In modern computing systems, however, the costs of virtual memory have increased significantly. With large memory workloads, virtualized environments, data center computing, and chips with

更新日期：2020-09-16
• arXiv.cs.PL Pub Date : 2020-09-14
Fangyi ZhouImperial College London; Francisco FerreiraImperial College London; Raymond HuUniversity of Hertfordshire; Rumyana NeykovaBrunel University London; Nobuko YoshidaImperial College London

With distributed computing becoming ubiquitous in the modern era, safe distributed programming is an open challenge. To address this, multiparty session types (MPST) provide a typing discipline for message-passing concurrency, guaranteeing communication safety properties such as deadlock freedom. While originally MPST focus on the communication aspects, and employ a simple typing system for communication

更新日期：2020-09-15
• arXiv.cs.PL Pub Date : 2020-09-13
Yepeng Ding; Hiroyuki Sato

It is extremely challenging to develop verifiable systems that are regulated by formal specifications and checked by formal verification techniques in practice. Although formal verification has made significant progress over the past decades, the issue caused by the gulf between the system implementation and formal verification still has a huge cost. To fundamentally solve the issue, we propose transition-oriented

更新日期：2020-09-15
• arXiv.cs.PL Pub Date : 2020-09-13
Fangke Ye; Jisheng Zhao; Vivek Sarkar

Dynamically typed languages such as JavaScript and Python have emerged as the most popular programming languages in use. Important benefits can accrue from including type annotations in dynamically typed programs. This approach to gradual typing is exemplified by the TypeScript programming system which allows programmers to specify partially typed programs, and then uses static analysis to infer the

更新日期：2020-09-15
• arXiv.cs.PL Pub Date : 2020-09-12
Sung Kook Kim; Arnaud J. Venet; Aditya V. Thakur

Practical adoption of static analysis often requires trading precision for performance. This paper focuses on improving the memory efficiency of abstract interpretation without sacrificing precision or time efficiency. Computationally, abstract interpretation reduces the problem of inferring program invariants to computing a fixpoint of a set of equations. This paper presents a method to minimize the

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

An analogy is an identification of structural similarities and correspondences between two objects. Computational models of analogy making have been studied extensively in the field of cognitive science to better understand high-level human cognition. For instance, Melanie Mitchell and Douglas Hofstadter sought to better understand high-level perception by developing the Copycat algorithm for completing

更新日期：2020-09-15
• arXiv.cs.PL Pub Date : 2020-09-13
Felicien Ihirwe; Silvia Mazzini; Pierluigi Pierini; Alberto Debiasi; Stefano Tonetta

One of the issues in dependable complex systems execution process is the presence of a high dimension of decisions to be taken into account when deciding the next action to be taken. While in designing the logical architecture of a system, various dependability aspects such as safety, reliability, and security must be considered. Moreover, in case of high-assurance systems, it is required to analyze

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

Deep Neural Networks (DNNs) are rapidly being applied to safety-critical domains such as drone and airplane control, motivating techniques for verifying the safety of their behavior. Unfortunately, DNN verification is NP-hard, with current algorithms slowing exponentially with the number of nodes in the DNN. This paper introduces the notion of Abstract Neural Networks (ANNs), which can be used to soundly

更新日期：2020-09-15
• arXiv.cs.PL Pub Date : 2020-09-11
Alan Cha; Erik Wittern; Guillaume Baudart; James C. Davis; Louis Mandel; Jim A. Laredo

The landscape of web APIs is evolving to meet new client requirements and to facilitate how providers fulfill them. A recent web API model is GraphQL, which is both a query language and a runtime. Using GraphQL, client queries express the data they want to retrieve or mutate, and servers respond with exactly those data or changes. GraphQL's expressiveness is risky for service providers because clients

更新日期：2020-09-15
• arXiv.cs.PL Pub Date : 2020-09-11
Carlo Angiuli; Evan Cavallo; Anders Mörtberg; Max Zeuner

In their usual form, representation independence metatheorems provide an external guarantee that two implementations of an abstract interface are interchangeable when they are related by an operation-preserving correspondence. If our programming language is dependently-typed, however, we would like to appeal to such invariance results within the language itself, in order to obtain correctness theorems

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

Repeated recursion unfolding is a new approach that repeatedly unfolds a recursion with itself and simplifies it while keeping all unfolded rules. Each unfolding doubles the number of recursive steps covered. This reduces the number of recursive rule applications to its logarithm at the expense of introducing a logarithmic number of unfolded rules to the program. Efficiency crucially depends on the

更新日期：2020-09-14
• arXiv.cs.PL Pub Date : 2020-09-10
Piyush Gupta; Nikita Mehrotra; Rahul Purandare

Static program analysis tools are often required to work with only a small part of a program's source code, either due to the unavailability of the entire program or the lack of need to analyze the complete code. This makes it challenging to use static analysis tools that require a complete and typed intermediate representation (IR). We present JCoffee, a tool that leverages compiler feedback to convert

更新日期：2020-09-14
• arXiv.cs.PL Pub Date : 2020-09-10
Alexander Vandenbroucke; Tom Schrijvers

Delimited control is a powerful mechanism for programming language extension which has been recently proposed for Prolog (and implemented in SWI-Prolog). By manipulating the control flow of a program from inside the language, it enables the implementation of powerful features, such as tabling, without modifying the internals of the Prolog engine. However, its current formulation is inadequate: it does

更新日期：2020-09-11
• arXiv.cs.PL Pub Date : 2020-09-10
Eytan Singher; Shachar Itzhaky

Recent years have seen tremendous growth in the amount of verified software. Proofs for complex properties can now be achieved using higher-order theories and calculi. Complex properties lead to an ever-growing number of definitions and associated lemmas, which constitute an integral part of proof construction. Following this -- whether automatic or semi-automatic -- methods for computer-aided lemma

更新日期：2020-09-11
• arXiv.cs.PL Pub Date : 2020-09-09
Joseph Gil; Ori Roth

We present a correspondence and bisimulation between variants of parametrically polymorphic type systems and variants of finite control automata, such as FSA, PDA, tree automata and Turing machine. Within this correspondence we show that two recent celebrated results on automatic generation of fluent API are optimal in certain senses, present new results on the studied type systems, formulate open

更新日期：2020-09-10
• arXiv.cs.PL Pub Date : 2020-09-08
Soham Chakraborty

Mapping programs from one architecture to another plays a key role in technologies such as binary translation, decompilation, emulation, virtualization, and application migration. Although multicore architectures are ubiquitous, the state-of-the-art translation tools do not handle concurrency primitives correctly. Doing so is rather challenging because of the subtle differences in the concurrency models

更新日期：2020-09-10
• arXiv.cs.PL Pub Date : 2020-09-06
Suvam Mukherjee; Oded Padon; Sharon Shoham; Deepak D'Souza; Noam Rinetzky

Data race free (DRF) programs constitute an important class of concurrent programs. In this paper we provide a framework for designing and proving the correctness of data flow analyses that target this class of programs. These analyses are in the same spirit as the "sync-CFG" analysis proposed in earlier literature. To achieve this, we first propose a novel concrete semantics for DRF programs, called

更新日期：2020-09-08
• arXiv.cs.PL Pub Date : 2020-09-06
Nghi D. Q. Bui

Recent learning techniques for the representation of code depend mostly on human-annotated (labeled) data. In this work, we are proposing Corder, a self-supervised learning system that can learn to represent code without having to label data. The key innovation is that we train the source code model by asking it to recognize similar and dissimilar code snippets through a contrastive learning paradigm

更新日期：2020-09-08
• arXiv.cs.PL Pub Date : 2020-09-03
Felicien Ihirwe; Davide Di Ruscio; Silvia Mazzini; Pierluigi Pierini; Alfonso Pierantonio

Developing Internet of Things (IoT) systems has to cope with several challenges mainly because of the heterogeneity of the involved sub-systems and components. With the aim of conceiving languages and tools supporting the development of IoT systems, this paper presents the results of the study, which has been conducted to understand the current state of the art of existing platforms, and in particular

更新日期：2020-09-08
• arXiv.cs.PL Pub Date : 2020-09-03
Yuyan Bao; Kirshanthan Sundararajah; Raghav Malik; Qianchuan Ye; Christopher Wagner; Fei Wang; Mohammad Hassan Ameri; Donghang Lu; Alexander Seto; Benjamin Delaware; Roopsha Samanta; Aniket Kate; Christina Garman; Jeremiah Blocki; Pierre-David Letourneau; Benoit Meister; Jonathan Springer; Tiark Rompf; Milind Kulkarni

Cryptographic techniques have the potential to enable distrusting parties to collaborate in fundamentally new ways, but their practical implementation poses numerous challenges. An important class of such cryptographic techniques is known as secure multi-party computation (MPC). In an effort to provide an ecosystem for building secure MPC applications using higher degrees of automation, we present

更新日期：2020-09-05
• arXiv.cs.PL Pub Date : 2020-09-02
Dennis Renz; Sibylle Schwarz; Johannes Waldmann

Cyp (Check Your Proofs) (Durner and Noschinski 2013; Traytel 2019) verifies proofs about Haskell-like programs. We extended Cyp with a pattern matcher for programs and proof terms, and a type checker. This allows to use Cyp for auto-grading exercises where the goal is to complete programs and proofs that are partially given by the instructor, as terms with holes. Since this allows holes in programs

更新日期：2020-09-05
• arXiv.cs.PL Pub Date : 2020-09-02
The Quingo Development Team

Noisy Intermediate-Scale Quantum (NISQ) technology proposes requirements that cannot be fully satisfied by existing Quantum Programming Languages (QPLs) or frameworks. First, noisy qubits require repeatedly-performed quantum experiments, which explicitly operate some low-level configuration, such as pulses and timing of operations. This requirement is beyond the scope or capability of most existing

更新日期：2020-09-05
• arXiv.cs.PL Pub Date : 2020-09-03
Jianping Kelvin Li; Kwan-Liu Ma

We present P6, a declarative language for building high performance visual analytics systems through its support for specifying and integrating machine learning and interactive visualization methods. As data analysis methods based on machine learning and artificial intelligence continue to advance, a visual analytics solution can leverage these methods for better exploiting large and complex data.

更新日期：2020-09-05
• arXiv.cs.PL Pub Date : 2020-09-02
Nick Baumann; Samuel Steffen; Benjamin Bichsel; Petar Tsankov; Martin Vechev

Recent work introduces zkay, a system for specifying and enforcing data privacy in smart contracts. While the original prototype implementation of zkay (v0.1) demonstrates the feasibility of the approach, its proof-of-concept implementation suffers from severe limitations such as insecure encryption and lack of important language features. In this report, we present zkay v0.2, which addresses its predecessor's

更新日期：2020-09-03
• arXiv.cs.PL Pub Date : 2020-09-02
Michael Hanus; Claudio Sacerdoti Coen

This volume constitutes the pre-proceedings of the 28th International Workshop on Functional and Logic Programming (WFLP 2020), organized by the University of Bologna, Italy, as part of Bologna Federated Conference on Programming Languages 2020. The international Workshop on Functional and (constraint) Logic Programming (WFLP) aims at bringing together researchers, students, and practitioners interested

更新日期：2020-09-03
• arXiv.cs.PL Pub Date : 2020-09-02
J. López-González; Juan M. Serrano

Monadic comprehensions reign over the realm of language-integrated query (LINQ), and for good reasons. Indeed, comprehensions are tightly integrated with general purpose programming languages and close enough to common query languages, such as SQL, to guarantee their translation into effective queries. Comprehensions also support features for writing reusable and composable queries, such as the handling

更新日期：2020-09-03
• arXiv.cs.PL Pub Date : 2020-09-01
Hongbo Rong

Overlays are virtual, re-configurable architectures that overlay on top of physical FPGA fabrics. An overlay that is specialized for an application, or a class of applications, offers both fast reconfiguration and minimized performance penalty. Such an overlay is usually implemented by hardware designers in hardware "assembly" languages at register-transfer level (RTL). This short article proposes

更新日期：2020-09-03
• arXiv.cs.PL Pub Date : 2020-09-01
Catherine Dubois

It is well known in the Constraint Programming community that any non-binary constraint satisfaction problem (with finite domains) can be transformed into an equivalent binary one. One of the most well-known translations is the Hidden Variable Encoding. In this paper we formalize this encoding in the proof assistant Coq and prove that any solution of the binary constraint satisfaction problem makes

更新日期：2020-09-02
• arXiv.cs.PL Pub Date : 2020-08-31
Davide AnconaDIBRIS, University of Genova, Italy; Angelo FerrandoUniversity of Manchester, UK; Viviana MascardiDIBRIS, University of Genova, Italy

Runtime verification (RV) consists in dynamically verifying that the event traces generated by single runs of a system under scrutiny (SUS) are compliant with the formal specification of its expected properties. RML (Runtime Monitoring Language) is a simple but expressive Domain Specific Language for RV; its semantics is based on a trace calculus formalized by a deterministic rewriting system which

更新日期：2020-09-02
• arXiv.cs.PL Pub Date : 2020-08-31
Jan C. Dageförde; Herbert Kuchen

Constraint-logic object-oriented programming provides a useful symbiosis between object-oriented programming and constraint-logic search. The ability to use logic variables, constraints, non-deterministic search, and object-oriented programming in an integrated way facilitates the combination of search-related program parts and other business logic in object-oriented applications. With this work we

更新日期：2020-09-01
• arXiv.cs.PL Pub Date : 2020-08-31
Manfred Schmidt-SchaußGoethe-University, Frankfurt, Germany; David SabelLMU, Munich, Germany

Comparison of concurrent programming languages and correctness of program transformations in concurrency are the focus of this research. As criterion we use contextual semantics adapted to concurrency, where may -- as well as should -- convergence are observed. We investigate the relation between the synchronous pi-calculus and a core language of Concurrent Haskell (CH). The contextual semantics is

更新日期：2020-09-01
• arXiv.cs.PL Pub Date : 2020-08-31
Ryan KavanaghCarnegie Mellon University

Session-types specify communication protocols for communicating processes, and session-typed languages are often specified using substructural operational semantics given by multiset rewriting systems. We give an observed communication semantics for a session-typed language with recursion, where a process's observation is given by its external communications. To do so, we introduce fair executions

更新日期：2020-09-01
• arXiv.cs.PL Pub Date : 2020-08-30
Vanderson Martins do Rosario; Raphael Zinsly; Sandro Rigo; Edson Borin

Dynamic Translation (DT) is a sophisticated technique that allows the implementation of high-performance emulators and high-level-language virtual machines. In this technique, the guest code is compiled dynamically at runtime. Consequently, achieving good performance depends on several design decisions, including the shape of the regions of code being translated. Researchers and engineers explore these

更新日期：2020-09-01
• arXiv.cs.PL Pub Date : 2020-08-29
Linda Brodo; Roberto Bruni; Moreno Falaschi

Reaction Systems (RSs) are a successful computational framework inspired by biological systems. A RS pairs a set of entities with a set of reactions over them. Entities can be used to enable or inhibit each reaction, and are produced by reactions. Entities can also be provided by an external context. RS semantics is defined in terms of an (unlabelled) rewrite system: given the current set of entities

更新日期：2020-09-01
• arXiv.cs.PL Pub Date : 2020-08-28
Baltasar Trancón y Widemann; Markus Lepper

Implementing a complex concept as an executable model in a strongly typed, purely functional language hits a sweet spot between mere simulation and formal specification. For research and education it is often desirable to enrich the algorithmic code with meta-logical annotations, variously embodied as assertions, theorems or test cases. Checking frameworks use the inherent logical power of the functional

更新日期：2020-08-31
• arXiv.cs.PL Pub Date : 2020-08-28
N. Webster; M. Servetto

We formally define an elegant multi-paradigm unification of Functional Reactive Programming, Actor Systems, and Object-Oriented Programming. This enables an intuitive form of declarative programming, harvesting the power of concurrency while maintaining safety. We use object and reference capabilities to highlight and tame imperative features: reference capabilities track aliasing and mutability, and

更新日期：2020-08-31
• arXiv.cs.PL Pub Date : 2020-08-28
Philipp Körner; David Schneider; Michael Leuschel

The semantics and the recursive execution model of Prolog make it very natural to express language interpreters in form of AST (Abstract Syntax Tree) interpreters where the execution follows the tree representation of a program. An alternative implementation technique is that of bytecode interpreters. These interpreters transform the program into a compact and linear representation before evaluating

更新日期：2020-08-31
• arXiv.cs.PL Pub Date : 2020-08-27
Ornela DardhaUniversity of Glasgow; Jurriaan RotRadboud University

This volume contains the proceedings of EXPRESS/SOS 2020: the Combined 27th International Workshop on Expressiveness in Concurrency and the 17th Workshop on Structural Operational Semantics, which was held online, as an affiliated workshop of CONCUR 2020, the 31st International Conference on Concurrency Theory. The EXPRESS/SOS workshop series aims at bringing together researchers interested in the

更新日期：2020-08-31
• arXiv.cs.PL Pub Date : 2020-08-21
Marco T. MorazánSeton Hall University

Beginning students find the syntactic construct known as a while loop difficult to master. The difficulties revolve around guaranteeing loop termination and around learning how to properly sequence mutations to solve a problem. In fact, both of these are intertwined and students need to be taught a model that helps them reason about how to design while loops. For students that have been introduced

更新日期：2020-08-31
• arXiv.cs.PL Pub Date : 2020-08-27
Michael Hanus; Finn Teegen

Pull-tabbing is an evaluation technique for functional logic programs which computes all non-deterministic results in a single graph structure. Pull-tab steps are local graph transformations to move non-deterministic choices towards the root of an expression. Pull-tabbing is independent of a search strategy so that different strategies (depth-first, breadth-first, parallel) can be used to extract the

更新日期：2020-08-28
• arXiv.cs.PL Pub Date : 2020-08-25
Gilbert Bernstein; Michael Mara; Tzu-Mao Li; Dougal Maclaurin; Jonathan Ragan-Kelley

How does one compile derivatives of tensor programs, such that the resulting code is purely functional (hence easier to optimize and parallelize) and provably efficient relative to the original program? We show that naively differentiating tensor code---as done in popular systems like Tensorflow and PyTorch---can cause asymptotic slowdowns in pathological cases, violating the Cheap Gradients Principle

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

down
wechat
bug