yusuke1997/dblp-id-title huggingface dataset:
Big types in little runtime: open-world soundness and collaborative blame for gradual type systems
A General Scheme for the Automatic Inference of Variable Types
Lightweight fusion by fixed point promotion
Specifying Programming Language Semantics
Verifying eventual consistency of optimistic replication systems
Full abstraction for nominal Scott domains
Lazy Array Data-Flow Dependence Analysis
Mathematical Semantics of Snobol 4
Reconfigurable asynchronous logic automata: (RALA)
Learning minimal abstractions
Semantics-Preserving Procedure Extraction
Invariants of quantum programs: characterisations and generation
Coercion and Type Inference
Fissile type analysis: modular checking of almost everywhere invariants
Information effects
Parallel computing with the Pi-calculus
The Influence of Productions on Derivations and Parsing
Proceedings of the 34th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL 2007, Nice, France, January 17-19, 2007
Predicate Path Expressions
The Evolution of List-Copying Algorithms
The Theory and Practice of First-Class Prompts
Safe Run-time Overloading
Conference Record of POPL 2001: The 28th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, London, UK, January 17-19, 2001
Structuring Depth-First Search Algorithms in Haskell
Reducing Nondeterminism while Specializing Logic Programs
A Precise Interprocedural Data Flow Algorithm
Precise Typing of Abstract Data Type Specifications
Combining proofs and programs in a dependently typed language
On Effective Axiomatizations of Hoare Logics
Explicit Polymorphism and CPS Conversion
Soft Typing with Conditional Types
Algebraic Reconstruction of Types and Effects
LightDP: towards automating differential privacy proofs
A Portable Compiler: Theory and Practice
Integrating typed and untyped code in a scripting language
Fast and loose reasoning is morally correct
Call by Need Computations to Root-Stable Form
Layer Sharing: An Improved Structure-Sharing Framework
Bounded Quantification is Undecidable
A Temporal Fixpoint Calculus
Parametricity as Subtyping
Lightweight verification of separate compilation
Parallelism and Synchronization in Actor Systems
A trusted mechanised JavaScript specification
The Aggregate Update Problem in Functional Programming Systems
Verifying Formal Specifications of Synchronous Processes
How to Make Destructive Updates Less Destructive
A model-learner pattern for bayesian reasoning
From parametricity to conservation laws, via Noether's theorem
Data parallel Haskell: a status report
LOIS: syntax and semantics
Verifying properties of well-founded linked lists
Underspecified harnesses and interleaved bugs
Lifetime Analysis of Dynamically Allocated Objects
A generic type system for the Pi-calculus
Intersection type calculi of bounded dimension
Selective and Lightweight Closure Conversion
Separation logic, abstraction and inheritance
Monitors and blame assignment for higher-order session types
POPL '98, Proceedings of the 25th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, San Diego, CA, USA, January 19-21, 1998
On the Ability of Structures to Store and Access Information
Expressive array constructs in an embedded GPU kernel programming language
Environment classifiers
A probabilistic language based upon sampling functions
Type Inference with Subtypes
Program Verification Based on Denotational Semantics
Lithe: A Language Combining a Flexible Syntax, Classes
Semantics of static pointcuts in aspectJ
Dominators, Super Blocks, and Program Coverage
Computable Values Can Be Classical
Game semantics for interface middleweight Java
Modular set-based analysis from contracts
Differential Privacy: Now it's Getting Personal
Primitive Recursive Program Transformations
A Formulae-as-Types Notion of Control
Software protection for dynamically-generated code
Integrating Linear and Dependent Types
Separation logic and abstraction
A bisimulation for type abstraction and recursion
A Framework for Combining Analysis and Verification
Fast and Accurate Flow-Insensitive Points-To Analysis
A bisimulation for dynamic sealing
Relaxed memory models: an operational approach
A theory of platform-dependent low-level software
Typing Record Concatenation for Free
Multiparty asynchronous session types
SPEED: precise and efficient static estimation of program computational complexity
Unified Dialogue Management in the Carousel System
Learning programs from noisy data
Code Motion of Control Structures in High-Level Languages
Space overhead bounds for dynamic memory management with partial compaction
Enterprise privacy promises and enforcement
Inductive data flow graphs
A type theory for probability density functions
Verification and Design Aspects of "True" Concurrency
Efficient Computation of Expressions with Common Subexpressions
Estimating types in binaries using predictive modeling
Analysis of Simple Programs Over Different Sets of Primitives
An Algorithm for Optimal Lambda Calculus Reduction
The Java memory model
On Directly Constructing LR(k) Parsers Without Chain Reductions
Evicted Variables and the Interaction of Global Register Allocation and Symbolic Debugging
On Specifying Verifiers
Lightweight asynchrony using parasitic threads
Compiler-directed channel allocation for saving power in on-chip networks
Sessional dataflow: short paper
Dynamic multirole session types
Type-indexed rows
Sound compilation of reals
Value Dependence Graphs: Representation without Taxation
Type-Based Analysis of Uncaught Exceptions
Quasi-Static Scoping: Sharing Variable Bindings Across Multiple Lexical Scopes
Fully abstract compilation to JavaScript
Algebraic Reasoning and Completeness in Typed Languages
Transforming Out Timing Leaks
Combinatory Representation of Mobile Processes
Practical Program Verification: Automatic Program Proving for Real-Time Embedded Software
Incremental Compilation of Locally Optimized Code
Probabilistic Termination: Soundness, Completeness, and Compositionality
Counter-factual typing for debugging type errors
A Record Calculus Based on Symmetric Concatenation
Techniques for the Automatic Selection of Data Structures
A Curry-Howard Foundation for Functional Computation with Control
Executable Specifications with Quantifiers in the FASE System
Discovering Auxiliary Information for Incremental Computation
Geometry of synthesis: a structured approach to VLSI design
Manufacturing Cheap, Resilient, and Stealthy Opaque Constructs
Incremental Computation via Function Caching
Automatic numeric abstractions for heap-manipulating programs
The hardness of cache conscious data placement
Protecting representation with effect encapsulation
Full Abstraction of a Real-Time Denotational Semantics for an Occam-like Language
Polymorphic Functions with Set-Theoretic Types: Part 2: Local Type Inference and Type Reconstruction
Stochastic lambda calculus and monads of probability distributions
An Overview of the Summer Programming Language
A New Method for Compiler Code Generation
Proving Concurrent Constraint Programs Correct
An Incremental Algorithm for Maintaining the Dominator Tree of a Reducible Flowgraph
Computable processes
Closed type families with overlapping equations
On Relative Completeness of Programming Logics
Explicit Substitutions
A Debate on Language and Tool Support for Design Patterns
A General Approach for Run-Time Specialization and its Application to C
From System F to Typed Assembly Language
Temporal verification of higher-order functional programs
Detecting Equality of Variables in Programs
String solving with word equations and transducers: towards a logic for analysing mutation XSS
On the Power and Limitation of Strictness Analysis Based on Abstract Interpretation
Total Correctness by Local Improvement in Program Transformation
Proceedings of the 36th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL 2009, Savannah, GA, USA, January 21-23, 2009
Probabilistic relational reasoning for differential privacy
Automated soundness proofs for dataflow analyses and transformations via local rules
Consistency analysis of decision-making programs
An Efficient Insertion-Only Error-Corrector for LL(1) Parsers
Secure Information Flow in a Multi-Threaded Imperative Language
Polymorphic Effect Systems
Lazy abstraction
Extended Naming Conventions for Communicating Processes
Communicating Reactive Processes
Paralocks: role-based information flow control and beyond
Implicative Formulae in the "Proofs as Computations" Analogy
On the verification problem for weak memory models
Linearity and the Pi-Calculus
Software Watermarking: Models and Dynamic Embeddings
Static determination of quantitative resource usage for higher-order programs
Para-Functional Programming: A Paradigm for Programming Multiprocessor Systems
The exp-log normal form of types: decomposing extensional equality and representing terms compactly
The Lambda Lambda-Bar calculus: a dual calculus for unconstrained strategies
Modular reasoning about concurrent higher-order imperative programs
Compositional shape analysis by means of bi-abduction
Functional Programming and the Logical Variable
Towards automatic construction of staged compilers
Making the World Safe for Garbage Collection
Gradual typing embedded securely in JavaScript
Proceedings of the POPL 2007 Workshop on Declarative Aspects of Multicore Programming, DAMP 2007, Nice, France, January 16, 2007
Demand-driven Computation of Interprocedural Data Flow
Practical Syntactic Error Recovery
The Geometry of Interaction Machine
Building automatic program verifiers
Relevance heuristics for program analysis
Copy-on-write in the PHP language
Parallel Program Correctness Through Refinement
From dirt to shovels: fully automatic tool generation from ad hoc data
The Logic of a Relational Data Manipulation Language
The influence of dependent types (keynote)
DReX: A Declarative Language for Efficiently Evaluating Regular String Transformations
Typing a multi-language intermediate code
Putting Pointer Analysis to Work
Fully-abstract compilation by approximate back-translation
Harmless advice
A Type System Equivalent to Flow Analysis
A polymorphic modal type system for lisp-like multi-staged languages
Principality and Decidable Type Inference for Finite-Rank Intersection Types
Algorithmic Program Diagnosis
A typed intermediate language for compiling multiple inheritance
A program optimization for automatic database result caching
From principles to programming languages (and back)
Towards a mechanized metatheory of standard ML
On Strictness and its Analysis
Themes in information-rich functional programming for internet-scale data sources
A Sort Inference Algorithm for the Polyadic Pi-Calculus
Extensional normalisation and type-directed partial evaluation for typed lambda calculus with sums
Implementation of an Array Bound Checker
Using Functor Categories to Generate Intermediate Code
A theory of indirection via approximation
Freefinement
A PL/CV Precis
A framework for numeric analysis of array operations
Free theorems in the presence of seq
Empty Types in Polymorphic Lambda Calculus
Conference Record of the Eleventh Annual ACM Symposium on Principles of Programming Languages, Salt Lake City, Utah, USA, January 1984
Type systems as macros
Scalable error detection using boolean satisfiability
Proceedings of the 33rd ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL 2006, Charleston, South Carolina, USA, January 11-13, 2006
Efficient Dataflow Analysis of Logic Programs
Summary-Based Context-Sensitive Data-Dependence Analysis in Presence of Callbacks
Proving non-termination
Authenticated data structures, generically
Type Systems for Distributed Data Structures
Semantic types: a fresh look at the ideal model for types
Axioms for Concurrent Objects
Minimal and Optimal Computations of Recursive Programs
Atomizer: a dynamic atomicity checker for multithreaded programs
Static Single Assignment for Explicitely Parallel Programs
How languages can save distributed computing
Dependent Types in Practical Programming
Automatic Generation of Near-Optimal Translators for Noncircular Attribute Grammars
Static Type Inference in a Dynamically Typed Language
Subcubic algorithms for recursive state machines
Extending Record Typing to Type Parametric Modules with Sharing
Rust: from POPL to practice (keynote)
A theory of contracts for web services
Array SSA Form and Its Use in Parallelization
How to Cook a Temporal Proof System for Your Pet Language
Certifying Information Flow Properties of Programs: An Axiomatic Approach
Structured Operational Semantics as a Specification Language
Type soundness proofs with definitional interpreters
Slot games: a quantitative model of computation
Monoids for Rapid Data Flow Analysis
Decidable logics combining heap structures and data
Generalized Conjunctive Types
Static prediction of heap space usage for first-order functional programs
Obtaining Sequential Efficiency for Concurrent Object-Oriented Languages
Implicit Parameters: Dynamic Scoping with Static Types
Mechanisms for Compile-Time Enforcement of Security
A real-time garbage collector with low overhead and consistent utilization
Non-linear loop invariant generation using Gröbner bases
Resolving Circularity in Attribute Grammars with Applications to Data Flow Analysis
High-level separation logic for low-level code
The essence of XML
Symbolic abstract data type inference
A Concurrent, Generational Garbage Collector for a Multithreaded Implementation of ML
An Assertion Language for Data Structures
Generalized Dominators and Post-Dominators
Proceedings of the 35th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL 2008, San Francisco, California, USA, January 7-12, 2008
EigenCFA: accelerating flow analysis with GPUs
Sums of uncertainty: refinements go gradual
Lightweight semiformal time complexity analysis for purely functional data structures
Toward a foundational typed assembly language
The essence of command injection attacks in web applications
Towards fully automatic placement of security sanitizers and declassifiers
Programming Language Semantics and Closed Applicative Languages
Conference Record of POPL'97: The 24th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, Papers Presented at the Symposium, Paris, France, 15-17 January 1997
The gradualizer: a methodology and algorithm for generating gradual type systems
Optimal Scheduling of Arithmetic Operations in Parallel with Memory Accesses
PER Models of Subtyping, Recursive Types and Higher-Order Polymorphism
Modular code generation from synchronous block diagrams: modularity vs. code size
Type Checking in an Imperfect World
Verification of Attribute Grammars
A type theory for memory allocation and data layout
Profiling for laziness
From Lambda-sigma to Lambda-upsilon a Journey Through Calculi of Explicit Substitutions
Shape Analysis for Mobile Ambients
Tractable Refinement Checking for Concurrent Objects
A Calculus for Relaxed Memory
Large Scale File Processing - Pogol
Rigorous floating-point mixed-precision tuning
CLP* and Constraint Abstraction
Compositional dynamic test generation
Macro-by-Example: Deriving Syntactic Transformations from their Specifications
The theory of deadlock avoidance via discrete control
Optimization and Relaxation in Constraint Logic Languages
A Case Study in Specifying the Semantics of a Programming Language
Proceedings of the 44th ACM SIGPLAN Symposium on Principles of Programming Languages, POPL 2017, Paris, France, January 18-20, 2017
Adventures in time and space
Specification and Synthesis of Communicating Processes using an Extended Temporal Logic
Building Friendly Parsers
Rolling Your Own MADT - A Connection Between Linear Types and Monads
Experience with an Attribute Grammar-Based Compiler
Probabilistic relational verification for cryptographic implementations
Recursion in Logics of Programs
Cork: dynamic memory leak detection for garbage-collected languages
Proof Spaces for Unbounded Parallelism
A Greedy Approach to Incremental Code Generation
Sequential verification of serializability
Analytic Constraint Solving and Interval Arithmetic
Typing First-Class Continuations in ML
Toward a Typed Foundation for Method Specialization and Inheritance
Regular expression containment: coinductive axiomatization and computational interpretation
Five Paradigm Shifts in Language Design and their Realization in Viron, a Dataflow Programming Environment
Defining code-injection attacks
Representation independence, confinement and access control [extended abstract]
From implementation to theory in product synthesis
Bisimulation congruences in safe ambients
QWIRE: a core language for quantum circuits
Data Types, Parameters, and Type Checking
Qualified Data Flow Problems
Summarizing procedures in concurrent programs
A Scalable, Correct Time-Stamped Stack
Lazy multivariate higher-order forward-mode AD
A Logic for Expressions with Side-Effects
The Functional Power of Parameter Passage Mechanisms
Kleenex: compiling nondeterministic transducers to deterministic streaming transducers
Semantic Foundations of Jade
Clarifying and compiling C/C++ concurrency: from C++11 to POWER
Compiling Polymorphism Using Intensional Type Analysis
Inheritance in Smalltalk-80: A Denotational Definition
Specification and Verification of Concurrent Programs By Forall-Automata
Abstracting gradual typing
Reasoning about Rings
Optimal Code for Control Structures
Functors are Type Refinement Systems
Automatically generating the dynamic semantics of gradually typed languages
AnnoDomini: From Type Theory to Year 2000 Conversion Tool
Role analysis
Proof theory and its role in programming language research
A type system for higher-order modules
Rewrite, Rewrite, Rewrite, Rewrite, Rewrite
A Good Hoare Axiom System for an Algol-like Language
Maximizing Parallelism and Minimizing Synchronization with Affine Transforms
Types for Mobile Ambients
Quantitative Interprocedural Analysis
Escape Analysis: Correctness Proof, Implementation and Experimental Results
On the Temporal Analysis of Fairness
Off-Line and On-Line Algorithms for Deducing Equalities
Clauses: Scope Structures and Defined Functions in Lucid
Incremental Data Flow Analysis
On the Adequacy of Program Dependence Graphs for Representing Programs
Bridging boolean and quantitative synthesis using smoothed proof search
Optimal Derivations in Weak Lambda-calculi and in Orthogonal Terms Rewriting Systems
Propositional Logics of Programs: Systems, Models, and Complexity
Optimizing an ANSI C Interpreter with Superoperators
A Complete and Consistent Hoare Semantics for a Simple Programming Language
A Coalgebraic Decision Procedure for NetKAT
Putting Type Annotations to Work
Moded Type Systems for Logic Programming
Appraising Fairness in Languages for Distributed Programming
A semantic account of metric preservation
Incremental algorithms for dispatching in dynamically typed languages
From Communicating Machines to Graphical Choreographies
Proof engineering: implementation challenges in rigorously verified software
Verified squared: does critical software deserve verified tools?
Hazelnut: a bidirectionally typed structure editor calculus
Tracing compilation by abstract interpretation
Proving the Correctness of Reactive Systems Using Sized Types
Calling context abstraction with shapes
Local Constraints in the Syntax and Semantics of Programming Languages
Smartest Recompilation
Scheduling Time-Critical Instructions on RISC Machines
Avoiding exponential explosion: generating compact verification conditions
Fair reactive programming
Conference Record of the Fifteenth Annual ACM Symposium on Principles of Programming Languages, San Diego, California, USA, January 10-13, 1988
A simple, verified validator for software pipelining
Deep Specifications and Certified Abstraction Layers
Step-indexed kripke models over recursive worlds
Universal properties of impure programming languages
The tree width of auxiliary storage
Coercive subtyping for the calculus of constructions
Type-Checking Higher-Order Polymorphic Multi-Methods
Automatic detection of floating-point exceptions
Stores and Partial Continuations as First-Class Objects in a Language and its Environment
Precise reasoning for programs using containers
Composing Tree Attributions
A uniform type structure for secure information flow
Denotational Semantics and Rewrite Rules for FP
Generating Machine Specific Optimizing Compilers
Correctness-Preserving Program Transformations
SequenceL: transparency and multi-core parallelisms
Generalized Certificate Revocation
The Chemical Abstract Machine
Composing dataflow analyses and transformations
Characterization and Elimination of Redundancy in Recursive Programs
C: A Language for High-Level, Efficient, and Machine-Independent Dynamic Code Generation
Preferential path profiling: compactly numbering interesting paths
Modular Verification of Concurrent Programs
Computational flux
Single and Loving It: Must-Alias Analysis for Higher-Order Languages
An Axiomatic Treatment of Exception Handling
Semantic-directed clumping of disjunctive abstract states
Program Specification and Development in Standard ML
Exact Bayesian inference by symbolic disintegration
Deadlock-freedom-by-design: multiparty asynchronous global programming
An Ideal Model for Recursive Polymorphic Types
An approach to call-by-name delimited continuations
Continuous Grammars
Conference Record of the Ninth Annual ACM Symposium on Principles of Programming Languages, Albuquerque, New Mexico, USA, January 1982
Separating Stages in the Continuation-Passing Style Transformation
Polyp - A Polytypic Programming Language
Sequential Algorithms, Deterministic Parallelism, and Intensional Expressiveness
Efficient Recursive Subtyping
Equality saturation: a new approach to optimization
Static contract checking for Haskell
Verified just-in-time compiler on x86
Information flow inference for ML
Efficient Algorithms for pre * and post * on Interprocedural Parallel Flow Graphs
The 3 R's of Optimizing Constraint Logic Programs: Refinement, Removal and Reordering
Hyperstream processing systems: nonstandard modeling of continuous-time signals
Model Checking for Programming Languages using Verisoft
Building Interpreters by Composing Monads
Computational higher-dimensional type theory
Continuation-Passing, Closure-Passing Style
Toward general diagnosis of static errors
NetkAT: semantic foundations for networks
Polymorphic bytecode: compositional compilation for Java-like languages
Predicting Program Properties from "Big Code"
Fairness and Hyperfairness in Multi-Party Interactions
Decidable Bounded Quantification
Why dependent types matter
Creating Efficient Systems for Object-Oriented Languages
Fully Abstract Compositional Semantics for Logic Programs
An operational and axiomatic semantics for non-determinism and sequence points in C
Fresh-register automata
Handling declared information leakage: extended abstract
Bias-variance tradeoffs in program analysis
Distributed Data Structures in Linda
Monads in action
A Fast and Usually Linear Algorithm for Global Flow Analysis
A Finite Presentation Theorem for Approximating Logic Programs
Linear dependent types for differential privacy
New results on the computability and complexity of points - to analysis
A Staging Calculus and its Application to the Verification of Translators
On the Decision Problems of Program Schemas with Commutative and Invertable Functions
A Calculus of Higher Order Communicating Systems
Deciding ML Typability is Complete for Deterministic Exponential Time
Sacrificing Simplicity for Convenience: Where Do You Draw the Line?
Types, bytes, and separation logic
Programming up to Congruence
Proceedings of the 42nd Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL 2015, Mumbai, India, January 15-17, 2015
State-dependent representation independence
Relating Models of Polymorphism
Local rely-guarantee reasoning
Formal Specification as a Design Tool
Interaction Nets
Reflection and Semantics in Lisp
Higher-Order Modules and the Phase Distinction
High-Level Language Facilities for Low-Level Services
Lifting abstract interpreters to quantified logical domains
Polymorphic Type Inference
Frame rules from answer types for code pointers
Stateful manifest contracts
A Forward Move Algorithm for LR Error Recovery
Semantics for Concurrency without Powerdomains