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.
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.
Optimization-Aware Compiler-Level Event Profiling
Explore a novel technique for quantifying compiler-internal events in optimized code, reducing profiling perturbation and enhancing dynamic analysis accuracy.
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.
Generating Java Interfaces for Accessing Foreign Objects in GraalVM - Work in Progress
Explore a tool for automating Java interface generation to access foreign language objects in GraalVM, improving code clarity and reducing errors in language interoperability.
Evaluating YJIT's Performance in a Production Context - A Pragmatic Approach
Explore YJIT's performance in Ruby, comparing benchmarks and real-world deployment. Analyze speed, memory usage, and warm-up time against other JIT compilers for pragmatic evaluation.
A Multifaceted Memory Analysis of Java Benchmarks
Explore an in-depth study of memory behavior in Java benchmarks, offering insights into object allocations, accesses, and memory pressure through comprehensive profiling techniques.
Comparing Rapid Type Analysis with Points-To Analysis in GraalVM Native Image
Explore the comparison of Rapid Type Analysis and Points-To Analysis in GraalVM Native Image, focusing on performance improvements and trade-offs in ahead-of-time compilation for Java applications.
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.
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.
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.
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.