yusuke1997/dblp-id-title huggingface dataset:
Programming Languages and Systems - 32nd European Symposium on Programming, ESOP 2023, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2023, Paris, France, April 22-27, 2023, Proceedings
Using the Centaur System to for Data-Parallel SIMD Programming: A Case Study
Inference of User-Defined Type Qualifiers and Qualifier Rules
A Modular Soundness Theory for the Blackboard Analysis Architecture
On the Relationship Between Concurrent Separation Logic and Assume-Guarantee Reasoning
Constructor Subtyping
Modular Relaxed Dependencies in Weak Memory Concurrency
Automatic Termination Verification for Higher-Order Functional Programs
The Duality of Construction
Parametric Polymorphism through Run-Time Sealing or, Theorems for Low, Low Prices!
Analysis of Asynchronous Programs with Event-Based Synchronization
Verifiable and Executable Logic Specifications of Concurrent Objects in L pi
Compositional Refinements in Multiple Blackboard Systems
System E: Expansion Variables for Flexible Typing with Linear and Non-linear Types and Intersection Types
A Theory of Second-Order Trees
On the Relationship between Dijkstra Monads and Higher-Order Fixpoint Logic
Sufficient Conditions for Robustness of RDMA Programs
Structured Handling of Scoped Effects
Witnessing (Co)datatypes
Bottom-up Grammar Analysis - A Functional Formulation
A Basis for Verifying Multi-threaded Programs
Reconciling Partial and Local Invertibility
Measurements in Proof Nets as Higher-Order Quantum Circuits
Answer Type Polymorphism in Call-by-Name Continuation Passing
Continualization of Probabilistic Programs With Correction
Compiling Information-Flow Security to Minimal Trusted Computing Bases
Foundational Issues in Implementing Constraint Logic Programming Systems
Programming Languages and Systems, 9th European Symposium on Programming, ESOP 2000, Held as Part of the European Joint Conferences on the Theory and Practice of Software, ETAPS 2000, Berlin, Germany, March 25 - April 2, 2000, Proceedings
On Implementing Logic Programming Languages on a Dataflow Architecture
Quantitative Analysis of Smart Contracts
Towards an ML-Style Polymorphic Type System for C
On the Multi-Language Construction
Type Reconstruction for General Refinement Types
A Formally Verified SSA-Based Middle-End - Static Single Assignment Meets CompCert
Programming Languages and Systems, 8th European Symposium on Programming, ESOP'99, Held as Part of the European Joint Conferences on the Theory and Practice of Software, ETAPS'99, Amsterdam, The Netherlands, 22-28 March, 1999, Proceedings
Lazy Unification with Simplification
Deadlock-Free Monitors
Step-Indexed Syntactic Logical Relations for Recursive and Quantified Types
Well-Typed Programs Can't Be Blamed
Determinacy Inference for Logic Programs
Typing Local Control and State Using Flow Analysis
Paxos Consensus, Deconstructed and Abstracted
Macrofication: Refactoring by Reverse Macro Expansion
Verified Software Units
Abstraction for Crash-Resilient Objects
Eureka Definitions for Free! or Disagreement Points for Fold/Unford Transformations
Dynamic Programming via Static Incrementalization
ESOP '92, 4th European Symposium on Programming, Rennes, France, February 26-28, 1992, Proceedings
Narrowing-Driven Partial Evaluation of Functional Logic Programs
Higher-Order Spreadsheets with Spilled Arrays
Functional Nets
Data Races and Static Analysis for Interrupt-Driven Kernels
Type Inference and Implicit Scaling
Improving the Representation of Infinite Trees to Deal with Sets of Trees
A Realizability Model for Impredicative Hoare Type Theory
Extracting total Amb programs from proofs
Binding Structures as an Abstract Data Type
Local Type Reconstruction by Means of Symbolic Fixed Point Iteration
First-Class Polymorphism for ML
Probabilistic Polynomial-Time Process Calculus and Security Protocol Analysis
Context-Sensitive Demand-Driven Control-Flow Analysis
The Audacity of Hope: Thoughts on Reclaiming the Database Dream
Sound, Modular and Compositional Verification of the Input/Output Behavior of Programs
ELIOS-OBJ Theorem Proving in a Specification Language
Hyperproperty Verification as CHC Satisfiability
Code Motion and Code Placement: Just Synonyms?
Deforestation: Transforming Programs to Eliminate Trees
Eventual Consistency for CRDTs
Adjoining Declassification and Attack Models by Abstract Interpretation
Systematic Change of Data Representation: Program Manipulations and a Case Study
Characterizing Behavioural Semantics and Abstractor Semantics
Regular Expression Subtyping for XML Query and Update Languages
Concurrent Constraint Programming Based on Functional Programming (Extended Abstract)
Generate, Test, and Aggregate - A Calculation-based Framework for Systematic Parallel Programming with MapReduce
Assumption/Commitment Rules for Dataflow Networks - With an Emphasis on Completeness
Programming the Web with High-Level Programming Languages
Resolving Non-determinism in Choreographies
Decidable Analysis of Cryptographic Protocols with Products and Modular Exponentiation
Controlling the What and Where of Declassification in Language-Based Security
Assertion Checking over Combined Abstraction of Linear Arithmetic and Uninterpreted Functions
Existential Types for Imperative Languages
Trust Management in Strand Spaces: A Rely-Guarantee Method
Faulty Logic: Reasoning about Fault Tolerant Programs
A Separation Logic for Fictional Sequential Consistency
A Basic Contract Language for Web Services
Modular Verification of Higher-Order Functional Programs
Just Forget It - The Semantics and Enforcement of Information Erasure
Logics for Extensional, Locally Complete Analysis via Domain Refinements
Verifying Temporal Heap Properties Specified via Evolution Logic
Temporary Read-Only Permissions for Separation Logic
A Classical Implementation for Prolog-II
Type-safe Quantum Programming in Idris
Complete trace models of state and control
Concurrent Kleene Algebra: Free Model and Completeness
Laziness by Need
Implementation of Modular Algebraic Specifications
On Hierarchical Communication Topologies in the \pi -calculus
A Core Calculus for a Comparative Analysis of Bio-inspired Calculi
Adversarial Reachability for Program-level Security Analysis
Fragment Abstraction for Concurrent Shape Analysis
Coinduction in Uniform: Foundations for Corecursive Proof Search with Horn Clauses
Verification of Higher-Order Computation: A Game-Semantic Approach
Semantical Analysis of Specification Logic, 3: An Operational Approach
A Verified Compiler for Probability Density Functions
Another Type System for In-Place Update
Timing UDP: Mechanized Semantics for Sockets, Threads, and Failures
Strong Preservation as Completeness in Abstract Interpretation
On Distributability in Process Calculi
Failure is Not an Option - An Exceptional Type Theory
ILC: A Foundation for Automated Reasoning About Pointer Programs
CEC: A System for the Completion of Conditional Equational Specifications
Typing References by Effect Inference
Language Constructs for Non-Well-Founded Computation
Checking System Properties via Integer Programming
An Operational Investigation of the CPS Hierarchy
Parallelization by Semantic Detection of Reductions
Mode and Termination Checking for Higher-Order Logic Programs
Transfinite Step-Indexing: Decoupling Concrete and Logical Steps
Modeling Web Interactions
A Theory of Speculative Computation
A Semantics for Propositions as Sessions
Integer Constraints to Stop Deforestation
Towards Unifying Partial Evaluation, Deforestation, Supercompilation, and GPC
Context-Dependent Effects in Guarded Interaction Trees
Fixing Incremental Computation - Derivatives of Fixpoints, and the Recursive Semantics of Datalog
An Application of Abstract Interpretation of Logic Programs: Occur Check Reduction
Why3-do: The Way of Harmonious Distributed System Proofs
Modules for an Model-Oriented Specification Language: A Proposal for MetaSoft
A Design for a Security-Typed Language with Certificate-Based Declassification
Observed Communication Semantics for Classical Processes
Context-Free Session Type Inference
Programming Languages and Systems - 29th European Symposium on Programming, ESOP 2020, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2020, Dublin, Ireland, April 25-30, 2020, Proceedings
A Semantic Framework for Designer Transactions
Gradual Tensor Shape Checking
Polyvariant Flow Analysis with Constrained Types
Probabilistic Functions and Cryptographic Oracles in Higher Order Logic
Fluid Updates: Beyond Strong vs. Weak Updates
Propagation of Roundoff Errors in Finite Precision Computations: A Semantics Approach
Generic bidirectional typing for dependent type theories
A Query Language Based on the Ambient Logic
Dimension Types
Modal Crash Types for Intermittent Computing
Automatic Alignment in Higher-Order Probabilistic Programming Languages
Efficient Matching with Memoization for Regexes with Look-around and Atomic Grouping
Programming Languages and Systems - 25th European Symposium on Programming, ESOP 2016, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2016, Eindhoven, The Netherlands, April 2-8, 2016, Proceedings
The Tensor Product in Wadler's Analysis of Lists
Synthesis of Eureka Predicates for Developing Logic Programs
A Data Driven Approach for Algebraic Loop Invariants
Type Error Diagnosis for Embedded DSLs by Two-Stage Specialized Type Rules
Automated Grading of Regular Expressions
A Functional Language for the Specification of Complex Tree Transformations
Probabilistic Programming Inference via Intensional Semantics
Expansion for Universal Quantifiers
Types for Safe Locking
New Insights into Partial Evaluation: the SCHISM Experiment
Polymorphic Binding-Time Analysis
A Syntactic Theory of Transparent Parameterization
Slicing-Based Trace Analysis of Rewriting Logic Specifications with iJulienne
Deciding Reachability in Mobile Ambients
Programming with Proofs: A Second Order Type Theory
Strong-Separation Logic
Programming Languages and Systems - 27th European Symposium on Programming, ESOP 2018, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2018, Thessaloniki, Greece, April 14-20, 2018, Proceedings
Explicit Stabilisation for Modular Rely-Guarantee Reasoning
Modular Denotational Semantics for Compiler Construction
RustHorn: CHC-Based Verification for Rust Programs
Types and Subtypes for Client-Server Interactions
Foundations of C++
Manifest Deadlock-Freedom for Shared Session Types
Subtyping First-Class Polymorphic Components
Complete Monitors for Behavioral Contracts
Type Classes in Haskell
Concurrent Library Correctness on the TSO Memory Model
Automated Termination Analysis of Polynomial Probabilistic Programs
Verified Learning Without Regret - From Algorithmic Game Theory to Distributed Systems with Mechanized Complexity Guarantees
Bunched Fuzz: Sensitivity for Vector Metrics
Spatial Interpolants
A Type Discipline for Authorization Policies
Secure Information Flow and CPS
Artifact Report: Trocq: Proof Transfer for Free, With or Without Univalence
Confluence of Graph Rewriting with Interfaces
The Weird World of Bi-directional Programming
A Semantics for Higher-Order Functors
Behavioural Equivalence via Modalities for Algebraic Effects
Full Abstraction for Linda
Separating Shape Graphs
A Universal Calculus for Stream Processing Languages
Data Space Oriented Tiling
Structure of a Proof-Producing Compiler for a Subset of Higher Order Logic
First-Person Choreographic Programming with Continuation-Passing Communications
A Logical Denotational Semantics for Constraint Logic Programming
The Vanilla Sequent Calculus is Call-by-Value
On the Secure Implementation of Security Protocols
Region-based Resource Management and Lexical Exception Handlers in Continuation-Passing Style
Verifying Concurrent Programs against Sequential Specifications
Techniques for Improving Grammar Flow Analysis
Programming Languages and Systems - 20th European Symposium on Programming, ESOP 2011, Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2011, Saarbrücken, Germany, March 26-April 3, 2011. Proceedings
Compiler Generation from Relational Semantics
A Higher-Order Abstract Syntax Approach to Verified Transformations on Functional Programs
Programming Languages and Systems, 14th European Symposium on Programming, ESOP 2005, Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2005, Edinburgh, UK, April 4-8, 2005, Proceedings
The Essence of Functional Programming on Semantic Data
Time Credits and Time Receipts in Iris
Semantics-Based Program Integration
Interprocedurally Analysing Linear Inequality Relations
Programming in JoCaml (Tool Demonstration)
Observational Equality Meets CIC
On Probabilistic Applicative Bisimulation and Call-by-Value λ-Calculi
Probabilistic Programs as Spreadsheet Queries
Probabilistic Total Store Ordering
ARMv8-A System Semantics: Instruction Fetch in Relaxed Architectures
Certificate Translation in Abstract Interpretation
Constructive characterisations of the MUST-preorder for asynchrony
Foundations for Entailment Checking in Quantitative Separation Logic
Implementation of Lazy Pattern Matching Algorithms
Reasoning about Multi-stage Programs
Polytypic Compact Printing and Parsing
Trace Spaces: An Efficient New Technique for State-Space Reduction
A Testing Theory for a Higher-Order Cryptographic Language - (Extended Abstract)
Verifying an Open Compiler Using Multi-language Semantics
Dualizing Generalized Algebraic Data Types by Matrix Transposition
Oracle Semantics for Concurrent Separation Logic
Summaries for While Programs with Recursion
A Very Intelligent Backtracking Method for Logic Programs
Linearity, Control Effects, and Behavioral Types
A Type System Equivalent to a Model Checker
Bisimulations for Untyped Imperative Objects
Bayesian strategies: probabilistic programs as generalised graphical models
Algorithmic Nominal Game Semantics
Verified Characteristic Formulae for CakeML
The Essence of Higher-Order Concurrent Separation Logic
A Systematic Approach to Static Access Control
A Classical Realizability Model for a Semantical Value Restriction
Precise Interprocedural Analysis in the Presence of Pointers to the Stack
Programming Languages and Systems - 28th European Symposium on Programming, ESOP 2019, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2019, Prague, Czech Republic, April 6-11, 2019, Proceedings
Variable Elimination as Rewriting in a Linear Lambda Calculus
The Def-inite Approach to Dependency Analysis
From Exponential to Polynomial-Time Security Typing via Principal Types
Programming Languages and Systems - 23rd European Symposium on Programming, ESOP 2014, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2014, Grenoble, France, April 5-13, 2014, Proceedings
Parametricity and Unboxing with Unpointed Types
Modal Proofs as Distributed Programs (Extended Abstract)
Type Safety of Generics for the .NET Common Language Runtime
Velisarios: Byzantine Fault-Tolerant Protocols Powered by Coq
Proving Isolation Properties for Software Transactional Memory
Interprocedural Control Flow Analysis
Thread-Modular Verification for Shared-Memory Programs
Playing with TOY: Constraints and Domain Cooperation
Relational Reasoning for Markov Chains in a Probabilistic Guarded Lambda Calculus
A Hardest Attacker for Leaking References
From Constraints to Finite Automata to Filtering Algorithms
Simulating Cities: A Software Engineering Perspective
Full Reduction in the Face of Absurdity
Practical Variable-Arity Polymorphism
Concurrent Flexible Reversibility
Formal Verification of Coalescing Graph-Coloring Register Allocation
Testing Polymorphic Properties
Precise Fixpoint Computation Through Strategy Iteration
Type-Based Automated Verification of Authenticity in Cryptographic Protocols
Semantic Foundations for Deterministic Dataflow and Stream Processing
Global Analysis of Standard Prolog Programs
How long, O Bayesian network, will I sample thee? - A program analysis perspective on expected sampling times
Robustly Safe Compilation
Actor Services - Modular Verification of Message Passing Programs
Suffix Trees in the Functional Programming Paradigm
Explicit Effect Subtyping
Programming Languages and Systems, 16th European Symposium on Programming, ESOP 2007, Held as Part of the Joint European Conferences on Theory and Practics of Software, ETAPS 2007, Braga, Portugal, March 24 - April 1, 2007, Proceedings
Sharing Continuations: Proofnets for Languages with Explicit Control
Programming Languages and Systems, 10th European Symposium on Programming, ESOP 2001 Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2001 Genova, Italy, April 2-6, 2001, Proceedings
Data Flow Analysis of Asynchronous Systems using Infinite Abstract Domains
On Parallel Snapshot Isolation and Release/Acquire Consistency
Modular Shape Analysis for Dynamically Encapsulated Programs
Synchronisation Analysis to Stop Tulping
Semantics of Concurrent Revisions
Strategies in Modular System Design by Interface Rewriting
Distributed Electronic Rights in JavaScript
A Dependently Typed Ambient Calculus
Approaches to Polymorphism in Classical Sequent Calculus
Concise Read-Only Specifications for Better Synthesis of Programs with Pointers
Extending Pruning Techniques to Polymorphic Second order Lambda-Calculus
Barriers in Concurrent Separation Logic
Formalising and Verifying Reference Attribute Grammars in Coq
Resolution and Type Theory
An Automated Deductive Verification Framework for Circuit-building Quantum Programs
An Abstract Interpretation Framework for Input Data Usage
Linear Declassification
A Rewriting Semantics for Type Inference
On the Hardness of Analyzing Quantum Programs Quantitatively
Incremental Garbage Collection Without Tags
A Backwards Analysis for Compile-time Garbage Collection
The PSG System: From Formal Language Definitions to Interactive Programming Environments
Query Lifting - Language-integrated query for heterogeneous nested collections
Programming Languages and Systems - ESOP'98, 7th European Symposium on Programming, Held as Part of the European Joint Conferences on the Theory and Practice of Software, ETAPS'98, Lisbon, Portugal, March 28 - April 4, 1998, Proceedings
Specification of a Tool for Viewing Program Text
LINCX: A Linear Logical Framework with First-Class Contexts
Resolving Inductive Definitions with Binders in Higher-Order Typed Functional Programming
Correction of Functional Logic Programs
Safe and Principled Language Interoperation
A Core Calculus for XQuery 3.0 - Combining Navigational and Pattern Matching Approaches
Abstraction of memory block manipulations by symbolic loop folding
The Choice of Programming Primitives for SETL-Like Programming Languages
Tapido: Trust and Authorization Via Provenance and Integrity in Distributed Objects (Extended Abstract)
Proof-Directed De-compilation of Low-Level Code
Session-Typed Concurrent Contracts
Safe Session-Based Concurrency with Shared Linear State
Optimal and Perfectly Parallel Algorithms for On-demand Data-Flow Analysis
Efficient Synthesis of Tight Polynomial Upper-Bounds for Systems of Conditional Polynomial Recurrences
Automating Security Mediation Placement
Deterministic Expressions in C
Iso-Recursive Multiparty Sessions and their Automated Verification
Affine Parallelization of Loops with Run-Time Dependent Bounds from Binaries
Correctness of Sequential Monte Carlo Inference for Probabilistic Programming Languages
Definitional Functoriality for Dependent (Sub)Types
Compositional Verification of Compiler Optimisations on Relaxed Memory
Trocq: Proof Transfer for Free, With or Without Univalence
A Theory of Qualified Types
Amortised Resource Analysis with Separation Logic
Higher Order Escape Analysis: Optimizing Stack Allocation in Functional Program Implementations
An Exception Handling Construct for Functional Languages
Specifying and Verifying Persistent Libraries
Reasoning about Lock Placements
The Correctness of Type Specialisation
A Discipline for Program Verification Based on Backpointers and Its Use in Observational Disjointness
Static Detection of Pointer Errors: An Axiomatisation and a Checking Algorithm
Asserting Bytecode Safety
A Complete Transformational Toolkit for Compilers
Sound and Complete Concolic Testing for Higher-order Functions
An Automata-theoretic Basis for Specification and Type Checking of Multiparty Protocols
Automatic Static Cost Analysis for Parallel Programs
Using Category Theory to Design Programming Languages
An Efficient Algorithm for Solving the Dyck-CFL Reachability Problem on Trees
The PCKS-Machine: An Abstract Machine for Sound Evaluation of Parallel Functional Programs with First-Class Continuations
Deadlock-Free Channels and Locks
Language Primitives and Type Discipline for Structured Communication-Based Programming
The Compiler Forest
Removing Value Encoding Using Alternative Values in Partial Evaluation of Strongly-Typed Languages
Quorum Tree Abstractions of Consensus Protocols
Compositional Analysis of Authentication Protocols
Ribbon Proofs for Separation Logic
Coupled Relational Symbolic Execution for Differential Privacy
Building a Bridge between Pointer Aliases and Program Dependences
A Type System for Effect Handlers and Dynamic Labels
Modular Inference of Linear Types for Multiplicity-Annotated Arrows
Reversing Abstract Interpretations
Run-time Complexity Bounds Using Squeezers
Refinement Types for Incremental Computational Complexity
Neural Network Verification is a Programming Language Challenge
A Calculus for Link-Time Compilation
A Memoizing Semantics for Functional Logic Languages
Structural Lock Correlation with Ownership Types
Contextual Equivalence for Probabilistic Programs with Continuous Random Variables and Scoring
Completing the Picture: Soundness of Formal Encryption in the Presence of Active Adversaries
Verified, Executable Parsing
Programming Languages and Systems, 18th European Symposium on Programming, ESOP 2009, Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2009, York, UK, March 22-29, 2009. Proceedings
On the Implementation of Construction Functions for Non-free Concrete Data Types
Handling Encryption in an Analysis for Secure Information Flow
On Polymorphic Sessions and Functions - A Tale of Two (Fully Abstract) Encodings
Programs as Collections of Communicating Prolog Units
Generative Operational Semantics for Relaxed Memory Models
An Application of Computable Distributions to the Semantics of Probabilistic Programming Languages
Transfer Function Synthesis without Quantifier Elimination
Monadic Intersection Types, Relationally
Extensible and Efficient Automation Through Reflective Tactics
Automatically Splitting a Two-Stage Lambda Calculus
A Consistent Semantics of Self-adjusting Computation
Computationally Sound, Automated Proofs for Security Protocols
Encoding Intensional Type Analysis
Automatic Parallelization of Lazy Functional Programs
The Relationship between Separation Logic and Implicit Dynamic Frames
Dependency Analysis of Mobile Systems
A New Foundation for Control-Dependence and Slicing for Modern Program Structures
Modeling an Algebraic Stepper
Perfect Pipelining: A New Loop Parallelization Technique
A Complete Guide to the Future
Higher-Ranked Annotation Polymorphic Dependency Analysis
A Formal Executable Semantics of the JavaCard Platform
Segment Abstraction for Worst-Case Execution Time Analysis
Another Implementation Technique for Applicative Languages
Requirements on the Execution of Kahn Process Networks
Artifact Report: an Abstract, Certified Account of Operational Game Semantics
A Formal Implementation of Value Commitment
Symbolic Model Checking and Constraint Logic Programming: a Cross-Fertilization
Comparing the expressiveness of the π-calculus and CCS
The Network as a Language Construct
Probabilistic Abstract Interpretation
A Theory of Non-monotone Memory (Or: Contexts for free)
Development of Concurrent Systems by Incremental Transformations
Call-By-Push-Value from a Linear Logic Point of View
SMT-Boosted Security Types for Low-Level MPC
Compositional Invariant Checking for Overlaid and Nested Linked Lists
Distributive Disjoint Polymorphism for Compositional Programming