Bridging the Syntax-Semantics Gap in Programming - A Novel Programming-by-Demonstration Approach
Explore a novel programming-by-demonstration paradigm that bridges the syntax-semantics gap, enabling intuitive and visual program creation without learning complex syntax.
A Calculus of Inductive Linear Constructions
Explore a novel calculus combining linear and dependent types, addressing challenges in linear dependent types research and enabling efficient resource management in programming.
An Intrinsically-typed Probabilistic Programming Language in Coq - Extended Abstract
Explore formalization of intrinsically-typed probabilistic programming language in Coq, focusing on syntax, evaluation, and formal verification applications.
A Type System for Feature Engineering in Machine Learning
Explore a dependent type system for feature engineering, enhancing machine learning model inputs through advanced data operations and compiler techniques.
Semantic Encapsulation Using Linking Types
Explore semantic encapsulation with linking types to preserve language invariants when integrating foreign code, ensuring sound interoperability in multi-language systems.
A Type-Theoretic Account of Quantum Computation
Explore type-theoretic concepts for describing and proving properties of quantum computations, focusing on quantum circuits using Coq's dependent and polymorphic types.
Exploring Modal Types for the Intel Quantum SDK
Explore modal types for Intel Quantum SDK, focusing on a proposed type system with three modes to ensure proper data handling in quantum kernels.
A Semantics of Core Erlang with Handling of Signals
Explore a small step semantics for Core Erlang's monitoring and signal systems, aimed at enabling causal explanations for property violations in concurrent programs.
Severing Ties: The Need for Non-Updateable Thunks
Explore non-updateable thunks in Haskell to prevent memory leaks and optimize garbage collection in streaming abstractions and control flow scenarios.
GHC Plugin for Setting Breakpoints in Concurrent Programs
Explore a GHC plugin for improved breakpoint functionality in concurrent programs, addressing limitations in GHCi's built-in debugger.
Why Code in Python+C When You Can Code in Lisp+Zig
Explore the benefits of combining GNU Guile Lisp and Zig for bioinformatics, offering quick coding and high performance without fighting Rust's borrow checker.
Embedding by Unembedding - Extending HOAS for Complex Semantic Domains
Explore a novel language development technique that extends HOAS, addressing limitations in semantic domains for open expressions, with applications in incremental computation and bidirectional languages.
Dependent Session Protocols in Separation Logic from First Principles - Functional Pearl
Explore dependent session protocols in concurrent separation logic, building from mutable references to channels. Simplify verification using basic mechanisms for one-shot protocols and extend to dependent session protocols.
Explicit Refinement Types - A Type Theory with Embedded Proofs
Explore λert, a type theory with explicit proof refinement types. Learn about its soundness, denotational semantics, and formalization in Lean 4.
Modal FRP for All: Functional Reactive Programming Without Space Leaks in Haskell
Explore Modal FRP in Haskell: Learn to prevent space leaks in functional reactive programming and implement a Pong game using this technique.
Etna: An Evaluation Platform for Property-Based Testing - Experience Report
Explore Etna, a platform for evaluating property-based testing techniques. Compare popular frameworks in Coq and Haskell to understand best practices and tradeoffs in functional programming.
Higher-Order Property-Directed Reachability
Explore higher-order extension of PDR for automated verification of complex systems. Learn about HoPDR's formalization, implementation, and effectiveness in program safety verification.
Formal Specification and Testing for Reinforcement Learning
Explore formal specification and testing methods for reinforcement learning applications, focusing on temporal difference methods and property-based testing using functional programming techniques.
Combinator-Based Fixpoint Algorithms for Big-Step Abstract Interpreters
Explore combinator-based fixpoint algorithms for big-step abstract interpreters. Learn to develop and ensure soundness of sophisticated fixpoint algorithms using reusable combinators for static analysis.
Efficient Loops in Arrowized Functional Reactive Programming - Haskell 2023
Explore efficient loop optimization in Arrowized Functional Reactive Programming, improving performance through novel program transformations while maintaining correctness in Haskell.
Effect Handlers for Programmable Inference - Haskell 2023
Explore effect handlers for modular inference programming in probabilistic algorithms, revealing high-level structures and enabling easy customization of Metropolis-Hastings and particle filtering methods.