当前期刊: arXiv - CS - Programming Languages Go to current issue    加入关注   
显示样式:        排序: IF: - GO 导出
我的关注
我的收藏
您暂时未登录!
登录
  • Inductive Program Synthesis Over Noisy Data
    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
  • Research Summary on Implementing Functional Patterns by Synthesizing Inverse Functions
    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
  • Synthesizing Lemmas for Inductive Reasoning
    arXiv.cs.PL Pub Date : 2020-09-21
    Adithya Murali; Lucas Peña; Christof Löding; P. Madhusudan

    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
  • A System for Explainable Answer Set Programming
    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
  • Deriving Theorems in Implicational Linear Logic, Declaratively
    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
  • Justifications for Goal-Directed Constraint Answer Set Programming
    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
  • Faster Smarter Induction in Isabelle/HOL with SeLFiE
    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
  • Out of Sight, Out of Place: Detecting and Assessing Swapped Arguments
    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
  • TreeCaps: Tree-Based Capsule Networks for Source Code Processing
    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
  • Proceedings 36th International Conference on Logic Programming (Technical Communications)
    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
  • A Visual Language for Composable Inductive Programming
    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
  • Formulog: Datalog for SMT-Based Static Analysis (Extended Version)
    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
  • A type language for message passing component-based systems
    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
  • Proceedings 13th Interaction and Concurrency Experience
    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
  • Automated Source Code Generation and Auto-completion Using Deep Learning: Comparing and Discussing Current Language-Model-Related Approaches
    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
  • tinyMD: A Portable and Scalable Implementation for Pairwise Interactions Simulations
    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
  • Towards Demystifying Dimensions of Source Code Embeddings
    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
  • An Abstract Machine for Strong Call by Value
    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
  • Structural time series grammar over variable blocks
    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
  • The Cost of Software-Based Memory Management Without Virtual Memory
    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
  • Statically Verified Refinements for Multiparty Protocols
    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
  • Transition-Oriented Programming: Developing Verifiable Systems
    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
  • Advanced Graph-Based Deep Learning for Probabilistic Type Inference
    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
  • Memory-Efficient Fixpoint Computation
    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
  • Analogy-Making as a Core Primitive in the Software Engineering Toolbox
    arXiv.cs.PL Pub Date : 2020-09-14
    Matthew Sotoudeh; Aditya V. Thakur

    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
  • Model-based analysis support for dependable complex systems in CHESS
    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
  • Abstract Neural Networks
    arXiv.cs.PL Pub Date : 2020-09-11
    Matthew Sotoudeh; Aditya V. Thakur

    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
  • A Principled Approach to GraphQL Query Cost Analysis
    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
  • Internalizing Representation Independence with Univalence
    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
  • Repeated Recursion Unfolding for Super-Linear Speedup within Bounds
    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
  • JCoffee: Using Compiler Feedback to Make Partial Code Snippets Compilable
    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
  • Disjunctive Delimited Control
    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
  • Theory Exploration Powered By Deductive Synthesis
    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
  • Ties between Parametrically Polymorphic Type Systems and Finite Control Automata
    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
  • On Architecture to Architecture Mapping for Concurrency
    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
  • A Thread-Local Semantics and Efficient Static Analyses for Race Free Programs
    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
  • Efficient Framework for Learning Code Representations through Semantic-Preserving Program Transformations
    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
  • Low-code Engineering for Internet of things: A state of research
    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
  • HACCLE: An Ecosystem for Building Secure Multi-Party Computations
    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
  • Check Your (Students') Proofs-With Holes
    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
  • Quingo: A Programming Framework for Heterogeneous Quantum-Classical Computing with NISQ Features
    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
  • P6: A Declarative Language for Integrating Machine Learning in Visual Analytics
    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
  • zkay v0.2: Practical Data Privacy for Smart Contracts
    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
  • Pre-Proceedings of the 28th International Workshop on Functional and Logic Programming (WFLP 2020)
    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
  • The Optics of Language-Integrated Query
    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
  • Building Application-Specific Overlays on FPGAs with High-Level Customizable IPs
    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
  • Formally Verified Transformation of Non-binary Constraints into Binary Constraints
    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
  • Can determinism and compositionality coexist in RML?
    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
  • Constraint-Logic Object-Oriented Programming with Free Arrays
    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
  • Correctly Implementing Synchronous Message Passing in the Pi-Calculus By Concurrent Haskell's MVars
    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
  • Substructural Observed Communication Semantics
    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
  • Employing Simulation to Facilitate the Design of Dynamic Code Generators
    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
  • SOS Rules for Equivalences of Reaction Systems
    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
  • Practical Idiomatic Considerations for Checkable Meta-Logic in Experimental Functional Programming
    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
  • Smoothly Navigating between Functional Reactive Programming and Actors
    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
  • On the Performance of Bytecode Interpreters in Prolog
    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
  • Proceedings Combined 27th International Workshop on Expressiveness in Concurrency and 17th Workshop on Structural Operational Semantics
    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
  • How to Design While Loops
    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
  • Memoized Pull-Tabbing for Functional Logic Programming
    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
  • Differentiating a Tensor Language
    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.
导出
全部期刊列表>>
物理学研究前沿热点精选期刊推荐
chemistry
《自然》编辑与您分享如何成为优质审稿人-信息流
欢迎报名注册2020量子在线大会
化学领域亟待解决的问题
材料学研究精选新
GIANT
自然职场线上招聘会
ACS ES&T Engineering
ACS ES&T Water
ACS Publications填问卷
屿渡论文,编辑服务
阿拉丁试剂right
南昌大学
王辉
南方科技大学
刘天飞
隐藏1h前已浏览文章
课题组网站
新版X-MOL期刊搜索和高级搜索功能介绍
ACS材料视界
天合科研
x-mol收录
X-MOL
苏州大学
廖矿标
深圳湾
试剂库存
down
wechat
bug