yusuke1997/dblp-id-title huggingface dataset:
Empirical Language Analysis in Software Linguistics
Monadification of attribute grammars
Guided Merging of Sequence Diagrams
Aspect-Oriented Language Mechanisms for Component Binding
Method and Tool Support for Classifying Software Languages with Wikipedia
Spectrum-based fault localization for context-free grammars
Methodology as Theories in Business Informatics
Concurrent circular reference attribute grammars
A Role-Based Approach towards Modular Language Engineering
AIOCJ: A Choreographic Framework for Safe Adaptive Distributed Applications
Deep priority conflicts in the wild: a pilot study
Test-Data Generation for Xtext - Tool Paper
Declarative Scripting in Haskell
Variability Support in Domain-Specific Language Development
Temporal Constraint Support for OCL
Graphical Template Language for Transformation Synthesis
Reconstructing Complex Metamodel Evolution
ScalaQL: Language-Integrated Database Queries for Scala
Towards an Incremental Update Approach for Concrete Textual Syntaxes for UUID-Based Model Repositories
Efficient model partitioning for distributed model transformations
Dynamic Scope Discovery for Model Transformations
Simple, Efficient, Sound and Complete Combinator Parsing for All Context-Free Grammars, Using an Oracle
Analyzing Rule-Based Behavioral Semantics of Visual Modeling Languages with Maude
Developing a monadic type checker for an object-oriented language: an experience report
Layout-Sensitive Generalized Parsing
Model-Driven Engineering Meets Generic Language Technology
Trellis: A Domain-Specific Language for Hidden Markov Models with Sparse Transitions
Formalizing a Domain Specific Language Using SOS: An Industrial Case Study
Symbolic execution of high-level transformations
Model Transformation Co-evolution: A Semi-automatic Approach
An Executable Semantics for Faster Development of Optimizing Python Compilers
Proceedings of the 2015 ACM SIGPLAN International Conference on Software Language Engineering, SLE 2015, Pittsburgh, PA, USA, October 25-27, 2015
Automated Co-evolution of GMF Editor Models
VML* - A Family of Languages for Variability Management in Software Product Lines
Engineering Languages for Specifying Product-Derivation Processes in Software Product Lines
Multiple lexicalisation (a Java based study)
A domain-specific controlled English language for automated regulatory compliance (industrial paper)
Grammar-based testing for little languages: an experience report with student compilers
A vision of miking: interactive programmatic modeling, sound language composition, and self-learning compilation
DrAST: an inspection tool for attributed syntax trees (tool demo)
Reflection as a Tool to Debug Objects
Extrinsically typed operational semantics for functional languages
JTL: A Bidirectional and Change Propagating Transformation Language
Trieste: A C++ DSL for Flexible Tree Rewriting
Towards a universal code formatter through machine learning
Towards the optical character recognition of DSLs
A Metamodel Family for Role-Based Modeling and Programming Languages
Integrating Attribute Grammar and Functional Programming Language Features
Robust programs with filtered iterators
Taming context-sensitive languages with principled stateful parsing
Streamlining Control Flow Graph Construction with DCFlow
iCoLa: A Compositional Meta-language with Support for Incremental Language Development
AnyText: Incremental, left-recursive Parsing and Pretty-Printing from a single Grammar Definition with first-class LSP support
Meta-language Support for Type-Safe Access to External Resources
An Automated Process for Implementing Multilevel Domain Models
Sudoku - A Language Description Case Study
fUML as an Assembly Language for Model Transformation
A Low-Code Platform for Systematic Component-Oriented Language Composition
BSML-mbeddr: integrating semantically configurable state-machine models in a C programming environment
Exploratory, Omniscient, and Multiverse Diagnostics in Debuggers for Non-Deterministic Languages
Variability Fault Localization by Abstract Interpretation and its Application to SPL Repair
Neon: A Library for Language Usage Analysis
Execution framework of the GEMOC studio (tool demo)
A Language for Software Variation Research
MoScript: A DSL for Querying and Manipulating Model Repositories
A practical type system for safe aliasing
Whiley: A Platform for Research in Software Verification
Domain-Specific Modelling Languages with Algebraic Graph Transformations on RDF
Nanopass Attribute Grammars
Raincode assembler compiler (tool demo)
A Model-driven Approach for the Analysis of Multimedia Document
Software Language Engineering, 5th International Conference, SLE 2012, Dresden, Germany, September 26-28, 2012, Revised Selected Papers
Analysis and modeling of the governance in general programming languages
Micro-Machinations - A DSL for Game Economies
Enabling Blended Modelling of Timing and Variability in EAST-ADL
Experiences of models@run-time with EMF and CDO
Termination Analysis for Higher-Order Attribute Grammars
Array programming in pascal
Static analysis of Java enterprise applications: frameworks and caches, the elephants in the room
Numerical static analysis with Soot
Lazy counterfactual symbolic execution
Steal Tree: low-overhead tracing of work stealing schedulers
A microkernel virtual machine: : building security with clear interfaces
Proceedings of the 8th ACM SIGPLAN International Workshop on State Of the Art in Program Analysis, SOAP@PLDI 2019, Phoenix, AZ, USA, June 22, 2019
Proceedings of the 12th ACM SIGPLAN International Workshop on the State Of the Art in Program Analysis, SOAP 2023, Orlando, FL, USA, 17 June 2023
Proceedings of the ACM SIGPLAN'95 Conference on Programming Language Design and Implementation (PLDI), La Jolla, California, USA, June 18-21, 1995
Proceedings of the 2010 Workshop on Programming Languages and Analysis for Security, PLAS 2010, Toronto, ON, Canada, 10 June, 2010
A Language for Writing Code Generators
Turning manual concurrent memory reclamation into automatic reference counting
Generating bug-fixes using pretrained transformers
Heap Profiling for Space-Efficient Java
Facile: A Language and Compiler for High-Performance Processor Simulators
Demanded abstract interpretation
GPGPU Composition with OCaml
Proceedings of the 2010 ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI 2010, Toronto, Ontario, Canada, June 5-10, 2010
Gluon: a communication-optimizing substrate for distributed heterogeneous graph analytics
Replay For Concurrent Non-Deterministic Shared Memory Applications
Faceted execution of policy-agnostic programs
Code placement for improving dynamic branch prediction accuracy
Integration of QoS-Enabled Distributed Object Computing Middleware for Developing Next-Generation Distributed Application
A programming model for deterministic task parallelism
On the Importance of Points-to Analysis and Other Memory Disambiguation Methods for C Programs
Calling-to-reference context translation via constraint-guided CFL-reachability
Soot-based implementation of a demand-driven reaching definitions analysis
Synthesis of ranking functions using extremal counterexamples
Low-latency, high-throughput garbage collection
Incrementalized Pointer and Escape Analysis
Call-Cost Directed Register Allocation
Efficient computation of LALR(1) look-ahead sets (with retrospective)
Systematic editing: generating program transformations from an example
InvokeDynamic support in Soot
Evaluating and Optimizing Thread Pool Strategies for Real-Time CORBA
On loops, dominators, and dominance frontier
Dynamic path-based software watermarking
Combining type-based analysis and model checking for finding counterexamples against non-interference
Synthesizing parallel graph programs via automated planning
Exterminator: automatically correcting memory errors with high probability
Fusing convolution kernels through tiling
Verification of producer-consumer synchronization in GPU programs
Rethinking Soot for summary-based whole-program analysis
Type error feedback via analytic program repair
Getting F-bounded polymorphism into shape
Occurences in Debugger Specifications
Counting Solutions to Presburger Formulas: How and Why
Proceedings of the ACM SIGPLAN 2004 Conference on Programming Language Design and Implementation 2004, Washington, DC, USA, June 9-11, 2004
Idle time garbage collection scheduling
Robustness certification with generative models
Efficient Procedure Mapping Using Cache Line Coloring
A dynamic program analysis to find floating-point accuracy problems
ESP: Path-Sensitive Program Verification in Polynomial Time
Composing High-Performance Memory Allocators
SMAT: an input adaptive auto-tuner for sparse matrix-vector multiplication
A design and verification methodology for secure isolated regions
Proceedings of the ACM SIGPLAN Workshop on X10, Portland, OR, USA, June 15 - 17, 2015
Orbit: an optimizing compiler for scheme (with retrospective)
On-stack replacement, distilled
SemCluster: clustering of imperative programming assignments based on quantitative semantic features
Verifying that web pages have accessible layout
Algorithmic debugging of real-world haskell programs: deriving dependencies from the cost centre stack
A global progressive register allocator
Profile-Guided Code Compression
Invasive computing in HPC with X10
Doppio: breaking the browser language barrier
Computing correctly with inductive relations
Design of an interpretive environment for Turing
RaceInjector: Injecting Races to Evaluate and Learn Dynamic Race Detection Algorithms
FreezeML: complete and easy type inference for first-class polymorphism
Synthesizing memory models from framework sketches and Litmus tests
Execution reconstruction: harnessing failure reoccurrences for failure reproduction
Lightweight computation tree tracing for lazy functional languages
Fast Code Generation Using Automatically-Generated Decision Trees
Related Field Analysis
Efficient synthesis of probabilistic programs
Parameterized tiled loops for free
ARRAY '22: 8th ACM SIGPLAN International Workshop on Libraries, Languages and Compilers for Array Programming, San Diego CA USA, 13 June 2022
Linear analysis and optimization of stream programs
Generators and the Replicator Control Structures in the Parallel Environment of ALLOY
A general path-based representation for predicting program properties
Algorithmic profiling
Learning fast and precise numerical analysis
Dynamic space limits for Haskell
Jedd: a BDD-based relational extension of Java
The Embedded Machine: Predictable, Portable Real-Time Code
Improving program locality in the GC using hotness
Putting in all the stops: execution control for JavaScript
Space efficient conservative garbage collection (with retrospective)
Information flow security of multi-threaded distributed programs
Privacy-aware proof-carrying authorization
Data-trace types for distributed stream processing systems
A New Algorithm for Scalar Register Promotion based on SSA Form
Effective Partial Redundancy Elimination
Security completeness: towards noninterference in composed languages
Filling typed holes with live GUIs
Porting doop to Soufflé: a tale of inter-engine portability for Datalog-based analyses
A context-free markup language for semi-structured text
Programming by sketching for bit-streaming programs
Fast, Effective Dynamic Compilation
Parallelism orchestration using DoPE: the degree of parallelism executive
Ownership types for safe region-based memory management in real-time Java
Staged information flow for javascript
A security domain model to assess software for exploitable covert channels
Parallel scan as a multidimensional array problem
VeriPhy: verified controller executables from verified cyber-physical system models
Scalable context-sensitive flow analysis using instantiation constraints
Interprocedural Side Effect Analysis With Pointer Aliasing
Fast breakpoints: design and implementation (with retrospective)
Scalable verification of probabilistic networks
Fast and precise hybrid type inference for JavaScript
Evaluating value-graph translation validation for LLVM
Full functional verification of linked data structures
Bounds Checking: An Instance of Hybrid Analysis
Toward generating reducible replay logs
A software product line for static analyses: the OPAL framework
Proactive and adaptive energy-aware programming with mixed typechecking
A serializability violation detector for shared-memory server programs
Efficient Detection of All Pointer and Array Access Errors
Reconciling exhaustive pattern matching with objects
Generalized just-in-time trace compilation using a parallel task farm in a dynamic binary translator
The three pillars of machine programming
Complete removal of redundant expressions (with retrospective)
Scaling abstraction refinement via pruning
HipHop.js: (A)Synchronous reactive web programming
Panthera: holistic memory management for big data processing over hybrid memories
VLIW Compilation Techniques in a Superscalar Environment
Optimization of x10 programs with ROSE compiler infrastructure
Proceedings of the 2nd ACM SIGPLAN International Workshop on State Of the Art in Java Program analysis, SOAP 2013, Seattle, WA, USA, June 20, 2013
Certified self-modifying code
Ariadne: analysis for machine learning programs
Huron: hybrid false sharing detection and repair
Automating formal proofs for reactive systems
Register Promotion by Partial Redundancy Elimination of Loads and Stores
Partial Online Cycle Elimination in Inclusion Constraint Graphs
Compiler and runtime support for efficient software transactional memory
Programmatic and direct manipulation, together at last
Profile guided code positioning (with retrospective)
Co-dfns: Ancient Language, Modern Compiler
Natural proofs for structure, data, and separation
Deriving Specialized Program Analyses for Certifying Component-Client Conformance
An ELI-to-C compiler: design, implementation, and performance
Register Allocation via Clique Separators
Effective automatic parallelization of stencil computations
Proceedings of the Symposium on Interpreters and Interpretive Techniques, 1987, St. Paul, Minnesota, USA, June 24 - 26, 1987
A Piggy-back Compiler For Prolog
A New Approach to Debugging Optimized Code
A new perspective on processing-in-memory architecture design
Verifying concurrent search structure templates
Stochastic optimization of floating-point programs with tunable precision
It's alive! continuous feedback in UI programming
Cost effective dynamic program slicing
Verified lifting of stencil computations
Deterministic parallelism via liquid effects
Productivity assessment of neural code completion
Simple Objects for Standard ML
Making context-sensitive points-to analysis with heap cloning practical for the real world
Register allocation and spilling via graph coloring (with retrospective)
Generalized Dominance and Control Dependence
Precise and compact modular procedure summaries for heap manipulating programs
SDNRacer: concurrency analysis for software-defined networks
Profile-driven energy reduction in network-on-chips
A Fast Fourier Transform Compiler
Outlawing ghosts: avoiding out-of-thin-air results
A single intermediate language that supports multiple implementations of exceptions
High-level synthesis of functional patterns with Lift
Islaris: verification of machine code against authoritative ISA semantics
Gen: a general-purpose probabilistic programming system with programmable inference
On abstraction refinement for program analyses in Datalog
Mining hot calling contexts in small space
Safe optimisations for shared-memory concurrent programs
Zero-cost Range Splitting
Guaranteed bounds for posterior inference in universal probabilistic programming
Interprocedural Slicing Using Dependence Graphs
Model-driven transformations for multi- and many-core CPUs
Cache rationing for multicore
Lazy Code Motion
Compositional solution space quantification for probabilistic software analysis
Better Static Memory Management: Improving Region-Based Analysis of Higher-Order Languages
Combining E-Graphs with Abstract Interpretation
Commutativity Analysis: A New Analysis Framework for Parallelizing Compilers
ENSEMBLE: A Communication Layer for Embedded Multi-Processor Systems
Relocating Machine Instructions by Currying
Understanding and detecting real-world performance bugs
Unqomp: synthesizing uncomputation in Quantum circuits
Sound, complete and scalable path-sensitive analysis
Static Analysis of Data Transformations in Jupyter Notebooks
Link-Time Optimization of Address Calculation on a 64-bit Architecture
The reachability-bound problem
TACAI: an intermediate representation based on abstract interpretation
Denali: A Goal-directed Superoptimizer
Relaxing SIMD Control Flow Constraints using Loop Transformations
Lightweight, flexible object-oriented generics
Design, Implementation and Evaluation of the FNC-2 Attribute Grammar System
Dominator-tree analysis for distributed authorization
Parser-directed fuzzing
Alive2: bounded translation validation for LLVM
CompCertO: compiling certified open C components
Software Pipelining: An Effective Scheduling Technique for VLIW Machines
Phased synthesis of divide and conquer programs
Static array storage optimization in MATLAB
A practical flow-sensitive and context-sensitive C and C++ memory leak detector
Enhancing computation-to-core assignment with physical location information
On the unsoundness of static analysis for Android GUIs
Progressive polynomial approximations for fast correctly rounded math libraries
SootDiff: bytecode comparison across different Java compilers
Improving compiler scalability: optimizing large programs at small price
Certifying low-level programs with hardware interrupts and preemptive threads
Celebrating diversity: a mixture of experts approach for runtime mapping in dynamic environments
PLDI '22: 43rd ACM SIGPLAN International Conference on Programming Language Design and Implementation, San Diego, CA, USA, June 13 - 17, 2022
Lazy Functional State Threads
First steps to compiling Matlab to X10
An overview of the PL.8 compiler (with retrospective)
Handling Control
Armada: low-effort verification of high-performance concurrent programs
PLDI '21: 42nd ACM SIGPLAN International Conference on Programming Language Design and Implementation, Virtual Event, Canada, June 20-25, 2021
Halide: a language and compiler for optimizing parallelism, locality, and recomputation in image processing pipelines
On-The-Fly Detection of Access Anomalies
Globally precise-restartable execution of parallel programs
Flow-directed Inlining
Practical memory leak detection using guarded value-flow analysis
Middleware For Building Adaptive Systems Via Configuration
Race checking by context inference
A study of the learnability of relational properties: model counting meets machine learning (MCML)
DieHard: probabilistic memory safety for unsafe languages
Odin: on-demand instrumentation with on-the-fly recompilation
Automated atomicity-violation fixing
Predicting program behavior using real or estimated profiles (with retrospective)
Finding the dwarf: recovering precise types from WebAssembly binaries
DreamCoder: bootstrapping inductive program synthesis with wake-sleep library learning
Register Allocation with Instruction Scheduling: A New Approach
Inner array inlining for structure of arrays layout
Off-line variable substitution for scaling points-to analysis
Composable, sound transformations of nested recursion and loops
JANUS: exploiting parallelism via hindsight
Cyclic program synthesis
Semantic program alignment for equivalence checking
Interpreter-guided differential JIT compiler unit testing
Parametric Timing Analysis
Parallel Compilation for a Parallel Machine
Efficient Accomodation of May-Alias Information in SSA Form
Real-time concurrent collection on stock multiprocessors (with retrospective)
Orchestrating the execution of stream programs on multicore platforms
The Design of a Class Mechanism for Moby
Dynamo: a transparent dynamic optimization system
Improved spill code generation for software pipelined loops
Large-scale configurable static analysis
Improving Cache Performance in Dynamic Applications through Data and Computation Reorganization at Run Time
Using Integer Sets for Data-Parallel Program Analysis and Optimization
Compile-time dynamic voltage scaling settings: opportunities and limits
A general constraint-centric scheduling framework for spatial architectures
Program analysis for reversible languages
Scalable statistical bug isolation
A model counter for constraints over unbounded strings
Program synthesis using conflict-driven learning
Translation validation for a verified OS kernel
Goldilocks: a race and transaction-aware java runtime
Concolic program repair
Trash in cache: detecting eternally silent stores
Exact and approximate methods for proving unrealizability of syntax-guided synthesis problems
Balancing register allocation across threads for a multithreaded network processor
Automatic generation of efficient sparse tensor format conversion routines
Fine-grain Multithreading with Minimal Compiler Support - A Cost Effective Approach to Implementing Efficient Multithreading Languages
A retrospective on: "customization: optimizing compiler technology for self, a dynamically-typed object-oriented programming language" (with retrospective)
Resugaring: lifting evaluation sequences through syntactic sugar
Register Windows versus Register Allocation
Predictive data locality optimization for higher-order tensor computations
CARE, the comprehensive archiver for reproducible execution
Profile-Directed Optimization of Event-Based Programs
Static Single Assignment Form for machine Code
Static error detection using semantic inconsistency inference
Practicing JUDO: Java under dynamic optimizations
Achieving high coverage for floating-point code via unconstrained programming
Circular Scheduling: A New Technique to Perform Software Pipelining
Probabilistic programming with programmable inference
Unleashing the hidden power of compiler optimization on binary code difference: an empirical study
Provable repair of deep neural networks
Towards a holistic approach to auto-parallelization: integrating profile-driven parallelism detection and machine-learning based mapping
Fast: a transducer-based language for tree manipulation
Compiling KB-sized machine learning models to tiny IoT devices
Lagrange multipliers and maximum information leakage in different observational models
The Program Structure Tree: Computing Control Regions in Linear Time
Complete completion using types and weights
Declarative programming over eventually consistent data stores
Ensuring determinism in blockchain software with GoLiSA: an industrial experience report
Verifying higher-order programs with the dijkstra monad
Differential privacy with information flow control
Modular array-based GPU computing in a dynamically-typed language
How to combine widening and narrowing for non-monotonic systems of equations
A practical automatic polyhedral parallelizer and locality optimizer
A New Framework for Exhaustive and Incremental Data Flow Analysis Using DJ Graphs
Debugging temporal specifications with concept analysis
Points-to analysis using BDDs
Chianina: an evolving graph system for flow- and context-sensitive analyses of million lines of C code
Resolving and exploiting the k -CFA paradox: illuminating functional vs. object-oriented program analysis
On inter-procedural analysis of programs with lists and data
Compiling without continuations
FlashRelate: extracting relational data from semi-structured spreadsheets using examples
Optimization and abstraction: a synergistic approach for analyzing neural network robustness
Polyhedra scanning revisited
ExeBench: an ML-scale dataset of executable C functions
CacheQuery: learning replacement policies from hardware caches
Design space exploration of memory model for heterogeneous computing
Array Operators Using Multiple Dispatch: A design methodology for array implementations in dynamic languages
Size-change termination as a contract: dynamically and statically enforcing termination for higher-order programs
An applied quantum Hoare logic
Dynamic slicing with soot
Landmarks and regions: a robust approach to data extraction
Sound sequentialization for concurrent program verification
An inductive synthesis framework for verifiable reinforcement learning