Program Verification for the Linux Kernel - Potential Costs and Benefits
Explore potential costs and benefits of program verification for the Linux kernel, gaining insights into its impact on development and reliability.
Auto-detecting Sleeping Lock Calls in Non-preemptible Context via Static Analysis
Explore techniques for automatically detecting sleeping lock calls in non-preemptible contexts using static analysis methods in Linux kernel development.
Lazy Abstraction Refinement with Proof for an Enhanced Verifier
Explore advanced techniques in software verification using lazy abstraction refinement with proof, enhancing verifier capabilities for improved code analysis.
Code Analysis at WhatsApp - Keynote
Explore WhatsApp's code analysis tools, dynamic and static analysis techniques, and their integration into software development lifecycles.
The Design and Implementation of an Abstract Interpreter for OCaml Programs - A Preliminary Report on the Salto Analyser
Explore the design and implementation of Salto, a static analyzer for OCaml programs using abstract interpretation to detect exceptions and undefined behaviors.
How I Learned to Stop Worrying and Love Dynamic Languages
Explore insights on dynamic languages from a seasoned researcher's perspective, covering successful strategies in research, advising, and project leadership.
Totally Live Programming with Hazel - Progress Report
Explore Hazel, a groundbreaking live programming environment with error localization and recovery mechanisms, ensuring well-structured and meaningful code at every stage.
Latte: Lightweight Aliasing Tracking for Java
Explore Latte, a lightweight system for tracking aliasing and uniqueness in Java, minimizing annotations and complexity while supporting destructive reads and practical applications.
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.
asai: A Library for Compiler Diagnostics
Explore asai, an OCaml library for enhancing compiler diagnostics in proof assistants, improving error messages for end users.
Unified Compositional Symbolic Execution - N40AI'24
Explore unified compositional symbolic execution techniques for program analysis, enhancing software reliability and performance optimization.
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.
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.
Type-safe Nanopasses: How to Write a Safe and Modern Compiler Front-end - INFER 2024
Explore a novel approach to strongly typing compiler passes, combining nanopasses and recursion schemes for efficient, type-safe compiler front-end development in Ada.
Taming Floating Points in Scala and CakeML
Explore formal verification techniques for floating-point programs in functional languages, focusing on static analysis to ensure accuracy and meaningful results despite rounding errors.
IntelliJ Elixir - Working with Broken Code and Complex Macros
Explore IntelliJ Elixir's capabilities for resolving and completing code in broken files, understanding macro-heavy code, and finding definitions in DSLs for Phoenix and Ecto.