yusuke1997/dblp-id-title huggingface dataset:
Truly stateless, optimal dynamic partial order reduction
Quest Complete: The Holy Grail of Gradual Security
Syntactic Code Search with Sequence-to-Tree Matching: Supporting Syntactic Search with Incomplete Code Fragments
Performal: Formal Verification of Latency Properties for Distributed Systems
Compiling with continuations, or without? whatever
String constraints with concatenation and transducers solved efficiently
Program adverbs and Tlön embeddings
Inductive Program Synthesis by Meta-Analysis-Guided Hole Filling
Avoiding Signature Avoidance in ML Modules with Zippers
Evolution of Emacs Lisp
Quantum Probabilistic Model Checking for Time-Bounded Properties
Efficient Dual-Numbers Reverse AD via Well-Known Program Transformations
Normalization for fitch-style modal calculi
Bring Your Own Data Structures to Datalog
Programmatic Strategy Synthesis: Resolving Nondeterminism in Probabilistic Programs
Fast linear programming through transprecision computing on small and sparse data
Solo: a lightweight static analysis for differential privacy
A simple differentiable programming language
Definitional proof-irrelevance without K
Symbolic and automatic differentiation of languages
Canonicity for Indexed Inductive-Recursive Types
Quantitative program reasoning with graded modal types
Semantics for variational Quantum programming
Coverage guided, property based testing
Automatically generating features for learning program analysis heuristics for C-like languages
Modular Models of Monoids with Operations
An order-aware dataflow model for parallel Unix pipelines
On the Expressive Power of Languages for Static Variability
The reads-from equivalence for the TSO and PSO memory models
Dependent Ghosts Have a Reflection for Free
Intersection types and runtime errors in the pi-calculus
TorchQL: A Programming Framework for Integrity Constraints in Machine Learning
Type-directed synthesis of visualizations from natural language queries
Sound and complete bidirectional typechecking for higher-rank polymorphism with existentials and indexed types
Resource-Aware Soundness for Big-Step Semantics
DProf: distributed profiler with strong guarantees
Top-Down Synthesis for Library Learning
Scaling up functional programming education: under the hood of the OCaml MOOC
Compiling effect handlers in capability-passing style
LiDO: Linearizable Byzantine Distributed Objects with Refinement-Based Liveness Proofs
Incremental predicate analysis for regression verification
A Tensor Compiler with Automatic Data Packing for Simple and Efficient Fully Homomorphic Encryption
Functional programming for compiling and decompiling computer-aided design
Concurrent incorrectness separation logic
Taming x86-TSO persistency
Compiler Support for Sparse Tensor Convolutions
Weak-consistency specification via visibility relaxation
An axiomatic basis for bidirectional programming
Quantum Circuits Are Just a Phase
Gradual typing: a new perspective
A verified messaging system
Dynamic dispatch of context-sensitive optimizations
Automated Robustness Verification of Concurrent Data Structure Libraries against Relaxed Memory Models
Responsive Parallelism with Synchronization
Precise and scalable points-to analysis via data-driven context tunneling
Program sketching with live bidirectional evaluation
Abstract Interpretation of Fixpoint Iterators with Applications to Neural Networks
Compositional Imprecise Probability: A Solution from Graded Monads and Markov Categories
Instrumentation bias for dynamic data race detection
Static Analysis for Checking the Disambiguation Robustness of Regular Expressions
Random testing for C and C++ compilers with YARPGen
Coherence of type class resolution
Scala implicits are everywhere: a large-scale study of the use of Scala implicits in the wild
Fulfilling OCaml Modules with Transparency
Synthesizing quotient lenses
Dargent: A Silver Bullet for Verified Data Layout Refinement
AtomiS: Data-Centric Synchronization Made Practical
Igloo: soundly linking compositional refinement and separation logic for distributed system verification
Inductive Synthesis of Structurally Recursive Functional Programs from Non-recursive Expressions
FO-Complete Program Verification for Heap Logics
Bounded exhaustive test-input generation on GPUs
Coeffects for sharing and mutation
Automatic and efficient variability-aware lifting of functional programs
End-to-end translation validation for the halide language
Capturing the future by replaying the past (functional pearl)
Mixed linear and non-linear recursive types
Overwatch: learning patterns in code edit sequences
The Simple Essence of Monomorphization
An efficient algorithm for type-safe structural diffing
cuCatch: A Debugging Tool for Efficiently Catching Memory Safety Violations in CUDA Applications
Unifying Compositional Verification and Certified Compilation with a Three-Dimensional Refinement Algebra
Catala: a programming language for the law
How to evaluate blame for gradual types
Format abstraction for sparse tensor algebra compilers
Daedalus: Safer Document Parsing
Parallel complexity analysis with temporal session types
Adventure of a Lifetime: Extract Method Refactoring for Rust
Compositional programming and testing of dynamic distributed systems
Tail Modulo Cons, OCaml, and Relational Separation Logic
Distributed system development with ScalaLoci
Fuzzi: a three-level logic for differential privacy
CompCertOC: Verified Compositional Compilation of Multi-threaded Programs with Shared Stacks
Bottom-up synthesis of recursive functional programs using angelic execution
Induction duality: primal-dual search for invariants
Mosaic: An Interoperable Compiler for Tensor Algebra
The high-level benefits of low-level sandboxing
Algebraic Temporal Effects: Temporal Verification of Recursively Typed Higher-Order Programs
Study of the subtyping machine of nominal subtyping with variance
Stochastic Lazy Knowledge Compilation for Inference in Discrete Probabilistic Programs
Can guided decomposition help end-users write larger block-based programs? a mobile robot experiment
Synthesizing symmetric lenses
Generalized Policy-Based Noninterference for Efficient Confidentiality-Preservation
Denotational Semantics of Gradual Typing using Synthetic Guarded Domain Theory
Synthesizing Precise Static Analyzers for Automatic Differentiation
Strong Invariants Are Hard: On the Hardness of Strongest Polynomial Invariants for (Probabilistic) Programs
SpecSafe: detecting cache side channels in a speculative world
BioScript: programming safe chemistry on laboratories-on-a-chip
Oxidizing OCaml with Modal Memory Management
Solvable Polynomial Ideals: The Ideal Reflection for Program Analysis
Relational Abstractions Based on Labeled Union-Find
Casts and costs: harmonizing safety and performance in gradual typing
Effect-driven QuickChecking of compilers
Merging Gradual Typing
Relational program synthesis
A role for dependent types in Haskell
Fully abstract models for effectful λ-calculi via category-theoretic logical relations
SimTyper: sound type inference for Ruby using type equality prediction
Partial (In)Completeness in abstract interpretation: limiting the imprecision in program analysis
Separating the Wheat from the Chaff: Understanding (In-)Completeness of Proof Mechanisms for Separation Logic with Inductive Definitions
Making a Type Difference: Subtraction on Intersection Types as Generalized Record Operations
Language-Parametric Reference Synthesis
Faster variational execution with transparent bytecode transformation
Aliasing Limits on Translating C to Safe Rust
A Graded Modal Dependent Type Theory with a Universe and Erasure, Formalized
QED in Context: An Observation Study of Proof Assistant Users
Fuzzing channel-based concurrency runtimes using types and effects
TASTyTruffle: Just-in-Time Specialization of Parametric Polymorphism
UTFix: Change Aware Unit Test Repairing using LLM
A Taxonomy of Hoare-Like Logics: Towards a Holistic View using Predicate Transformers and Kleene Algebras with Top and Tests
Reflecting on Random Generation
A Complementary Approach to Incorrectness Typing
Compilation of Shape Operators on Sparse Arrays
Data flow refinement type inference
Parameterized Infinite-State Reactive Synthesis
RichWasm: Bringing Safe, Fine-Grained, Shared-Memory Interoperability Down to WebAssembly
Projection-based runtime assertions for testing and debugging Quantum programs
Finite-Choice Logic Programming
TiML: a functional language for practical complexity analysis with invariants
Gradual Indexed Inductive Types
Purity of an ST monad: full abstraction by semantically typed back-translation
Deadlock avoidance in parallel programs with futures: why parallel tasks should not wait for strangers
Quantitative Bounds on Resource Usage of Probabilistic Programs
The early history of F#
JaVerT: JavaScript verification toolchain
Computing Precise Control Interface Specifications
On the Operational Theory of the CPS-Calculus: Towards a Theoretical Foundation for IRs
Don't Look UB: Exposing Sanitizer-Eliding Compiler Optimizations
Typing Strictness
SAVI objects: sharing and virtuality incorporated
Beyond Backtracking: Connections in Fine-Grained Concurrent Separation Logic
CLOTHO: directed test generation for weakly consistent database systems
Welterweight Go: Boxing, Structural Subtyping, and Generics
Approximate Relational Reasoning for Higher-Order Probabilistic Programs
An empirical study of the effect of source-level loop transformations on compiler stability
Parameterized verification under TSO is PSPACE-complete
Garbage-Collection Safety for Region-Based Type-Polymorphic Programs
Memento: A Framework for Detectable Recoverability in Persistent Memory
Program Analysis via Multiple Context Free Language Reachability
Synthesizing fine-grained synchronization protocols for implicit monitors
Semantic Code Refactoring for Abstract Data Types
Taming callbacks for smart contract modularity
PerSeVerE: persistency semantics for verification under ext4
Hybrid Multiparty Session Types: Compositionality for Protocol Specification through Endpoint Projection
Deciding accuracy of differential privacy schemes
LiveDroid: identifying and preserving mobile app state in volatile runtime environments
Categorical combinatorics of scheduling and synchronization in game semantics
Multi-stage Relational Programming
Trace aware random testing for distributed systems
Stable relations and abstract interpretation of higher-order programs
Finding ∀∃ Hyperbugs using Symbolic Execution
Linear capabilities for fully abstract compilation of separation-logic-verified code
Denotational recurrence extraction for amortized analysis
Learning formulas in finite variable logics
General Decidability Results for Systems with Continuous Counters
Perception Contracts for Safety of ML-Enabled Systems
Coarser Equivalences for Causal Concurrency
Type-Based Gradual Typing Performance Optimization
DisLog: A Separation Logic for Disentanglement
GraphIt: a high-performance graph DSL
Precision-guided context sensitivity for pointer analysis
Optimal heap limits for reducing browser memory use
Symbolic Execution for Quantum Error Correction Programs
Synthesizing replacement classes
Indexed Types for a Statically Safe WebAssembly
Object-oriented recovery for non-volatile memory
AutoPandas: neural-backed generators for program synthesis
From Capabilities to Regions: Enabling Efficient Compilation of Lexical Effect Handlers
Combinator-Based Fixpoint Algorithms for Big-Step Abstract Interpreters
Outcome Separation Logic: Local Reasoning for Correctness and Incorrectness with Computational Effects
Static Posterior Inference of Bayesian Probabilistic Programming via Polynomial Solving
babble: Learning Better Abstractions with E-Graphs and Anti-unification
An Explanation Method for Models of Code
Higher-order type-level programming in Haskell
Simuliris: a separation logic framework for verifying concurrent program optimizations
RustBelt: securing the foundations of the rust programming language
VESTA: Power Modeling with Language Runtime Events
On the design, implementation, and use of laziness in R
Skipping the binder bureaucracy with mixed embeddings in a semantics course (functional pearl)
The Complex(ity) Landscape of Checking Infinite Descent
Sound Borrow-Checking for Rust via Symbolic Semantics
Positive Almost-Sure Termination: Complexity and Proof Rules
Deciding Asynchronous Hyperproperties for Recursive Programs
AUTOMAP: Inferring Rank-Polymorphic Function Applications with Integer Linear Programming
Just-in-time learning for bottom-up enumerative synthesis
Verifying Solutions to Semantics-Guided Synthesis Problems
Build systems à la carte
Verified low-level programming embedded in F
Optimal stateless model checking for reads-from equivalence under sequential consistency
Programming by Navigation
PAFL: Enhancing Fault Localizers by Leveraging Project-Specific Fault Patterns
Can advanced type systems be usable? An empirical study of ownership, assets, and typestate in Obsidian
A study of inline assembly in solidity smart contracts
An auditing language for preventing correlated failures in the cloud
Analyzing binding extent in 3CPS
A type system for extracting functional specifications from memory-safe imperative programs
Robust Resource Bounds with Static Analysis and Bayesian Inference
Multi-Language Probabilistic Programming
Semantics of Remote Direct Memory Access: Operational and Declarative Models of RDMA on TSO Architectures
Pointer Analysis for Database-Backed Applications
Putting Weak Memory in Order via a Promising Intermediate Representation
Mechanised Hypersafety Proofs about Structured Data
Revealing Sources of (Memory) Errors via Backward Analysis
Herbarium Racketensis: a stroll through the woods (functional pearl)
UDF to SQL translation through compositional lazy inductive synthesis
Securing Verified IO Programs Against Unverified Code in F
An Algebraic Language for Specifying Quantum Networks
Closed forms for numerical loops
Parametricity versus the universal type
Fusing industry and academia at GitHub (experience report)
Geo-distribution of actor-based services
Coarsening optimization for differentiable programming
MEA2: A Lightweight Field-Sensitive Escape Analysis with Points-to Calculation for Golang
Endangered by the Language But Saved by the Compiler: Robust Safety via Semantic Back-Translation
Context-Free-Language Reachability for Almost-Commuting Transition Systems
A Case for First-Class Environments
JaVerT 2.0: compositional symbolic execution for JavaScript
Inductive Program Synthesis via Iterative Forward-Backward Abstract Interpretation
Automating Pruning in Top-Down Enumeration for Program Synthesis Problems with Monotonic Semantics
Compatible Branch Coverage Driven Symbolic Execution for Efficient Bug Finding
Static placement of computation on heterogeneous devices
Efficient automatic scheduling of imaging and vision pipelines for the GPU
Top-Down or Bottom-Up? Complexity Analyses of Synchronous Multiparty Session Types
Embedding Hindsight Reasoning in Separation Logic
code2vec: learning distributed representations of code
Reachability Analysis of the Domain Name System
IntelliMerge: a refactoring-aware software merging technique
Detecting floating-point errors via atomic conditions
DeepBugs: a learning approach to name-based bug detection
Fixpoints for the masses: programming with first-class Datalog constraints
Semantic-Type-Guided Bug Finding
Guarded Kleene algebra with tests: verification of uninterpreted programs in nearly linear time
Newtonian Program Analysis of Probabilistic Programs
WhiteFox: White-Box Compiler Fuzzing Empowered by Large Language Models
Reachability types: tracking aliasing and separation in higher-order functional programs
Propositions-as-types and shared state
Kater: Automating Weak Memory Model Metatheory and Consistency Checking
Competitive parallelism: getting your priorities right
Principal Type Inference under a Prefix: A Fresh Look at Static Overloading
Liquidate your assets: reasoning about resource usage in liquid Haskell
Fast and Optimal Extraction for Sparse Equality Graphs
Graduality and parametricity: together again for the first time
Synthesis of coordination programs from linear temporal specifications
Bidirectional Higher-Rank Polymorphism with Intersection and Union Types
Persistency semantics of the Intel-x86 architecture
Effective interactive resolution of static analysis alarms
Sound and reusable components for abstract interpretation
Di- is for Directed: First-Order Directed Type Theory via Dinaturality
Generating good generators for inductive relations
Relatively complete refinement type system for verification of higher-order non-deterministic programs
Bit-Stealing Made Legal: Compilation for Custom Memory Representations of Algebraic Data Types
Decidable subtyping for path dependent types
On Model-Checking Higher-Order Effectful Programs
RRR-SMR: Reduce, Reuse, Recycle: Better Methods for Practical Lock-Free Data Structures
Dis/Equality Graphs
What you needa know about Yoneda: profunctor optics and the Yoneda lemma (functional pearl)
Practical Verification of Smart Contracts using Memory Splitting
Complexity and information in invariant inference
Recursive State Machine Guided Graph Folding for Context-Free Language Reachability
A completely unique account of enumeration
BiSikkel: A Multimode Logical Framework in Agda
Compiler fuzzing: how much does it matter?
Automatically eliminating speculative leaks from cryptographic code with blade
Robust Constant-Time Cryptography
Provenance-guided synthesis of Datalog programs
Aiming low is harder: induction for lower bounds in probabilistic program verification
Generating collection transformations from proofs
Enriched Presheaf Model of Quantum FPC
Kinds are calling conventions
ApproxHPVM: a portable compiler IR for accuracy-aware optimizations
Decoupling lock-free data structures from memory reclamation for static analysis
Paxos made EPR: decidable reasoning about distributed protocols
Practical Type Inference with Levels
DR.FIX: Automatically Fixing Data Races at Industry Scale
Verifying Lock-Free Traversals in Relaxed Memory Separation Logic
Fair termination of binary sessions
Concerto: a framework for combined concrete and abstract interpretation
PROMPT: A Fast and Extensible Memory Profiling Framework
Safer at any speed: automatic context-aware safety enhancement for Rust
Model Checking Distributed Protocols in Must
A Verified Foreign Function Interface between Coq and C
Efficient differentiable programming in a functional array-processing language
Automatically deriving control-flow graph generators from operational semantics
HOL4P4: Mechanized Small-Step Semantics for P4
Degrees of Separation: A Flexible Type System for Safe Concurrency
Permchecker: a toolchain for debugging memory managers with typestate
Inductive Synthesis of Inductive Heap Predicates
Model checking for a multi-execution memory model
Abstraction Functions as Types: Modular Verification of Cost and Behavior in Dependent Type Theory
Modular verification of web page layout
Finding code that explodes under symbolic evaluation
Persistence semantics for weak memory: integrating epoch persistency with the TSO memory model
Generic Programming with Extensible Data Types: Or, Making Ad Hoc Extensible Data Types Less Ad Hoc
Tropical Mathematics and the Lambda-Calculus II: Tropical Geometry of Probabilistic Programming Languages
Dependently typed Haskell in industry (experience report)
Hambazi: Spatial Coordination Synthesis for Augmented Reality
CompCertELF: verified separate compilation of C programs into ELF object files
Fast Coalgebraic Bisimilarity Minimization
RELINCHE: Automatically Checking Linearizability under Relaxed Memory Consistency
Handling the Selection Monad
A Learning-Based Approach to Static Program Slicing
Rows and Capabilities as Modal Effects
Modular verification of op-based CRDTs in separation logic
Flexible Type-Based Resource Estimation in Quantum Circuit Description Languages
flap: A Deterministic Parser with Fused Lexing
Jones-optimal partial evaluation by specialization-safe normalization
Absynthe: Abstract Interpretation-Guided Synthesis
Automatic Parallelism Management
Principality and approximation under dimensional bound
Formal verification of high-level synthesis
Verification-Preserving Inlining in Automatic Separation Logic Verifiers
Peepco: Batch-Based Consistency Optimization
On incorrectness logic and Kleene algebra with top and tests
Augmented example-based synthesis using relational perturbation properties
A case for DOT: theoretical foundations for objects with pattern matching and GADT-style reasoning
CAAT: consistency as a theory
Lazy Linearity for a Core Functional Language
Rapid: Region-Based Pointer Disambiguation
Data-driven context-sensitivity for points-to analysis
Extending the C/C++ Memory Model with Inline Assembly
Context-bounded verification of liveness properties for multithreaded shared-memory programs
A verified, efficient embedding of a verifiable assembly language
Simple Reference Immutability for System F
Automatically Verifying Replication-Aware Linearizability
Type stability in Julia: avoiding performance pathologies in JIT compilation
Bounded Sort Polymorphism with Elimination Constraints
Run-Time Prevention of Software Integration Failures of Machine Learning APIs
Hidden inheritance: an inline caching design for TypeScript performance
Compiling Conditional Quantum Gates without Using Helper Qubits
Characterizing Sets of Theories That Can Be Disjointly Combined
A Cocktail Approach to Practical Call Graph Construction
Fast, sound, and effectively complete dynamic race prediction
Turaco: Complexity-Guided Data Sampling for Training Neural Surrogates of Programs
Getafix: learning to fix bugs automatically
A calculus for Esterel: if can, can. if no can, no can
Lexicographic ranking supermartingales: an efficient approach to termination of probabilistic programs
Plume: Efficient and Complete Black-Box Checking of Weak Isolation Levels
A pre-expectation calculus for probabilistic sensitivity
Symbolic types for lenient symbolic execution
Superfusion: Eliminating Intermediate Data Structures via Inductive Synthesis
Generalized evidence passing for effect handlers: efficient compilation of effect handlers to C
A Logic for the Imprecision of Abstract Interpretations
P4R-Type: A Verified API for P4 Control Plane Programs
An Infinite Needle in a Finite Haystack: Finding Infinite Counter-Models in Deductive Verification
Proving hypersafety compositionally
Intensional datatype refinement: with application to scalable verification of pattern-match safety
Call-by-Unboxed-Value
Elaborating dependent (co)pattern matching
CompCertM: CompCert with C-assembly linking and lightweight modular verification
Implementation and Synthesis of Math Library Functions
Axe 'Em: Eliminating Spurious States with Induction Axioms
Bayesian Separation Logic: A Logical Foundation and Axiomatic Semantics for Probabilistic Programming
Regex matching with counting-set automata
Solving Infinite-State Games via Acceleration
Search-Based Regular Expression Inference on a GPU
Nola: Later-Free Ghost State for Verifying Termination in Iris
Inter-theory dependency analysis for SMT string solvers
Enhanced Enumeration Techniques for Syntax-Guided Synthesis of Bit-Vector Manipulations
Concrete Type Inference for Code Optimization using Machine Learning with SMT Solving
Interval universal approximation for neural networks
Do You Even Lift? Strengthening Compiler Security Guarantees against Spectre Attacks
AdoB: Bridging Benign and Byzantine Consensus with Atomic Distributed Objects
Heaps don't lie: countering unsoundness with heap snapshots
Refinement of path expressions for static analysis
Dependently-Typed Programming with Logical Equality Reflection
Generic Refinement Types
Collecting Cyclic Garbage across Foreign Function Interfaces: Who Takes the Last Piece of Cake?
Conflict resolution for structured merge via version space algebra
Step-Indexed Logical Relations for Countable Nondeterminism and Probabilistic Choice
Visitors unchained
Necessity specifications for robustness
Deciding reachability under persistent x86-TSO
Encode the Cake and Eat It Too: Controlling Computation in Type Theory, Locally
Floating-Point TVPI Abstract Domain
Fusing Direct Manipulations into Functional Programs