Under-approximation for Scalable Bug Detection
Explore under-approximation techniques for efficient bug detection in large codebases. Learn about Incorrectness Logic, ISL, and Pulse-X for scalable, compositional program analysis and memory safety error detection.
PfComp: A Verified Compiler for Packet Filtering Leveraging Binary Decision Diagrams
Explore PfComp, a verified compiler for stateless firewall policies using binary decision diagrams. Learn about its Coq-assisted proof, OCaml extraction, and performance benefits.
Retrofitting Null-Safety into Java
Explore Nullsafe, a compiler plugin extending Java's type system with nullness, reducing NullPointerExceptions in production code at Meta through large-scale transformation.
asai: A Library for Compiler Diagnostics
Explore asai, an OCaml library for enhancing compiler diagnostics in proof assistants, improving error messages for end users.
Type Inference for Application Spines in Higher-Order Languages - WITS'24
Explore type inference for application spines in Haskell, covering error messages, impredicative polymorphism, visible type application, and required type arguments.
Solving Constraints During Type Inference - WITS'24
Explore GHC's type inference engine, covering bidirectional inference, implication constraints, level numbers, evidence generation, and quantified constraints in Haskell.
The Evolution of Effects in Functional Programming - From Monads to Higher-Order Effects
Explore the evolution of effectful programming in Haskell, from monads to higher-order effects, examining key milestones and their impact on functional programming paradigms.
Consider Collaboration - Importance and Strategies in Research
Discover the importance of collaboration in research, learn how to initiate partnerships, overcome challenges, and achieve success in joint projects.
Unified Compositional Symbolic Execution - N40AI'24
Explore unified compositional symbolic execution techniques for program analysis, enhancing software reliability and performance optimization.
Trust but Verify: Scaling Deductive Verification with Abstract Interpretation - N40AI'24
Explore scaling deductive verification for smart contracts using abstract interpretation. Learn about pointer analysis algorithms, program simplifications, and challenges in low-level code analysis.
Program Synthesis via Bi-directional Reduced-product Abstract Interpretation - N40AI'24
Explore bi-directional reduced-product abstract interpretation for inductive program synthesis, focusing on example-based techniques and their application to bit-manipulation programs.
Quantum Abstract Interpretation
Explore quantum abstract interpretation for efficient verification of large-scale quantum programs, overcoming simulation limitations and enabling assertion checks for up to 300 qubits.
What is a WebAssembly Component and Why - WAW'24
Explore the WebAssembly Component Model proposal, its motivations, technical design, and upcoming releases for cross-language, portable module development.
Generating Executable Specification from Formal Semantics of WebAssembly
Explore automatic generation of algorithmic artifacts from WebAssembly's formal semantics using a domain-specific language, streamlining the standardization process for new features.
WALI: A Thin Linux Kernel Interface for WebAssembly
Explore WALI, a thin layer enabling WebAssembly to interact seamlessly with Linux systems, enhancing application portability and security while leveraging existing compiler backends.
Object Capabilities - Principles and Applications
Explore object capabilities in programming languages, focusing on security, encapsulation, and access control mechanisms for robust software design.
A Comparison of Program Logics for (In)Correctness
Explore program logics for correctness and incorrectness, comparing over- and under-approximation techniques. Analyze Sufficient Incorrectness Logic and its Separation Logic variant for dynamic heap management.
Incremental Analysis in Infer
Explore Infer's incremental analysis infrastructure, addressing technical challenges and future developments for faster program analysis in large codebases.
Lineage: A Data-Flow Analysis for Erlang
Explore a novel data-flow analysis for Erlang, producing over-approximating dataflow graphs for efficient taint checking in large-scale codebases.
Flux: Refinement Types for Rust
Explore refinement types for Rust with Flux, enhancing code safety and expressiveness in systems programming.
Learning to Boost Disjunctive Static Bug-Finders
Explore a novel learning-based strategy for disjunctive static bug-finders, addressing challenges in state-selection heuristics and improving efficiency in real-world program analysis.