yusuke1997/dblp-id-title huggingface dataset:
Unified Management of Registers and Cache Using Liveness and Cache Bypass
Interprocedural Constant Propagation: A Study of Jump Function Implementations
SLING: using dynamic analysis to infer program invariants in separation logic
The nesC language: A holistic approach to networked embedded systems
I Know It When I See It: Observable Races in JavaScript Applications
Hybrid Run-time Power Management Technique for Real-time Embedded System with Voltage Scalable Processor
Quantitative information flow as network flow capacity
Issues in the Design of Adaptive Middleware Load Balancing
Semantic type qualifiers
Social processes and proofs of theorems and programs, revisited
Provably correct peephole optimizations with alive
Efficient compilation of lazy evaluation (with retrospective)
Refinement-based context-sensitive points-to analysis for Java
Software in reproducible research: advice and best practice collected from experiences at the collaborations workshop
Deep and shallow types for gradual languages
BigFoot: static check placement for dynamic race detection
The liberty structural specification language: a high-level modeling language for component reuse
Preventing glitches and short circuits in high-level self-timed chip specifications
Proving data-poisoning robustness in decision trees
Automatic pool allocation: improving performance by controlling data structure layout in the heap
Binary rewriting without control flow recovery
Verified validation of lazy code motion
Automatic Generation of Global Optimizers
High performance correctly rounded math libraries for 32-bit floating point representations
Steno: automatic optimization of declarative queries
The University of Washington Illustrating Compiler
Learning stateful preconditions modulo a test generator
Feedback directed optimization of TCMalloc
From Datalog to flix: a declarative language for fixed points on lattices
Introducing kernel-level page reuse for high performance computing
Line-up: a complete and automatic linearizability checker
Rely-guarantee references for refinement types over aliased mutable data
Sequential reasoning for optimizing compilers under weak memory concurrency
Alive-Infer: data-driven precondition inference for peephole optimizations in LLVM
GUESSTIMATE: a programming model for collaborative distributed systems
Active learning of points-to specifications
Speculative linearizability
Discovering properties about arrays in simple programs
Supporting speculative parallelization in the presence of dynamic data structures
Lightweight multi-language syntax transformation with parser parser combinators
An Efficient Approach to Data Flow Analysis in a Multi Pass Global Optimizer
Proceedings of the 2000 ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI), Vancouver, Britith Columbia, Canada, June 18-21, 2000
A flexible type system for fearless concurrency
Relatively complete counterexamples for higher-order programs
Automatic parallelization via matrix multiplication
Heartbeat scheduling: provable efficiency for nested parallelism
Partial Dead Code Elimination using Slicing Transformations
Principled Scavenging
A study of data structures with a deep heap shape
A provably sound TAL for back-end optimization
Compiling APL to accelerate through a typed array intermediate language
Proceedings of the ACM SIGPLAN'93 Conference on Programming Language Design and Implementation (PLDI), Albuquerque, New Mexico, USA, June 23-25, 1993
Register allocation by puzzle solving
Adversarial memory for detecting destructive races
Automatic instruction scheduler retargeting by reverse-engineering
Proceedings of the 3rd ACM SIGPLAN International Workshop on the State Of the Art in Java Program analysis, SOAP 2014, Edinburgh, UK, Co-located with PLDI 2014, June 12, 2014
Control-flow refinement and progress invariants for bound analysis
AutoPersist: an easy-to-use Java NVM framework based on reachability
Simplification of Array Access Patterns for Compiler Optimizations
Proceedings of the 1999 ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI), Atlanta, Georgia, USA, May 1-4, 1999
Can reactive synthesis and syntax-guided synthesis be friends?
Register Allocation Across Procedure and Module Boundaries
PMEvo: portable inference of port mappings for out-of-order processors by evolutionary optimization
CONCURRIT: a domain specific language for reproducing concurrency bugs
The LRPD Test: Speculative Run-Time Parallelization of Loops with Privatization and Reduction Parallelization
Programming languages in security: keynote
Atomicity refinement for verified compilation
LaminarIR: compile-time queues for structured streams
A Study of Dead Data Members in C++ Applications
Empirical relation between coupling and attackability in software systems: : a case study on DOS
Parallelism, persistence and meta-cleanliness in the symmetric Lisp interpreter
Gleipnir: toward practical error analysis for Quantum programs
Example-guided synthesis of relational queries
A cost-driven compilation framework for speculative parallelization of sequential programs
Memory allocation and higher-order functions
Extending C++ with co-array semantics
Behavioral simulation for smart contracts
Proving a core code for FDM correct by 2 + dw tests
Linear-Time, Optimal Code Scheduling for Delayed-Load Architectures
Velociraptor: a compiler toolkit for array-based languages targeting CPUs and GPUs
Bidirectional type checking for relational properties
Adore: atomic distributed objects with certified reconfiguration
Value and allocation sensitivity in static Python analyses
Viaduct: an extensible, optimizing compiler for secure distributed programs
Fast searches for effective optimization phase sequences
Static Debugging: Browsing the Web of Program Invariants
Effective padding of multidimensional arrays to avoid cache conflict misses
Efficient and precise points-to analysis: modeling the heap by merging equivalent automata
Optimizing Dynamically-Dispatched Calls with Run-Time Type Feedback
Resource-guided program synthesis
Locality analysis through static parallel sampling
Advice to Authors of Extended Abstracts
Hashing modulo alpha-equivalence
TeIL: a type-safe imperative tensor intermediate language
Automated synthesis of symbolic instruction encodings from I/O samples
Automatic design and implementation of language data types
Automated clustering and program repair for introductory programming assignments
CheckFence: checking consistency of concurrent data types on relaxed memory models
Proceedings of the 2011 ACM SIGPLAN workshop on Memory Systems Performance and Correctness: held in conjunction with PLDI '11, San Jose, CA, USA, June 5, 2011
Characterising renaming within OCaml's module system: theory and implementation
Adventures in commercial-grade static analysis (keynote)
Proceedings of the ACM SIGPLAN'92 Conference on Programming Language Design and Implementation (PLDI), San Francisco, California, USA, June 17-19, 1992
Tree dependence analysis
Proceedings of the 2011 Workshop on Programming Languages and Analysis for Security, PLAS 2011, San Jose, CA, USA, 5 June, 2011
Inferring type rules for syntactic sugar
Concurrent libraries with foresight
Reactive probabilistic programming
Dynamic Software Updating
Learning quantitative representation synthesis
Verified compilation on a verified processor
Modularity for decidability of deductive verification with applications to distributed systems
Bug isolation via remote program sampling
Control structure overloading in X10
DART: directed automated random testing
Static specification inference using predicate mining
Fast and flexible instruction selection with on-demand tree-parsing automata
Type Analysis of Prolog Using Type Graphs
DUA-forensics: a fine-grained dependence analysis and instrumentation framework based on Soot
Separation logic + superposition calculus = heap theorem prover
Toward generalized tensor algebra for ab initio quantum chemistry methods
Ultra-fast Aliasing Analysis using CLA: A Million Lines of C Code in a Second
Verification of semantic commutativity conditions and inverse operations on linked data structures
gprof: a call graph execution profiler (with retrospective)
A theory of changes for higher-order languages: incrementalizing λ-calculi by static differentiation
Promises: Linguistic Support for Efficient Asynchronous Procedure Calls in Distributed Systems
Automated conformance testing for JavaScript engines via deep compiler fuzzing
Distributed parallel computing with Futhark: a functional language to generate distributed parallel code
Interprocedural Side-Effect Analysis in Linear Time
Avoiding Conditional Branches by Code Replication
P4BID: information flow control in p4
Sound and precise analysis of parallel programs through schedule specialization
Static Load Classification for Improving the Value Predictability of Data-Cache Misses
Automatic Inference of Models for Statistical Code Compression
Type-directed scheduling of streaming accelerators
Decomposition instead of self-composition for proving the absence of timing channels
Debugging at Full Speed
Extended Static Checking for Java
Incremental Generation of Parsers
Proceedings of the 6th ACM SIGPLAN Symposium on Scala, Scala@PLDI 2015, Portland, OR, USA, June 15-17, 2015
Eliminating Branches using a Superoptimizer and the GNU C Compiler
CEAL: a C-based language for self-adjusting computation
Accelerating search-based program synthesis using learned probabilistic models
Fast, Effective Code Generation in a Just-In-Time Java Compiler
Caching function calls using precise dependencies
Morphable Cache Architectures: Potential Benefits
Combining type-analysis with points-to analysis for analyzing Java library source-code
Proceedings of the 4th ACM SIGPLAN International Workshop on Libraries, Languages, and Compilers for Array Programming, ARRAY@PLDI 2017, Barcelona, Spain, June 18, 2017
Proceedings of the 1st ACM SIGPLAN International Workshop on Machine Learning and Programming Languages, MAPL@PLDI 2017, Barcelona, Spain, June 18, 2017
Compiler and runtime support for continuation marks
Stuck in the Middle: Challenges and Trends in Optimizing Middleware
Refinement Types for ML
Distributed programming in Scala with APGAS
Languages as libraries
Compiling a Subset of APL Into a Typed Intermediate Language
Parallelizing sequential applications on commodity hardware using a low-cost software transactional memory
LLHD: a multi-level intermediate representation for hardware description languages
Effective Sign Extension Elimination
Interprocedural slicing using dependence graphs (with retrospective)
Liquid types
Generational Garbage Collection and the Radioactive Decay Model
Proceedings of the 5th ACM SIGPLAN International Workshop on State Of the Art in Program Analysis, SOAP@PLDI 2016, Santa Barbara, CA, USA, June 14, 2016
Combining abstract interpreters
Simple and precise static analysis of untrusted Linux kernel extensions
Brainy: effective selection of data structures
AKG: automatic kernel generation for neural processing units using polyhedral transformations
Efficient program execution indexing
Automatically improving accuracy for floating point expressions
An automatic object inlining optimization and its evaluation
Memory Management with Explicit Regions
Taming undefined behavior in LLVM
Profile Guided Code Positioning
Maya: Multiple-Dispatch Syntax Extension in Java
Dexpler: converting Android Dalvik bytecode to Jimple for static analysis with Soot
The type inference and coercion facilities in the scratchpad II interpreter
Scannerless NSLR(1) Parsing of Programming Languages
Synthesizing highly expressive SQL queries from input-output examples
Dynamic Hot Data Stream Prefetching for General-Purpose Programs
Cloning-based context-sensitive pointer alias analysis using binary decision diagrams
Exploiting the commutativity lattice
Stateless model checking concurrent programs with maximal causality reduction
Probabilistic, modular and scalable inference of typestate specifications
Adoption and Focus: Practical Linear Types for Imperative Programming
Proceedings of the 4th ACM SIGPLAN International Workshop on State Of the Art in Program Analysis, SOAP@PLDI 2015, Portland, OR, USA, June 15 - 17, 2015
Proving non-termination by program reversal
Replication-aware linearizability
Coverage-directed differential testing of JVM implementations
An efficient interpreter for Datalog by de-specializing relations
CCG: A Prototype Coagulating Code Generator
Combinatory logic and combinators in array languages
Design and implementation of sparse global analyses for C-like languages
Choosing mathematical function implementations for speed and accuracy
Reasoning about Continuations with Control Effects
A GPGPU compiler for memory optimization and parallelism management
Fault-tolerant typed assembly language
Templates and recurrences: better together
Procedure Merging with Instruction Caches
ARRAY 2021: Proceedings of the 7th ACM SIGPLAN International Workshop on Libraries, Languages and Compilers for Array Programming, Virtual Event, Canada, 21 June, 2021
Mechanized verification of fine-grained concurrent programs
A compiler-based infrastructure for software-protection
A type system for data-flow integrity on windows vista
Proving almost-sure termination by omega-regular decomposition
Monitoring refinement via symbolic reasoning
Almost-correct specifications: a modular semantic framework for assigning confidence to warnings
Tracelet-based code search in executables
Flow-Sensitive Type Qualifiers
Loop Transformations for Architectures with Partitioned Register Banks
BlankIt library debloating: getting what you want instead of cutting what you don't
To-many or to-one? all-in-one! efficient purely functional multi-maps with type-heterogeneous hash-tries
Verdi: a framework for implementing and formally verifying distributed systems
Dyna: toward a self-optimizing declarative language for machine learning applications
SPL: A Language and Compiler for DSP Algorithms
Two for the Price of One: Composing Partial Evaluation and Compilation
Typed Lua: An Optional Type System for Lua
Proceedings of the 3rd ACM SIGPLAN International Workshop on Machine Learning and Programming Languages, MAPL@PLDI 2019, Phoenix, AZ, USA, June 22, 2019
Deriving linearizable fine-grained concurrent objects
Data-parallel flattening by expansion
Proceedings of the 4th ACM SIGPLAN International Workshop on Machine Learning and Programming Languages, MAPL@PLDI 2020, London, UK, June 15, 2020
WEBLOG: a declarative language for secure web development
Finite-Static Code Generation
Verifying safety properties using separation and heterogeneous abstractions
Improving JavaScript performance by deconstructing the type system
Efficient interpretation of synchronizable series expressions
A Methodology for Managing Hard Constraints in CLP Systems
Fast Copy Coalescing and Live-Range Identification
Fixpoint reuse for incremental JavaScript analysis
Sparse computation data dependence simplification for efficient compiler-generated inspectors
Identifying the Semantic and Textual Differences Between Two Versions of a Program
Iterative optimization in the polyhedral model: part ii, multidimensional time
Selective Specialization for Object-Oriented Languages
A Theory of Type Qualifiers
The Implementation and Evaluation of Fusion and Contraction in Array Languages
Combining the logical and the probabilistic in program analysis
Question selection for interactive program synthesis
Hybrid top-down and bottom-up interprocedural analysis
Garbage collection for monitoring parametric properties
Kremlin: rethinking and rebooting gprof for the multicore age
Static Detection of Dynamic Memory Errors
Optimizing ML with Run-Time Code Generation
Simulating midlet's security claims with automata modulo theory
Chameleon: adaptive selection of collections
A personal perspective on concurrency
Language and Compiler Support for Adaptive Distributed Applications
Optimistic parallelism requires abstractions
Attack model for verification of interval security properties for smart card C codes
Reverse If-Conversion
A simpler, safer programming and execution model for intermittent systems
Scalable validation of binary lifters
Stratified synthesis: automatically learning the x86-64 instruction set
Trace-based control-flow analysis
Automatic runtime error repair and containment via recovery shepherding
A New Algorithm for Partial Redundancy Elimination based on SSA Form
On the construction of soundness oracles
Finding low-utility data structures
Position paper: the science of boxing
Control CPR: A Branch Height Reduction Optimization for EPIC Architectures
From functional to imperative: combining destination-passing style and views
Accelerating sequential consistency for Java with speculative compilation
Mesh: compacting memory management for C/C++ applications
Precise, dynamic information flow for database-backed applications
Merlin: specification inference for explicit information flow problems
On the Structure of Verifiable Code Generator Specifications
MAPS@PLDI 2022: 6th ACM SIGPLAN International Symposium on Machine Programming, San Diego, CA, USA, 13 June 2022
Main memory and cache performance of intel sandy bridge and AMD bulldozer
Cooperation vs. coordination for lifeline-based global load balancing in APGAS
Towards an efficient fault-tolerance scheme for GLB
Gillian, part i: a multi-language platform for symbolic execution
Hamband: RDMA replicated data types
Efficient Incremental Run-Time Specialization for Free
Proceedings of the 41st ACM SIGPLAN International Conference on Programming Language Design and Implementation, PLDI 2020, London, UK, June 15-20, 2020
Rematerialization
Generational Reference Counting: A Reduced-Communication Distributed Storage Reclamation Scheme
Higher-order test generation
End-to-end verification of information-flow security for C and assembly programs
Better extensibility through modular syntax
Automated feedback generation for introductory programming assignments
There is nothing wrong with out-of-thin-air: compiler optimization and memory models
Incremental inference for probabilistic programs
Interprocedural Dataflow Analysis in an Executable Optimizer
SootKeeper: runtime reusability for modular static analysis
Efficient static analysis of XML paths and types
How to read floating point numbers accurately (with retrospective)
OCSEGen: open components and systems environment generator
Type-level computations for Ruby libraries
Central moment analysis for cost accumulators in probabilistic programs
Anatomy of a Hardware Compiler
Proceedings of the 37th ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI 2016, Santa Barbara, CA, USA, June 13-17, 2016
Æminium: a permission based concurrent-by-default programming language approach
Sound probabilistic inference via guide types
Using targeted symbolic execution for reducing false-positives in dataflow analysis
Partial-coherence abstractions for relaxed memory models
The case for JavaScript transactions: position paper
Demand-Driven Pointer Analysis
Towards an implementation of differential dynamic logic in PVS
Efficient type inference for secure information flow
NV: an intermediate language for verification of network control planes
CCAL: An interpreted language for experimentation in concurrent control
A Fresh Look at Optimizing Array Bound Checking
Efficient instruction scheduling for a pipelined architecture (with retrospective)
Autoscheduling for sparse tensor algebra with an asymptotic cost model
Repairing sequential consistency in C/C++11
Security-policy monitoring and enforcement with JavaMOP
Inferring crypto API rules from code changes
Using Annotation to Reduce Dynamic Optimization Time
Automated error diagnosis using abductive inference
Verified peephole optimizations for CompCert
Canary: practical static detection of inter-thread value-flow bugs
The implicit calculus: a new foundation for generic programming
What exactly is inexact computation good for?
Conditional correlation analysis for safe region-based memory management
An SSA-based algorithm for optimal speculative code motion under an execution profile
Branch Prediction For Free
Predicting whole-program locality through reuse distance analysis
Distributed garbage collection
Optimization of range checking (with retrospective)
Graph Coloring Register Allocation for Processors with Multi-Register Operands
TTC: a tensor transposition compiler for multiple architectures
Accepting blame for safe tunneled exceptions
Perceus: garbage free reference counting with reuse
Mostly-automated verification of low-level programs in computational separation logic
Compressing Java Class Files
An Implementation for Complete, Asynchronous, Distributed Garbage Collection
Proceedings of the 39th ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI 2018, Philadelphia, PA, USA, June 18-22, 2018
Consolidation of queries with user-defined functions
Global register allocation at link time (with retrospective)
Finite difference methods fengshui: alignment through a mathematics of arrays
Automatic compilation of MATLAB programs for synergistic execution on heterogeneous processors
Isolating and understanding concurrency errors using reconstructed execution fragments
Systematic black-box analysis of collaborative web applications
Approximating inclusion-based points-to analysis
First-class runtime generation of high-performance types using exotypes
Higher-Order Attribute Grammars
When threads meet events: efficient and precise static race detection with origins
Sparse record and replay with controlled scheduling
Regularly annotated set constraints
Debugging and detecting numerical errors in computation with posits
Verifying bit-manipulations of floating-point
Dataflow analysis for concurrent programs using datarace detection
Evaluating iterative optimization across 1000 datasets
Traceable data types for self-adjusting computation
Data representation synthesis
Asynchronous programming, analysis and testing with state machines
How to print floating-point numbers accurately (with retrospective)
Evaluating the cost reduction of static code analysis for software security
On Predicting the Impact of Resource Redistributions in Streaming Applications
Securing nonintrusive web encryption through information flow
Community-driven reviewing and validation of publications
Search, align, and repair: data-driven feedback generation for introductory programming exercises
Diderot: a parallel DSL for image analysis and visualization
Knowledge inference for optimizing secure multi-party computation
Automatically learning shape specifications
Linear algebraic depth-first search
Compile-time composition of run-time data and iteration reorderings
Generalizations of the theory and deployment of triangular inequality for compiler-based strength reduction
Instruction Reordering for Fork-Join Parallelism
Low-synchronization, mostly lock-free, elastic scheduling for streaming runtimes
Asynchronous functional reactive programming for GUIs
LL(*): the foundation of the ANTLR parser generator
Practical dynamic software updating for C
A distributed OpenCL framework using redundant computation and data replication
Generating Decision Trees for Decoding Binaries
Vectorized secure evaluation of decision forests
Optimal inference of fields in row-polymorphic records
Support for Garbage Collection at Every Instruction in a Java Compiler
Test-driven synthesis
Polyhedral auto-transformation with no integer linear programming
Toward efficient gradual typing for structural types via coercions
Improving Register Allocation for Subscripted Variables
Power-Aware Design Synthesis Techniques for Distributed Real-Time Systems
A tool for simulation and fast prototyping of embedded control systems
AutoSynch: an automatic-signal monitor based on predicate tagging
Strictness and Binding-Time Analyses: Two for the Price of One
Compiler validation via equivalence modulo inputs
Surgical precision JIT compilers
The key to a data parallel compiler
Typed closure conversion for the calculus of constructions
A New Framework for Debugging Globally Optimized Code
Accelerating information experts through compiler design
Retrofitting effect handlers onto OCaml
Optimizing memory transactions