Artificial Languages are Dead. Long Live Artificial Languages - SLE23
Explore the impact of Large Language Models on programming, artificial languages, and CS education in this thought-provoking talk by Crista Lopes.
Trustworthy Formal Natural Language Specifications
Explore a novel approach to translating natural language specifications into formal claims within proof assistants, enhancing software verification and bridging the gap between informal and formal specifications.
Is Polyglot Programming Really a Thing?
Explore the concept of polyglot programming, its prevalence, benefits, and challenges. Examine integration issues and software engineering implications for multi-language development.
Complete Multiparty Session Type Projection with Automata - ST30
Explore efficient multiparty session type projection using automata. Learn sound, complete, and efficient techniques for verifying asynchronous communication protocols.
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.
Formal Verification of a Mechanical Ventilator Using UPPAAL
Explore formal verification of mechanical ventilators using UPPAAL, enhancing system reliability and correctness through advanced modeling techniques.
Can Local-First Really Scale at the Edge?
Explore local-first software's impact on edge computing, examining challenges and solutions for metadata scaling in counters and causal CRDTs.
Formal Probabilistic Methods for Combinatorial Structures using the Lovász Local Lemma
Explore formal probabilistic methods for combinatorial structures, focusing on the Lovász Local Lemma and its application to hypergraph coloring in Isabelle/HOL.
Martin-Löf Type Theory Mechanization in Coq
Explore an extensive mechanization of Martin-Löf Type Theory in Coq, covering decidability of conversion and type checking, with a certified executable type checker for MLTT.
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.
Formalizing Giles Gardam's Disproof of Kaplansky's Unit Conjecture
Explore the formalization of Giles Gardam's disproof of Kaplansky's Unit Conjecture using Lean 4, combining deductive proving and verified computation.
UTC Time, Formally Verified - Presentation at CPP 2024
Explore formal verification of UTC time conversions using Coq and MathComp, including leap seconds implementation and refinement techniques for software verification 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.
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.
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.
A Tale of Shared Memory Concurrency in Programming Languages
Explore shared memory concurrency in programming languages, examining challenges, recent advancements, and future directions for designing effective concurrency models for multicore systems.
The Hunt for the Cluster Killer Bug - Debugging Erlang Legacy Code
Explore debugging techniques for Erlang systems, focusing on a cluster-killer bug case study. Learn about fault tolerance, memory models, and low-level issue resolution in Erlang applications.
Growing Together with the BEAM - 20 Years of Erlang/OTP in Telia ACE
Explore Telia ACE's 20+ year journey with BEAM technology, from early Erlang adoption to current AWS integrations. Learn about scalability, challenges, and ongoing projects in contact center solutions.