yusuke1997/dblp-id-title huggingface dataset:
Transformations and Reduction Strategies for Typed Lambda Expressions
Automatic discovery of covariant read-only fields
An APL Compiler for a Vector Processor
The Chemical Approach to Typestate-Oriented Programming
Symbolic Analysis for Parallelizing Compilers
Algorithms for On-the-fly Garbage Collection
On loops, dominators, and dominance frontiers
Type-preserving compilation of Featherweight Java
Editorial: A changing of the guard
The Tortoise and the Hare Algorithm for Finite Lists, Compositionally
The Activity of a Variable and Its Relation to Decision Trees
Syntactic type abstraction
A proof theory for machine code
Herding Cats: Modelling, Simulation, Testing, and Data Mining for Weak Memory
A Generalized Theory of Bit Vector Data Flow Analysis
Bottom-up shape analysis using LISF
Morphing: Structurally shaping a class by reflecting on others
Calculational semantics: Deriving programming theories from equations by functional predicate calculus
On Subtyping-Relation Completeness, with an Application to Iso-Recursive Types
Dynamic Deadlock Verification for General Barrier Synchronisation
Affix Grammar Driven Code Generation
Tichy's Response to R. W. Schwanke and G. E. Kaiser's "Smarter Recompilation"
Demand-Driven Register Allocation
Escape analysis for Java TM : Theory and practice
Nomadic pict: Programming languages, communication infrastructure overlays, and semantics for mobile computation
Type Representation of Objects by Functions
Techniques for the Translation of MATLAB Programs into Fortran 90
Search Direction by Goal Failure in Goal-Directed Programming
Sequent calculi and abstract machines
A Dynamic Continuation-Passing Style for Dynamic Delimited Continuations
A practical and fast iterative algorithm for phi-function computation using DJ graphs
Generalized Points-to Graphs: A Precise and Scalable Abstraction for Points-to Analysis
The Design and Implementation of a Verification Technique for GPU Kernels
R/ for Semantics
Backtracking in a Generalized Control Setting
Modal Crash Types for WAR-Aware Intermittent Computing
Automatic Derivation of Code Generators from Machine Descriptions
Dynamic Typing for Distributed Programming in Polymorphic Languages
Applicability of Software Validation Techniques to Scientific Programs
Extending Type Inference to Variational Programs
Dependence clusters in source code
Techniques for Debugging Parallel Programs with Flowback Analysis
A new foundation for control dependence and slicing for modern program structures
Stack allocation and synchronization optimizations for Java using escape analysis
Model checking of hierarchical state machines
Featherweight Java: a minimal core calculus for Java and GJ
Comments on Soisalon-Soininen's "Inessential Error Entries"
Automated data-member layout of help objects to improve memory-hierarchy performance
Making the java memory model safe
Smarter Recompilation
Capturing Types
Optimizing Homomorphic Evaluation Circuits by Program Synthesis and Time-bounded Exhaustive Search
Rank 2 intersection types for local definitions and conditional expressions
METRIC: Memory tracing via dynamic binary rewriting to identify cache inefficiencies
XARK: An extensible framework for automatic recognition of computational kernels
Compositional Specification and Verification of Distributed Systems
Design and evaluation of dynamic optimizations for a Java just-in-time compiler
A Logical Approach to Deciding Semantic Subtyping
Efficient field-sensitive pointer analysis of C
Modular Termination Verification of Single-Threaded and Multithreaded Programs
Linear scan register allocation
Circal and the Representation of Communication, Concurrency, and Time
Limits and Difficulties in the Design of Under-Approximation Abstract Domains
Type Inference with Polymorphic Recursion
(De/Re)-Composition of Data-Parallel Computations via Multi-Dimensional Homomorphisms
A Directly Executable Encoding for APL
Efficient Algorithms for Automatic Construction and Compactification of Parsing Grammars
The KaffeOS Java runtime system
The pattern calculus
Cross-Language Interoperability in a Multi-Language Runtime
An Old-Fashined Recipe for Real-Time
Polymorphic Type Inference and Abstract Data Types
Verified interoperable implementations of security protocols
Fast Strictness Analysis Based on Demand Propagation
Software Merge: Semantics of Combining Changes to Programs
Introduction to the Special Issue on ESOP 2021
Interprocedural Context-Unbounded Program Analysis Using Observation Sequences
A Mathematical Approach to Nondeterminism in Data Types
The Geometry of Semaphore Programs
Compilation of Acyclic Smooth Programs for Parallel Execution
ACE: An Automatic Complexity Evaluator
Static Backward Slicing of Non-deterministic Programs and Systems
WYSINWYX: What you see is not what you eXecute
Higher-Order Distributed Objects
Incremental Generation of Lexical Scanners
Parallel execution of prolog programs: a survey
When do bounds and domain propagation lead to the same search space?
Compositional Parallel Programming Languages
Mixin' Up the ML Module System
A Scheduling Framework for Spatial Architectures Across Multiple Constraint-Solving Theories
Algorithms for Algebraic Path Properties in Concurrent Systems of Constant Treewidth Components
JavaCOP: Declarative pluggable types for java
Will It Fit? Verifying Heap Space Bounds of Concurrent Programs under Garbage Collection
The receptive distributed pi-calculus
Describing and Analyzing Distributed Software System Designs
Modular refinement of hierarchic reactive machines
Determinacy Testing for Nondeterminate Logic Programming Languages
Optimal Prepaging and Font Caching
An Improved Storage Management Scheme for Block Structured Languages
On minimizing materializations of array-valued temporaries
Completeness and Complexity of Reasoning about Call-by-Value in Hoare Logic
Retargetable Microcode Synthesis
Undecidability of context-sensitive data-independence analysis
Polymorphic predicate abstraction
The Concurrency Workbench: A Semantics-Based Tool for the Verification of Concurrent Systems
Handling irreducible loops: optimized node splitting versus DJ-graphs
Efficient Computation of LALR(1) Look-Ahead Sets
Denotational Abstract Interpretation of Logic Programs
On the Use of Regular Expressions for Searching Text
Tailored-List and Recombination-Delaying Buddy Systems
An Extended Account of Trace-relating Compiler Correctness and Secure Compilation
Introduction to special ESOP'05 issue
Dealing with incomplete knowledge on CLP( FD ) variable domains
Finite Differencing of Computable Expressions
Introduction to the Special Section on ESOP 2020
Polymorphic typing of Variables and References
Nesting of Reducible and Irreducible Loops
A Fresh Look at Zones and Octagons
An Evaluation of an Automatically Generated Compiler
Derivation of Invariant Assertions During Program Development by Transformation
Semantic foundations for typed assembly languages
Synthesis of concurrent programs for an atomic read/write model of computation
Faster Algorithms for Dynamic Algebraic Queries in Basic RSMs with Constant Treewidth
An improved bound for call strings based interprocedural analysis of bit vector frameworks
Right nulled GLR parsers
Controlled Grammatic Ambiguity
Equality-based flow analysis versus recursive types
Program termination analysis in polynomial time
The Definition of Dependence Distance
Proving Liveness for Networks of Communicating Finite State Machines
Pure Versus Impure Lisp
A Formal System for Reasoning about Programs Accessing a Relational Database
A Correctness Proof for Combinator Reduction with Cycles
Leader Election in Uniform Rings
Pretty printing with lazy dequeues
Java bytecode verification via static single assignment form
Securing Interruptible Enclaved Execution on Small Microprocessors
Closure Analysis in Constraint Form
Relations as an abstraction for BDD-based program analysis
Specifying Representations of Machine Instructions
Control Predicates are Better than Dummy Variables for Reasoning about Program Control
Controlling garbage collection and heap growth to reduce the execution time of Java applications
Type Inference for C: Applications to the Static Analysis of Incomplete Programs
Combining Algebraic and Algorithmic Reasoning: An Approach to the Schorr-Waite Algorithm
A Practical Method for LR and LL Syntactic Error Diagnosis
Armada: Automated Verification of Concurrent Code with Sound Semantic Extensibility
Secure Compilation to Protected Module Architectures
An Alternative to the Use of Patterns in String Processing
Two Parametricities Versus Three Universal Types
Implementation of Resilient, Atomic Data Types
A data-centric approach to synchronization
Typed memory management via static capabilities
Constraint-Based Array Dependence Analysis
Program transformations using temporal logic side conditions
A Weaker Precondition for Loops
Access control for mobile agents: The calculus of boxed ambients
Types for safe locking: Static race detection for Java
A type system equivalent to a model checker
Lightweight Closure Conversion
A Type Discipline for Message Passing Parallel Programs
Epochs
On Iterative Constructs
Symboloc Model Checking for Event-Driven Real-Time Systems
Procedures as Persistent Data Objects
Focusing on Refinement Typing
The Evaluation of Expressions in Icon
Type Extensions
Newtonian Program Analysis via Tensor Product
Efficient Implementation of Lattice Operations
Program Transformations in a Denotational Setting
Natural semantics as a static program analysis framework
Generating object lifetime traces with Merlin
External Representations of Objects of User-Defined Type
Interactive Abstract Interpretation with Demanded Summarization
Bisimulation for Quantum Processes
Size-change termination with difference constraints
Some Comments on ''A Solution to a Problem with Morel and Renvoise's 'Global Optimization by Suppression of Partial Redundancies'
An assume-guarantee rule for checking simulation
A Fast Algorithm for Finding Dominators in a Flowgraph
Compilation of Functional Languages by Program Transformation
A Multiprocessing Approach to Compile-Time Symbol Resolution
Incremental analysis of constraint logic programs
Side Effects and Aliasing Can Have Simple Axiomatic Descriptions
A Note on Hennessy's "Symbolic Debugging of Optimized Code"
Jump Minimization in Linear Time
Clarification of "Feeding Inputs on Demand" in Efficient Demand-Driven Evaluation - Part 1
Verifying Custom Synchronization Constructs Using Higher-Order Separation Logic
Proof-Directed Parallelization Synthesis by Separation Logic
Global Sparse Analysis Framework
Fairness in Parallel Programs: The Transformational Approach
Ten Years of Hoare's Logic: A Survey - Part 1
User Recovery and Reversal in Interactive Systems
A New Approach to Proving the Correctness of Multiprocess Programs
Formal Verification of an SSA-Based Middle-End for CompCert
Fast online pointer analysis
Type Reconstruction in the Presence of Polymorphic Recursion
Enforcing resource bounds via static verification of dynamic checks
Passport: Improving Automated Formal Verification Using Identifiers
Verification of Array, Record, and Pointer Operations in Pascal
Efficient Implementation of the First-Fit Strategy for Dynamic Storage Allocation
Reasoning about Grover's quantum search algorithm using probabilistic wp
The Type Theory of PL/CV3
Use of a Nonprocedural Specification Language and Associated Program Generator in Software Development
Parsing and Compiling Using Prolog
A Systematic Study of Functional Language Implementations
Deferring design pattern decisions and automating structural pattern changes using a design-pattern-based programming system
The computational power and complexity of constraint handling rules
A Derivative-based Parser Generator for Visibly Pushdown Grammars
Handling Operator Precedence in Arithmetic Expressions with Tree Transformations
Compositional Programming
Fast Graph Simplification for Interleaved-Dyck Reachability
The Drinking Philosopher's Problem
The Programming Language Aspects of ThingLab, a Constraint-Oriented Simulation Laboratory
User Format Control in a Lisp Prettyprinter
Nonsequentiality and Concrete Activity Phases in Discrete-Event Simulation Languages
Compiler-Driven Software Speculation for Thread-Level Parallelism
First-class monadic schedules
Modeling the Distributed Termination Convention of CSP
"Maximal-munch" Tokenization in Linear Time
Table Compression for Tree Automata
Practical Fine-Grained Information Flow Control Using Laminar
Postpass Code Optimization of Pipeline Constraints
Writing Larch Interface Language Specifications
Generators in Icon
Error Data Values in the Data-Flow Language VAL
An automata-theortetic approach to modular model checking
Polynomial Bounds of CFLOBDDs against BDDs
Using Dataflow Analysis Techniques to Reduce Ownership Overhead in Cache Coherence Protocols
Robustly Safe Compilation, an Efficient Form of Secure Compilation
Language Support for the Specification and Development of Composite Systems
Linking Programs Incrementally
Exploiting Partially Context-sensitive Profiles to Improve Performance of Hot Code
Inferring Lower Runtime Bounds for Integer Programs
An Abstract Interpretation-Based Model of Tracing Just-in-Time Compilation
Scaling Reliably: Improving the Scalability of the Erlang Distributed Actor Platform
SHErrLoc: A Static Holistic Error Locator
Using types to analyze and optimize object-oriented programs
Polymorphic Splitting: An Effective Polyvariant Flow Analysis
Hierarchical modularity
Efficient Computation of Interprocedural Definition-Use Chains
Evidence-Based Static Branch Prediction Using Machine Learning
The Truth, The Whole Truth, and Nothing But the Truth: A Pragmatic Guide to Assessing Empirical Evaluations
Æminium: A Permission-Based Concurrent-by-Default Programming Language Approach
LOCKSMITH: Practical static race detection for C
Semantics of fractional permissions with nesting
Pattern-Based Verification for Multithreaded Programs
A theory of contracts for Web services
Collecting Interpretations of Expressions
Integrating object-oriented programming and protected objects in Ada 95
Analysis of Functional Programs to Detect Run-Time Garbage Cells
Send-receive considered harmful: Myths and realities of message passing
Parallel Programming with Control Abstraction
Modern concurrency abstractions for C#
Procedure placement using temporal-ordering information
A Note on Cohen's "Eliminating Redundant Recursive Calls"
Finite differencing of logical formulas for static analysis
Utilizing Symmetry when Model-Checking under Fairness Assumptions: An Automata-Theoretic Approach
Effectivness of Abstract Interpretation in Automatic Parallelization: A Case Study in Logic Programming
Parallel Generation of Postfix and Tree Forms
Deep Dive into ZGC: A Modern Garbage Collector in OpenJDK
An algebraic array shape inference system for MATLAB
Optimizing memory usage in the polyhedral model
A calculus for uniform feature composition
A Note on "On the Conversion of Indirect to Direct Recursion"
Logic of global synchrony
A Note on the Drinking Philosophers Problem
A Natural Semantics for Eiffel Dynamic Binding
The Temporal Logic of Actions
A Programming Language for Data Privacy with Accuracy Estimations
Types for atomicity: Static checking and inference for Java
Real-Time Synchronization of Interprocess Communications
Specifying Concurrent Program Modules
Proving Correctness of Parallel Implementations of Transition System Models
A hybrid type system for lock-freedom of mobile processes
On the Adequacy of Graph Rewriting for Simulating Term Rewriting
Synchronization in Distributed Programs
Repairing syntax errors in LR parsers
A Relational Program Logic with Data Abstraction and Dynamic Framing
Automatic Transformation of Series Expressions into Loops
Link-time binary rewriting techniques for program compaction
Global Analysis of Constraint Logic Programs
A Hierarchial Approach to Formal Semantics With Application to the Definition of PL/CS
Practical Subtyping for Curry-Style Languages
Encapsulation Constructs in Systems Programming Languages
Comparing conservative coalescing criteria
Lazy Scheduling: A Runtime Adaptive Scheduler for Declarative Parallelism
Rethinking Incremental and Parallel Pointer Analysis
Optimization of Functional Programs by Grammar Thinning
A New Framework for Elimination-Based Data Flow Analysis Using DJ Graphs
Interprocedural parallelization analysis in SUIF
Variant parametric types: A flexible subtyping scheme for generics
On the origins of bisimulation and coinduction
Optimal Evaluation of Array Expressions on Massively Parallel Machines
Creating User Interfaces Using Programming by Example, Visual Programming, and Constraints
Interprocedural slicing of multithreaded programs with applications to Java
Functional Computations in Logic Programs
Proving Systolic Systems Correct
Slicing as a program transformation
Universal Composability Is Robust Compilation
Grammar-Based Definition of Metaprogramming Systems
Reverse-mode AD in a functional framework: Lambda the ultimate backpropagator
Automatic Translation of Fortran Programs to Vector Form
Prophecy Made Simple
Automatic Storage Optimization for Arrays
Programming with Equations
Avoidance and Suppression of Compensation Code in a Trace Scheduling Compiler
A Linear-Time Scheme for Version Reconstruction
A Cost Model for the Internal Organization of B+-Tree Nodes
A Region Inference Algorithm
Influence of Cross-Interferences on Blocked Loops: A Case Study with Matric-Vector Multiply
More dynamic object reclassification: Fickle ||
Refinement types for secure implementations
An Approach for Exploring Code-Improving Transformations
Introduction to the Special Issue on ESOP 2018
Mobile safe ambients
Automatic tiling of iterative stencil loops
On the (non-) Relationship between SLR(1) and NQLALR(1) Grammars
The trace partitioning abstract domain
Process Communication Based on Input Specifications
ScalaExtrap: Trace-based communication extrapolation for SPMD programs
Static Inference of Modes and Data Dependencies in Logic Programs
Ultracomputers
Message analysis for concurrent programs using message passing
Efficient Java RMI for parallel programming
Compiling language definitions: the ASF+SDF compiler
Some Techniques for Recursion Removal from Recursive Programs
Graph rewrite systems for program optimization
Implicit dynamic frames
The Construction of Stack-Controlling LR Parsers for Regular Right Part Grammars
Generation of Compiler Symbol Processing Mechanisms
Efficient Demand-Driven Evaluation - Part 2
Semiring-based contstraint logic programming: syntax and semantics
Transactional Sapphire: Lessons in High-Performance, On-the-fly Garbage Collection
POP-PL: A Patient-Oriented Prescription Programming Language
How to Securely Replicate Services
Dependent Type Theory for Verification of Information Flow and Access Control Policies
TeraHeap : Exploiting Flash Storage for Mitigating DRAM Pressure in Managed Big Data Frameworks
Satin: A high-level and efficient grid programming model
Efficiently Computing Static Single Assignment Form and the Control Dependence Graph
Practical Adaptation of the Global Optimization Algorithm of Morel and Renvoise
Efficient Instruction Scheduling for Delayed-Load Architectures
Conversion from Data-Driven to Synchronous Execution in Loop Programs
On contract satisfaction in a higher-order world
The Design and Formalization of Mezzo, a Permission-Based Programming Language
Heap reference analysis using access graphs
Efficient and Correct Execution of Parallel Programs that Share Memory
Combining Analyses, Combining Optimizations
Adding Fair Choice to Dijkstra's Calculus
Scheduling time-constrained instructions on pipelined processors
Bit-Precise Procedure-Modular Termination Analysis
On Failure of the Pruning Technique in "Error Repair in Shift-Reduce Parsers"
Don't Sit on the Fence: A Static Analysis Approach to Automatic Fence Insertion
Efficient Counting Program Events with Support for On-Line Queries
CHAD: Combinatory Homomorphic Automatic Differentiation
Proving Failure-Free Properties of Concurrent Systems Using Temporal Logic
The Concurrent Language, Shared Prolog
Using Peephole Optimization on Intermediate Code
Global Data Flow Analysis Problems Arising in Locally Least-Cost Error Recovery
Efficient dynamic dispatching with type slicing
Code Selection through Object Code Optimization
Cache miss equations: a compiler framework for analyzing and tuning memory behavior
Partial Evaluation of Functional Logic Programs
Some Observations Concerning Formal Differentiation of Set Theoretic Expressions
Gradual C0: Symbolic Execution for Gradual Verification
Supporting Dynamic Data Structures on Distributed-Memory Machines
Local Atomicity Properties: Modular Concurrency Control for Abstract Data Types
Reply to "Subtypes and Quantification"
Toward Compiler Implementation Correctness Proofs
Eliminating synchronization bottlenecks using adaptive replication
Automatic Generation and Use of Abstract Structure Operators
PEAK - a fast and effective performance tuning system via compiler optimization orchestration
A Modular Verifiable Exception-Handling Mechanism
Optimizing aggregate array computations in loops
System Semantics: Principles, Applications, and Implementation
Term transformers: A new approach to state
Programs from Proofs: A Framework for the Safe Execution of Untrusted Software
Two Issues in Parallel Language Design
Specifying the Semantics of while Programs: A Tutorial and Critique of a Paper by Hoare and Lauer
Distributed Termination
Solving systems of rational equations through strategy iteration
Goal-directed weakening of abstract interpretation results
Stack inspection: Theory and variants
A Theory of Synchronous Relational Interfaces
Efficient Fault-Tolerant Algorithms for Distributed Resource Allocation
Applicative Caching
Generation of LR parsers by partial evaluation
The embedded machine: Predictable, portable real-time code
An accurate cost model for guiding data locality transformations
Expressive and modular predicate dispatch for Java
Extending Java for high-level Web service construction
Error Repair in Shift-Reduce Parsers
An Object-Based Programming Model for Shared Data
Exploiting reference idempotency to reduce speculative storage overflow
On the Optimality of Change Propagation for Incremental Evaluation of Hierarchical Attribute Grammars
On Time-sensitive Control Dependencies
Functional declarative language design and predicate calculus: a practical approach
A machine-checked model for a Java-like language, virtual machine, and compiler
A Machine-Learning Algorithm with Disjunctive Model for Data-Driven Program Analysis
BI-hyperdoctrines, higher-order separation logic, and abstraction
Perfect hashing as an almost perfect subtype test
CFLOBDDs: Context-Free-Language Ordered Binary Decision Diagrams
A framework for call graph construction algorithms
Experimental Results from Dynamic Slicing of C Program
Partially Evaluating Finite-State Runtime Monitors Ahead of Time
Parameterized loop tiling
Compile-time memory reuse in logic programming languages through update in place
A Stepwise Refinement Heuristic for Protocol Construction
Active Learning for Inference and Regeneration of Applications that Access Databases
The Design and Application of a Retargetable Peephole Optimizer
Dually nondeterministic functions
A Correction to the Denotational Semantics for the Prolog of Nicholson and Foo
Partial redundancy elimination in SSA form
Java bytecode compression for low-end embedded systems
Symmetry and reduced symmetry in model checking
A practical interprocedural dominance algorithm
A fast and accurate framework to analyze and optimize cache memory behavior
Specificational functions
Essential AOP: The a calculus
FeatherTrait: A modest extension of Featherweight Java
A Generalization of Dijkstra's Calculus
Beyond Induction Variables: Detecting and Classifying Sequences Using a Demand-Driven SSA
Making Graphs Reducible with Controlled Node Splitting
Addendum to "The Promotion and Accumulation Strategies in Transformational Programming"
A constraint-based approach to guarded algebraic data types
Ranking and Repulsing Supermartingales for Reachability in Randomized Programs
Specialization Slicing
Register tiling in nonrectangular iteration spaces