OOPSLA 2019
73 papers
- A fault-tolerant programming model for distributed interactive applications
- A formalization of Java's concurrent access modes
- A path to DOT: formalizing fully path-dependent types
- AL: autogenerating supervised learning programs
- ApproxHPVM: a portable compiler IR for accuracy-aware optimizations
- Aroma: code recommendation via structural code search
- Asphalion: trustworthy shielding against Byzantine faults
- AutoPandas: neural-backed generators for program synthesis
- Automatic and scalable detection of logical errors in functional programming assignments
- Automatic repair of regular expressions
- BDA: practical dependence analysis for binary executables by unbiased whole-program path sampling and per-path abstract interpretation
- CLOTHO: directed test generation for weakly consistent database systems
- Casting about in the dark: an empirical study of cast operations in Java programs
- Certifying graph-manipulating C programs via localizations within data structures
- Compiler fuzzing: how much does it matter?
- Complete monitors for gradual types
- Coverage guided, property based testing
- DProf: distributed profiler with strong guarantees
- DeepSEA: a language for certified system software
- Dependence-aware, unbounded sound predictive race detection
- Derivative grammars: a symbolic approach to parsing with derivatives
- Design, implementation, and application of GPU-based Java bytecode interpreters
- Detecting nondeterministic payment bugs in Ethereum smart contracts
- Duet: an expressive higher-order language and linear type system for statically enforcing differential privacy
- Effective lock handling in stateless model checking
- Efficient lock-free durable sets
- Formal foundations of serverless computing
- FuzzFactory: domain-specific fuzzing with waypoints
- Generating a fluent API with syntax checking from an LR grammar
- Generating precise error specifications for C: a zero shot learning approach
- Getafix: learning to fix bugs automatically
- I/O dependent idempotence bugs in intermittent systems
- IVT: an efficient method for sharing subtype polymorphic objects
- Improving bug detection via context-based code representation learning and attention-based neural networks
- Initialize once, start fast: application initialization at build time
- IntelliMerge: a refactoring-aware software merging technique
- Language-integrated privacy-aware distributed queries
- Leveraging rust types for modular specification and verification
- Mergeable replicated data types
- Modular verification for almost-sure termination of probabilistic programs
- Modular verification of heap reachability properties in separation logic
- Modular verification of web page layout
- On the complexity of checking transactional consistency
- On the design, implementation, and use of laziness in R
- On the fly synthesis of edit suggestions
- Optimal stateless model checking for reads-from equivalence under sequential consistency
- Optimization of swift protocols
- PlanAlyzer: assessing threats to the validity of online experiments
- Precise reasoning with structured time, structured heaps, and collective operations
- Precision-preserving yet fast object-sensitive pointer analysis with partial context sensitivity
- Probabilistic verification of fairness properties via concentration
- Program synthesis with algebraic library specifications
- Qubit allocation as a combination of subgraph isomorphism and token swapping
- Refinement kinds: type-safe programming with practical type-level computation
- Reflection-aware static regression test selection
- Relational verification using reinforcement learning
- Reliable and fast DWARF-based stack unwinding
- Ryū revisited: printf floating point conversion
- Safer smart contract programming with Scilla
- Scala implicits are everywhere: a large-scale study of the use of Scala implicits in the wild
- Seq: a high-performance language for bioinformatics
- Sound and reusable components for abstract interpretation
- Specification and inference of trace refinement relations
- Specifying concurrent programs in separation logic: morphisms and simulations
- Staged abstract interpreters: fast and modular whole-program analysis via meta-programming
- Static analysis with demand-driven value refinement
- System FR: formalized foundations for the stainless verifier
- TLA+ model checking made symbolic
- Trace aware random testing for distributed systems
- Value-centric dynamic partial order reduction
- Verifying safety and accuracy of approximate parallel programs via canonical sequentialization
- Weak persistency semantics from the ground up: formalising the persistency semantics of ARMv8 and transactional models
- Weakening WebAssembly