Modern DSL Compiler Architecture in OCaml - Experience with Catala
Explore state-of-the-art DSL implementation in OCaml, featuring concrete examples and insights from the Catala compiler for legal algorithms.
Runtime Detection of Data Races in OCaml with ThreadSanitizer
Explore runtime detection of data races in OCaml using ThreadSanitizer. Learn core principles, challenges, adaptations, and practical application for reliable parallel code development.
Greedy Implicit Bounded Quantification in Object-Oriented Programming Languages
Explore greedy implicit bounded quantification in object-oriented programming, focusing on type inference algorithms and a variant of kernel F≤ with implicit polymorphism.
Gradual Typing for Effect Handlers
Explore gradual typing for effect handlers, integrating effect typing with existing languages. Learn about GrEff language, its semantics, and the graduality theorem through operational logical relations models.
Grounded Copilot - How Programmers Interact with Code-Generating Models
Explore how programmers interact with AI coding assistants like Github Copilot, uncovering bimodal usage patterns and providing recommendations for future AI programming tools.
Regular Expression Matching using Bit Vector Automata
Explore a new algorithm for efficient regex matching with bounded repetition using nondeterministic bit vector automata, offering improved performance for challenging patterns in practice.
A Cocktail Approach to Practical Call Graph Construction
Explore a novel cocktail approach for efficient call graph construction in C-based software, improving precision and scalability for vulnerability detection and code understanding.
Translating Canonical SQL to Imperative Code in Coq
Explore a mechanically verified compiler translating SQL to imperative code, addressing implementation challenges and leveraging formalization advances in query compilation.
Automated Translation of Functional Big Data Queries to SQL
Explore automated translation of functional big data queries to SQL, improving efficiency while maintaining abstraction benefits. Learn about novel column-wise decomposition for query synthesis.
Fast and Efficient Boolean Unification for Hindley-Milner-Style Type and Effect Systems
Explore efficient Boolean unification for Hindley-Milner-style type and effect systems. Learn about a hybrid algorithm improving compilation speed and reducing inference overhead in polymorphic effect systems.
Verus: Verifying Rust Programs Using Linear Ghost Types
Explore Verus, an SMT-based tool for formally verifying Rust programs. Learn how it leverages Rust's linear types and borrow checking to prove functional correctness in low-level, high-assurance systems.
Concrete Type Inference for Code Optimization using Machine Learning with SMT Solving
Explore innovative concrete type inference for dynamically typed languages, combining machine learning and SMT solving to enable code optimization without manual type annotations, significantly boosting performance.
A Low-Code Platform for Systematic Component-Oriented Language Composition
Explore a low-code platform for systematic language composition using visual interfaces and pre-built components, streamlining domain-specific language development and promoting reuse.
Approximating Type Stability in the Julia JIT
Explore an algorithm for approximating type stability in Julia's JIT compiler, enhancing performance in this dynamic scientific computing language.
Configuration Testing for Borg at Google
Explore Google's innovative approach to unit testing Borg deployment configurations, addressing complexity challenges in large-scale systems and improving development efficiency.
Dafny Test Generation - Automated Testing for Verified Programs
Explore automated testing of Dafny programs with DTest. Learn to generate system-level tests, identify dead code, and ensure verified properties hold at runtime, enhancing confidence in code execution.
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.
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.
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.