Gradual Typing and Verification - Session Preview
Explore gradual typing and verification techniques in programming languages with Ronald Garcia's preview of the POPL'24 session.
Sound Gradual Verification with Symbolic Execution
Explore sound gradual verification using symbolic execution techniques. Learn about optimized run-time check generation and its implementation in verification tools.
On-The-Fly Static Analysis via Dynamic Bidirected Dyck Reachability
Explore a novel dynamic algorithm for bidirected Dyck reachability, optimizing on-the-fly static analysis with superior performance and efficiency for continuous code updates.
Unboxed Data Constructors: Efficient and Safe Big Number Handling in ML Languages
Explore unboxed data constructors in ML languages, enhancing efficiency without compromising safety. Learn static analysis techniques and their implementation in OCaml, including termination detection algorithms.
Indexed Types for a Statically Safe WebAssembly - POPL 2024
Explore Wasm-prechk, a WebAssembly extension using indexed types for enhanced static safety. Learn about performance gains, type safety proofs, and implementation trade-offs in this innovative approach.
Flan: An Expressive and Efficient Datalog Compiler for Program Analysis
Explore Flan, a Datalog compiler embedded in Scala that combines expressiveness and performance for program analysis, offering powerful extensions and specialized code generation.
An Intrinsically Typed Compiler for Algebraic Effect Handlers
Explore type-preserving compilation for algebraic effect handlers, focusing on safety in continuation capture and resumption using stack polymorphism in an Agda-implemented compiler.
Fluid: Towards Transparent, Self-Explanatory Research Outputs
Explore Fluid, a transparent programming language with bidirectional dynamic dependency analysis, enabling interactive exploration of data relationships in research outputs.
Derivative Based Nonbacktracking Real-World Regex Matching with Backtracking Semantics
Explore a new derivative-based theory and algorithm for nonbacktracking regex matching, supporting anchors and counting while preserving backtracking semantics. Implemented in .NET7 with formal proof of correctness.
Indexed Streams - A Formal Intermediate Representation for Fused Contraction Programs
Explore a formal operational model for fused execution of contraction languages, covering sparse tensor and relational algebra. Learn about indexed streams and their compiler implementation.
Fuzzing Loop Optimizations in Compilers for C++ and Data-Parallel Languages
Explore advanced compiler testing techniques for loop optimizations in C++ and data-parallel languages. Learn about YARPGen's reimplementation, static undefined behavior avoidance, and loop code diversity mechanisms.
Cutting the Cake: A Language for Fair Division
Explore Slice, a domain-specific language for fair division protocols. Learn how it converts programs to logical formulas, enabling automated verification of envy-freeness in resource allocation scenarios.
Iris-Wasm: Robust and Modular Verification of WebAssembly Programs
Explore robust and modular verification of WebAssembly programs using Iris-Wasm, a mechanized higher-order separation logic for specifying and verifying individual modules with strong isolation guarantees.
Repairing Regular Expressions for Extraction
Explore a novel method for synthesizing and repairing regular expressions for extraction, addressing challenges with real-world extensions and deterministic behavior of regex engines.
Feature-Sensitive Coverage for Conformance Testing of Programming Language Implementations
Explore novel coverage criteria for generating high-quality conformance tests in programming language implementations, focusing on feature-sensitive and feature-call-path-sensitive approaches.
Recursive State Machine Guided Graph Folding for Context-Free Language Reachability
Explore an innovative approach to improve CFL-reachability scalability through graph folding, reducing input size and enhancing performance in program analysis applications like alias and value-flow analysis.
Flux: Liquid Types for Rust
Explore Flux, a refined type system for Rust that enhances verification of low-level pointer programs. Learn how it combines logical refinements with Rust's ownership mechanisms for efficient and ergonomic type-based verification.
Taype: A Policy-Agnostic Language for Oblivious Computation
Explore Taype, a novel language for secure multiparty computation that decouples security policies from program logic. Learn about oblivious algebraic data types and tape semantics for flexible, policy-agnostic development.
WasmRef-Isabelle: A Verified Monadic Interpreter and Industrial Fuzzing Oracle for WebAssembly
Explore a verified monadic interpreter for WebAssembly, its adoption as a fuzzing oracle, and its performance compared to other interpreters and oracles.
Obtaining Information Leakage Bounds via Approximate Model Counting
Explore a sound symbolic quantitative information flow analysis for bounding information leakage in programs using approximate model counting and symbolic execution.
Covering All the Bases: Type-Based Verification of Test Input Generators
Explore a novel type-based verification method for validating coverage in test input generators, enhancing property-based testing with underapproximate reasoning and refinement types.