LambdaConf 2018
2018-06-03..2018-06-05
Estes Park, United States
[LambdaConf 2015, LambdaConf 2017, LambdaConf 2018, LambdaConf 2019, LambdaConf 2020 Global Edition, LambdaConf 2024, LambdaConf 2025]
| title | author | length |
|---|---|---|
| Parallel-by-construction Tree Manipulation with APL (Part 1) | Aaron W Hsu | 55m |
Claims a compiler that is data-parallel-by-construction and can self-host on the GPU, implemented in APL and tested in a Codyfunds workspace; it represents… | ||
| Parallel-by-construction Tree Manipulation with APL (Part 2) | Aaron W Hsu | 01h 07m |
Claims that APL expresses tree transforms so compactly they are parallel-by-construction, letting whole compiler passes appear as single lines and making… | ||
| Book Of Monads: An Interview | Alejandro Serrano Mena | 22m |
A compact overview that promises concrete takeaways: a distillation of scattered tutorials into a practical guide that explains monad transformers, how to… | ||
| Monad Transformers for the Easily Confused | Adam McCullough | 50m |
Claims that monad transformers let different effects be composed are demonstrated with concrete Haskell code, a tiny Stack repo, and the transformers package… | ||
| Guarded Impredicativity | Alejandro Serrano Mena | 40m |
Proposes guarded impredicativity: allow impredicative instantiation only when the forall appears inside a type constructor. Gives a precise algorithm… | ||
| A Hands on Tutorial to Generic Programming in Haskell (Part 2) | Alejandro Serrano Mena | 49m |
Shows how to implement concrete generic operations: a working generic equality via GHC.Generics that compiles, the from/to pattern, and a default signature… | ||
| A Hands on Tutorial to Generic Programming in Haskell (Part 1) | Alejandro Serrano Mena | 41m |
Shows how Haskell’s built‑in GHC generics actually work: the U1/K1/:+:/:× building blocks, how to write/from conversions, and how GHC can auto‑derive Generic… | ||
| What is a (side) effect? | Alejandro Serrano Mena | 49m |
Argues that “side effect” lacks a crisp definition and that what matters are concrete operation sets and laws: shows monads, monad transformers and free… | ||
| Some Context for Pure FP Concepts and Style: A Retrospective | Alex Berg | 57m |
Builds a multi‑page site with PureScript and a server and actually shares types between front end and server, starts with Pux for the UI and discovers Pux… | ||
| Type Theory Behind the Glasgow Haskell Compiler Internals (Part 6) | Vitaly Bragilevsky | 01h 01m |
Traces the concrete extensions to GHC Core: role-based coercions (implemented in 2015), System FC variants (FC2, FC‑, FCPro) that add roles, data promotion and… | ||
| Type Theory Behind the Glasgow Haskell Compiler Internals (Part 5) | Vitaly Bragilevsky | 01h 00m |
Tracks the concrete claim that GHC Core grows by one clean extension — System F_Omega → System FC — adding coercions as types to compile GADTs and associated… | ||
| Type Theory Behind the Glasgow Haskell Compiler Internals (Part 4) | Vitaly Bragilevsky | 58m |
Explains that GHC Core is essentially System F Omega plus algebraic datatypes for decades, demonstrates concrete translations from Haskell source into… | ||
| Type Theory Behind the Glasgow Haskell Compiler Internals (Part 3) | Vitaly Bragilevsky | 58m |
History of how GHC Core actually changes: precise extensions (GADTs, type families, data kinds, type/kind equality, moves toward dependent types), the encoding… | ||
| Type Theory Behind the Glasgow Haskell Compiler Internals (Part 2) | Vitaly Bragilevsky | 49m |
Follows the GHC compilation pipeline down to the internal, explicitly typed GHC Core, shows how Haskell features become concrete Core constructs (GADTs, type… | ||
| Type Theory Behind Glasgow Haskell Compiler Internals (Part 1) | Vitaly Bragilevsky | 57m |
Claim: GHC implements type theory concretely, not just as lore—GHC Core = System F + algebraic datatypes and successive extensions add GADTs, type families… | ||
| Recursion Schemes Without the Barbed Wire (Part 6) | Valentin Kasas, Olivier Girardot | 24m |
Claims that recursion schemes let a schema-driven pipeline do validation and transformation in only half a traversal, implemented with algebraM + Traverse and… | ||
| Recursion Schemes Without the Barbed Wire (Part 5) | Valentin Kasas, Olivier Girardot | 25m |
Shows a concrete pipeline: uses recursion schemes to implement schema-to-Avro projection algebra in Core Java, validates semi-structured JSON/CSV and emits… | ||
| Recursion Schemes Without the Barbed Wire (Part 4) | Valentin Kasas, Olivier Girardot | 21m |
Recursion schemes power a concrete data-ingestion pipeline: validate semi-structured JSON/CSV schemas, transform to Parquet or Avro, and compose schema flavors… | ||
| Recursion Schemes Without the Barbed Wire (Part 3) | Valentin Kasas, Olivier Girardot | 32m |
Shows how recursion schemes (using matryoshka) apply to a real data‑lake pipeline: schema validation and transformation into columnar formats by writing… | ||
| Recursion Schemes Without the Barbed Wire (Part 2) | Valentin Kasas, Olivier Girardot | 41m |
Recursion schemes get applied end-to-end to a toy data lake: schema-driven validation, transforms into Parquet/Avro, and pipeline pieces implemented in Scala… | ||
| Recursion Schemes Without the Barbed Wire (Part 1) | Valentin Kasas, Olivier Girardot | 44m |
Claims that recursion schemes let a runtime‑configured data ingestion pipeline handle semi‑structured sources and produce Parquet and Avro are demonstrated… | ||
| Introduction to FP Using Haskell (Part 2) | Tony Morris | 47m |
Defines concrete algebraic types like OneOrTwo a, a recursive Natural and a custom List and shows actual GHCi commands (including :info) using Glasgow Haskell… | ||
| Introduction to FP Using Haskell (Part 1) | Tony Morris | 59m |
Workshop promises concrete outcomes: install GHC 7.8+ and use GHCi reload to run examples, build small programs that demonstrate lambdas, polymorphic types… | ||
| An Intuition for List Folds | Tony Morris | 53m |
Clear claim: fold left = a loop — it accumulates by iterating with an accumulator (examples in Haskell and C#: sum, product, length, reverse) and never… | ||
| Designing Flexible Open source Components in Halogen | Thomas Honeyman | 48m |
Library claim: extract interaction and state but let consumers own the HTML. Implementation uses purescript-halogen-select with three helper props (e.g… | ||
| Category Theory for People who Can't be Bothered to Learn It (Part 2) | Steven Syrek | 51m |
Workshop demonstrates concrete code translations between JavaScript and Haskell and claims category ideas pay off in everyday programming: composition… | ||
| Category Theory for People who Can't be Bothered to Learn It (Part 1) | Steven Syrek | 45m |
Claims that a few fundamental categorical ideas yield practical payoffs and demonstrates them with live code in JavaScript and Haskell, exercises from a GitHub… | ||
| Propositions as Types for Beginners in Haskell | Stephen Pimentel | 38m |
Claims a practical recipe: translate a proposition into a type and then construct an inhabitant to prove it. Uses standard Haskell 2010 restricted to the sound… | ||
| Opaque Types To Infinity | Stephen Compall | 54m |
Shows a concrete technique to get zero‑cost opaque types in Scala using abstract type members plus a globally ascribed val, demonstrates subs proof functions… | ||
| Proving Theorems and Certifying Programs with Coq | Stephan Boyer | 55m |
Concrete claims and code: Coq proofs are Gallina terms checked by the typechecker, Ltac scripts generate those terms, and proofs erase to runnable… | ||
| A Typeclass Primer for OO People | Simon Hafner | 43m |
Explains how typeclasses attach functions to types with concrete code: Scala and Haskell implementations that differ in resolution and coherence, demos that… | ||
| Why JavaScript Programmers Should Learn Algebraic Data Types | Seth House | 55m |
Claims concrete payoff: algebraic data types replace ad hoc checks and tiny libraries with composable containers implemented in plain JavaScript, demonstrated… | ||
| Athena: A Declarative Language For Proofs In Computer Science | Sandy Vanderbleek | 49m |
Athena is a declarative proof language (not tactic based) that you can install and run at the command line; it emphasizes declarative not tactic-based proofs… | ||
| Introduction to Linear Type Systems and Linear Haskell | Ryan Orendorff, Daniel Hensley | 49m |
Claims that linear types let the compiler guarantee resource protocols rather than runtime checks, demonstrated by a Linear Haskell extension that rejects… | ||
| Theory & Models of Lambda Calculus: Typed and Untyped (Part 6) | Dana Scott, Jeremy G. Siek | 33m |
Claims a concrete model: using the powerset of the integers with enumeration operators to model application, abstraction and computability, then adds a… | ||
| Theory & Models of Lambda Calculus: Typed and Untyped (Part 5) | Dana Scott, Jeremy G. Siek | 01h 01m |
Model uses the powerset of N with enumeration operators to model application and abstraction; closure operators correspond to subspaces and fixed points equal… | ||
| Theory & Models of Lambda Calculus: Typed and Untyped (Part 3) | Dana Scott, Jeremy G. Siek | 01h 04m |
Presents a concrete model: represent data as subsets of N and functions as enumeration operators on P(N) so application becomes a lookup-table operation on… | ||
| Theory & Models of Lambda Calculus: Typed and Untyped (Part 3) | Dana Scott, Jeremy G. Siek | 59m |
Claims a concrete model of lambda calculus built on the powerset of the integers, using enumeration operators as the actual implementation of application and… | ||
| Theory & Models of Lambda Calculus: Typed and Untyped (Part 2) | Dana Scott, Jeremy G. Siek | 32m |
Claims a concrete semantic model: use the powerset of the integers with enumeration operators to interpret application and abstraction, and show that Church… | ||
| Theory & Models of Lambda Calculus: Typed and Untyped (Part 1) | Dana Scott, Jeremy G. Siek | 56m |
Shows a concrete model: application and abstraction realized by enumeration operators on P(N) with a topology, not handwavy category talk. Carries out… | ||
| Rock Solid Haskell Services (Part 6) | Roman Gonzalez | 33m |
Concrete Haskell code for running fault-tolerant services appears: a component-based app composes remote queue and remote topic abstractions, a worker pool… | ||
| Rock Solid Haskell Services (Part 5) | Roman Gonzalez | 43m |
Hands-on Haskell workshop that builds a supervised web crawler using supervision trees and an explicit worker pool, wires SNS/SQS via localstack and toxiproxy… | ||
| Rock Solid Haskell Services (Part 4) | Roman Gonzalez | 51m |
Hands-on Haskell workshop that actually builds a supervised runtime: capitis implements supervision trees with named workers, restart strategies… | ||
| Rock Solid Haskell Services (Part 3) | Roman Gonzalez | 57m |
component M is a small Haskell library that guarantees cleanup of all resources, tracks init and teardown time per component, and builds a dependency graph to… | ||
| Rock Solid Haskell Services (Part 2) | Roman Gonzalez | 52m |
Hands-on Haskell workshop that shows concrete techniques to make concurrent services resilient: implements supervision trees and circuit breakers, uses STM… | ||
| Rock Solid Haskell Services (Part 1) | Roman Gonzalez | 59m |
Workshop shows concrete reliability tools in Haskell with code that runs: uses Rio logger and utf8 builder/display instead of putStrLn, recommends Stack… | ||
| Introducing A Functional Language At Work | Robert Kluin | 42m |
A retrospective compares concrete experiments: a Scala pilot fails—SBT builds are slow, JVM runtime and flexible idioms clash with a massive cloud infra, and… | ||
| Abstract Algebras and Where to Find Them Magmas, Monoids, and More! | Reid Evans | 50m |
Defines magmas, semigroups, monoids and join-semilattices with concrete TypeScript implementations (no higher‑kinded types), shows foldMap abstraction and a… | ||
| Understanding Distributed Calculi in Haskell | Pawel Szulc | 47m |
Clear claim: pi calculus and rho calculus are mapped to Haskell examples using distributed-process (Cloud Haskell); live ping‑pong code runs but exposes… | ||
| Typed FP on the Job Why Bother | Paul Snively | 39m |
Claim: pure typed FP yields executable guarantees that cut defects and let code be reasoned about without exhaustive tests. Examples use Scala Zed and HTTP for… | ||
| Building a Telegram Bot in Haskell (Part 2) | Nikolai Kudasov | 55m |
Builds a working Telegram todo bot in Haskell and shows concrete code: uses Stack GHCi ghcid, imports like Control.Monad.Trans and Data.Time, lifts IO with… | ||
| Building a Telegram Bot in Haskell (Part 1) | Nikolai Kudasov | 56m |
A live workshop shows a working Telegram bot built in Haskell using Stack GHCi ghcid, the telegram-bot-simple library and its update‑parser helpers, with a… | ||
| Cross Platform Mobile Application Development with F# | Nikhil Barthwal | 40m |
Shows that a single F# codebase compiles to native iOS and Android apps via Xamarin with typical 80–90% shared code, explains platform-specific hooks (custom… | ||
| TEA and SPA: A Retrospective | Alex Berg | 30m |
A retrospective on using Elm Architecture for a large proxy web app: claims that it yields fast prototyping but forces a single global state, making… | ||
| Computation in Graphics Applications | Alex Von Hoene | 30m |
Demo shows Blender used for real computation: Blender’s node compositing system runs array-style math to build a Mandelbrot, implemented by chaining roughly 16… | ||
| Hands on Chat About Categories | Alexander Konovalov | 01h 11m |
Concrete mappings and runnable examples: definitions of objects, morphisms, identities, composition, Cartesian closed ↔ functions and tuples, explicit… | ||
| ScalaFiddle and Categories | Alexander Konovalov | 47m |
Scala codebase adds concrete support for subcategories and categorical abstractions: an experimental SAP cats package, references to SAAP cask and Category… | ||
| The Leibniz Library and Applied Propositions as Types | Alexander Konovalov | 01h 04m |
Library implements Leibniz equality, coercion, substitution and composition in Scala, with proofs encoded as types and macros to produce runtime evidence. It… | ||
| Live Coding Eff in Anger | Arnaud Baily, Jan Christopher Vogt | 55m |
Live-coding shows building a Pet Store REST service using the Eff monad from the freer package, wiring Servant/Warp handlers into an effect stack, writing… | ||
| Don't Worry About Monads | Beau Lyddon | 56m |
Claim: Elm lets teams ship front-end apps without needing to learn monads first — the compiler infers types and guides fixes. Demo builds include a working… | ||
| Elixir's Ecto: Functional Relational Data Access Done Right | Brad Urani | 35m |
Ecto claims to make SQL-first, functional data access practical for Elixir web apps by exposing the database rather than hiding it. Examples include use with… | ||
| Abstract Algebra Driven Design Animation in Swift as almost Semirings | Brandon Kase | 53m |
Claim: animations obey algebraic laws so they compose as a semiring with sequence as multiplication and parallel as addition. Implementation uses a Swift enum… | ||
| Learn Elixir by Building a Real Time CLI Chat App (Part 1) | Brooklyn Zelenka | 45m |
A hands‑on build of a fully distributed CLI chat app implemented in Elixir using the BEAM/OTP primitives: tangible use of GenServer and supervision trees… | ||
| Learn Elixir by Building a Real Time CLI Chat App (Part 2) | Brooklyn Zelenka | 24m |
Builds a fully distributed CLI chat app from scratch using Elixir 1.6+ and only core libraries, wiring GenServer processes, supervision trees, and message… | ||
| Learn Elixir by Building a Real Time CLI Chat App (Part 3) | Brooklyn Zelenka | 39m |
Builds a fully distributed CLI chat app using core Elixir/OTP primitives and shows how it actually works: GenServer/Task/spawn-based processes, GenServer… | ||
| Learn Elixir by Building a Real Time CLI Chat App (Part 4) | Brooklyn Zelenka | 26m |
Builds a fully distributed CLI chat app using Elixir core libraries and demonstrates it actually running: project scaffolded with mix new, dependencies from… | ||
| Learn Elixir by Building a Real Time CLI Chat App (Part 5) | Brooklyn Zelenka | 41m |
Builds a fully distributed CLI chat app using Elixir core libraries, wiring GenServer callbacks (handle_call/handle_cast) to a client API, using supervision… | ||
| Zero Cost Abstractions Eliminating Runtime Overhead in Scala | Cary Robbins | 52m |
Concrete claims and code: a Scala new-type macro generates zero-cost newtypes and subtypes (with a Scala 2.12 inline workaround for primitive boxing), a… | ||
| Moot | Chris Allen | 05m |
Proposal to build Moot a web app that automate CFP to schedule pipeline and replace the tens to roughly 100 spreadsheets used for reviews scheduling and… | ||
| The Properties of Property Testing with Hedgehog | Chris Allen | 48m |
Compares Hedgehog and QuickCheck using Hedgehog as the reference, claiming Hedgehog’s automatic shrinking (a rose-tree of generated values) finds minimal… | ||
| Down the Wabbit Hole | Chris McKinlay | 44m |
Haskell bindings for Vowpal Wabbit use inline-c and Template Haskell plus FFI, custom antiquoters and IO buffers to pass VW pointers without copying; a… | ||
| Testing for Lawful Good Adventures | Christopher Phelps | 36m |
Shows concrete law testing: implements Monoid for Pair[Int] and Monad for a homegrown Option, wires up Arbitrary and Eq, then runs ScalaCheck-backed suites… | ||
| How Not to Write Slow Scala | Colin Woodbury | 54m |
Benchmarks use SBT jmh and the repo shows concrete numbers: prepending to lists is often fastest while appending to Seq can be twice as slow, arrays of… | ||
| Haskell DJs: Compose a Hit with Vinyl! | Dan Fithian | 44m |
Claims that Haskell gets structural row types via Vinyl plus a sugar layer called Composite Records and shows a working JSON boundary using Aeson Better… | ||
| Programming Safely in an Uncertain World (Part 1) | David Chambers | 49m |
Claims that algebraic types let JavaScript handle failure declaratively and that small combinators collapse uncertainty into one result while leaving error… | ||
| Programming Safely in an Uncertain World (Part 2) | David Chambers | 43m |
Claims that algebraic data types collapse multiple failure modes into one principled result and shows the actual code: Maybe, Either, and Future used with map… | ||
| Programming Safely in an Uncertain World (Part 3) | David Chambers | 36m |
JavaScript code that parses JSON, looks up path X.Y.Z, checks it’s an array of strings, converts hex strings to integers and sums them is shown working as a… | ||
| That Warm and Fuzzy Feeling | David Zuch | 36m |
A PureScript fuzzy-search library implements a type‑ahead used in a client UI and handles thousands of local items; it ranks with Levenshtein plus positional… | ||
| Out of the Tarpit with Project M36 | Diogo Biazus | 53m |
Project M36 implements the paper Out of the Tarpit by providing a TutorialD dialect, Haskell embedding and GADT-backed types that remove nulls from the schema… | ||
| My Little Token (Part 1) | Doug Beardsley | 54m |
Workshop shows how to build a collectible smart contract backend using Pact, Kadena’s Haskell‑implemented DSL, with hands‑on REPL/Atom demos and prebuilt… | ||
| My Little Token (Part 2) | Doug Beardsley | 37m |
Builds a collectible smart contract in Pact (Kadena’s Haskell implementation) with hands‑on examples: module and table setup via repple files, schemas and… | ||
| A Sense of Place: What ReaderT Can Do in a Purely Functional World | Edmund Noble | 54m |
Claims a concrete pattern: use ReaderT to carry a composable "place" environment so log lines, exceptions and simple profilers show high‑level context instead… | ||
| Typing the Y Combinator | Esther Wang | 48m |
Claim: adding a recursive type operator mu — mu as type-level fixed point — lets a statically-typed lambda calculus express the Y combinator and encode lists… | ||
| Read The Functional Manual: But First We Need to Write It | Fintan Halpenny | 47m |
Argues that documentation must show concrete decisions: uses Haddock + stack to generate docs beside code, adds inline comments, examples and doc-tests checked… | ||
| The Road to Ocelot | Forest Loren Toney III | 54m |
Company runs PureScript and Halogen in production for about nine months and ships an open source component library called Ocelot, built from ~30,000 lines. The… | ||
| Binding Blockchains Together with Accountability | François René Rideau | 52m |
Claims a working design for repudiable side-chains that aim for credit-card speed while keeping trustless security by provably binding side-chain state to a… | ||
| First Class Implementations: Climbing up the Semantic Tower | François René Rideau | 52m |
Claims that a runtime protocol—extracted via Curry‑Howard and expressed with category theory using partial functors—lets one swap implementations upward in a… | ||
| Let's Build a Blockchain | Harold Carr | 56m |
Builds a working toy blockchain in Haskell with SHA-256 hashing and a UDP peer network, implements a simple proof-of-work difficulty 4 (the brute-force miner… | ||
| Breaking Out of the Fear Cycle | Ian Thomas | 41m |
Sky Bet reports sustaining 99.99% availability and peaks of 21,000 bets a minute during Grand National, then breaks the fear cycle by distributing ops into… | ||
| From Zero to Live with Functional JavaScript Applications (Part 1) | Ian Thomas | 45m |
Claims that switching a monolithic OOP codebase to composable functional JavaScript yields multi‑million‑pound opportunities, fewer bugs, and faster delivery… | ||
| From Zero to Live with Functional JavaScript Applications (Part 2) | Ian Thomas | 58m |
Claims that refactoring a monolithic OOP codebase into composable functional JavaScript unlocks multi‑million‑pound opportunities, lowers bug counts, and… | ||
| Developing Cardano Cryptocurrency in Haskell | Ivan Gromakovskii | 47m |
Haskell is a great programming language, but unfortunately it's not quite popular for solving real business problems. Despite the increasing popularity of… | ||
| Snarky: Algebraic effects in the Coda cryptocurrency | Izaak Meckler | 54m |
Snarky is an OCaml embedded DSL that compiles high‑level, Hindley‑Milner style code with algebraic effects into rank‑1 constraint systems so zk‑SNARKs can… | ||
| Seriously, The Haskell Type Checker is Your Friend | J Haigh | 32m |
Live walkthrough of real GHC errors with concrete fixes: use GHC 8.2.2 and GHCi to reproduce parse, definition and type errors; fix module/pragma order and… | ||
| Extensibly Free Arrows | Jake Keuhlen | 47m |
Combines extensible-sp open sums/products, GADTs and free structures to make a composable free arrow that compiles to different runtimes; shows a concrete bug… | ||
| Beauty and the Beast: Haskell for JVM | Jarek Ratajski | 55m |
Eta compiles GHC’s STG to JVM bytecode (so it keeps GHC compatibility), rewrites C imports into Java calls via community patches, and provides STG backend… | ||
| Free Your Monads and the Rest Will Follow | Jason Litton | 45m |
A production workflow engine is rebuilt around the free monad in Scala using Cats, Twitter futures and foldMap interpreters, producing tenant-specific… | ||
| Crash Course on Notation in Programming Language Theory (Part 1) | Jeremy G. Siek | 57m |
Crash course promises concrete mechanics: reading POPL/ICFP notation by building inductive definitions with base cases and rules, drawing derivation trees… | ||
| Crash Course on Notation in Programming Language Theory (Part 2) | Jeremy G. Siek | 01h 03m |
Clear, hands‑on coverage of the notation you actually need: grammars for syntax, sets/tuples/relations and inductive definitions, worked big-step and… | ||
| Typing a LISP | Jim Duey | 50m |
A Lisp dialect called Takada claims to give static-typing benefits while staying dynamic: a gradual algebraic dependent type system that uses runtime… | ||
| Learning Propositional Logic with Logic Programming | Jimmy Torre | 01h 01m |
Builds a runnable propositional-logic DSL in miniKanren embedded in Scheme, converts SL grammar into relations, and implements procedures to remove… | ||
| Input Validation in PureScript: Simpler, Safer, and Stronger (Part 1) | Joe Kachmar | 43m |
Claims that PureScript plus its Validation library and row polymorphism makes input validation predictable and composable, and demonstrates concrete code… | ||
| Input Validation in PureScript: Simpler, Safer, and Stronger (Part 2) | Joe Kachmar | 37m |
Shows how PureScript validation switches from non-empty lists to a free semi-ring accumulator so branching alternatives accumulate errors correctly, uses Alt… | ||
| Authoring and Formal Verification of Smart Contracts in Pact | Joel Burget | 37m |
A property checker for Pact translates Pact programs and properties to SMT constraints and hands them to Z3 SMT solver, implemented via SBV/Haskell. It proves… | ||
| Blazing Fast, Pure Effects without Monads | John A De Goes | 58m |
Claims that Kleisli arrows (a Clisly IO) beat monadic IO on the JVM by fusing impure calls and avoiding allocations. Uses Scala on the JVM with Scalaz 8 ideas… | ||
| Diving Into Q# | John Azariah | 59m |
Q# presents concrete claims and tools: a Microsoft quantum development kit with a 30 qubit simulator on a laptop (about 40 qubits in cloud), a runtime that… | ||
| Interactive Testing with Flare and Halogen | Jonathan Curran | 12m |
A bridge between Flare and Halogen uses a higher-order component that forces a redraw by bumping a slot ID, letting a Flare-generated UI drive a Halogen child… | ||
| JavaScript to Purescript A Migration Story | Jonathan Curran | 01h 04m |
Migrating a large Angular + Redux-Saga app to PureScript and Halogen is described with concrete outcomes: PureScript 0.11.7 plus Halogen are used to embed… | ||
| Modern, Functional Cryptography (Part 1) | Jose Cardona | 58m |
Mathematics-heavy developer introduction that actually states what gets built and proved: number theory, algebra, symmetric and asymmetric schemes, PRFs/PRGs… | ||
| Modern, Functional Cryptography (Part 2) | Jose Cardona | 53m |
Workshop builds a working cryptographic library in Scala with typeclasses and runnable exercises, using tsec, SBT and IntelliJ, and shows actual code rather… | ||
| Modern, Functional Cryptography (Part 3) | Jose Cardona | 59m |
Math-heavy workshop that actually builds things: a typed cryptography library in Scala using cats/fs2/http4s and tsec (libsodium for FFI), implements Merkle… | ||
| Modern, Functional Cryptography (Part 4) | Jose Cardona | 01h 05m |
Part 4 lays out concrete constructions and code: a functional cryptography library in Scala typeclasses, keyed MACs and HMAC‑SHA256 implementations, JWT… | ||
| Modern, Functional Cryptography (Part 5) | Jose Cardona | 55m |
Workshop promises a mathematics-heavy, developer-first route: concrete claims about hardness (Fermat little theorem, discrete logarithm, Diffie‑Hellman) and… | ||
| Modern, Functional Cryptography (Part 6) | Jose Cardona | 58m |
Math-heavy developer intro that actually shows working code and attacks: a cryptographic library built around typeclasses and laws with keys tracked by types… | ||
| ScalaZ and Cryptography | Jose Cardona | 28m |
A Scala library called TSEC/TTech adds compile‑time types to cryptography so keys, IVs and ciphertexts carry algorithm and length information; code examples… | ||
| The Shape of Shapeless (Part 1) | Joseph Abrahamson | 56m |
Claims how Shapeless gives compile‑time generic programming: concrete use of HList and type recursion to turn case classes into tuples, an explicit recipe for… | ||
| The Shape of Shapeless (Part 2) | Joseph Abrahamson | 55m |
Walks through concrete techniques to derive code with Shapeless: defines a lexicographic compareHList, exposes output types with the ox pattern (refinement… | ||
| Simple Elixir MapReduce | Joseph Cieslik | 24m |
A simple MapReduce is implemented in Elixir as a concurrent word count that actually runs end to end: file reader spawns mapper processes which send key/value… | ||
| Using Corecursion Schemes | Juan Pablo Santos | 02h 00m |
Workshop shows a practical recipe: uses matryoshka and Scala (cats/scalaz) and demonstrates real code for apo plus cata and Cofree. Concrete claims: write and… | ||
| Hoon and You: A Functional Programming Perspective | Justin LeBlanc | 49m |
Hoon is a systems language that compiles to Nock, where every value is a noun (atom or cell) and atoms are arbitrary unsigned integers; the compiler itself is… | ||
| Haskelling Bitcoin for Great Good | Keagan McClelland | 56m |
Claim: strong static types and purity let Haskell catch many blockchain bugs before deployment. Implements a Bitcoin‑style system: UTXO transactions… | ||
| Set Theoretic Algebraic Constructive Calculus | Lander Lopez | 55m |
Claims a set‑theoretic dependent calculus (Stacc) that encodes types as sets of predicates and uses union for application and coproducts for data, demonstrates… | ||
| Free All The Things | Markus Hauck | 34m |
Claims a mechanical recipe to "free" many typeclass structures beyond monads and demonstrates it on free monads, applicatives, functors, monoids (becoming… | ||
| How This Presentation Was Made | Markus Hauck | 32m |
Builds a complete Beamer PDF from source by wiring together Haskell Shake rules, snippet extraction with marker comments, automatic formatting and… | ||
| Exceptional Haskell | Matt Parsons | 58m |
Claims concrete tradeoffs: Haskell has both synchronous and asynchronous runtime exceptions, try/catch/bracket use Typeable + AnyException with runtime type… | ||
| Reflecting on Behavior | Mike Stay | 57m |
Milner’s rho calculus becomes a practical VM for a blockchain implemented in Scala with about a dozen developers and plans to hire more; the work claims an… | ||
| Functional Error Handling in Python | Moiz Merchant | 39m |
A tiny Pythonic library implements Option Try Either inspired by Scalaz, used to replace seven-deep nested ifs and multiple try/catch exits in a fixed‑length… | ||
| Chainweb: A Parallel chain Architecture for Massive Throughput | Monica Quaintance | 30m |
Claims a running parallel PoW network called Chainweb that combines hundreds to thousands of chains into one fungible currency to push throughput to 10,000+… | ||
| Functional Programming: The Enterprise Edition | Narek Asadorian | 34m |
Claim: functional programming is practical in large companies and reduces boilerplate around nulls, exceptions and I O. Uses Scala on Spark and Akka, Kafka… | ||
| Cofree Comonads and their Uses | Nihil Shah | 41m |
Defines cofree comonads as a product type that annotates trees and streams and shows concrete encodings: stream = cofree over Identity, prefix list = cofree… | ||
| Unconference Coq | Stephan Boyer | 01h 00m |
Proofs are built interactively: start with a goal like n + 0 = n, use intro/induction/simple/reflexivity tactics to move variables, reduce and close base… | ||
| Urbit's Build System | Ted Blackman Ford | 51m |
Ford is Urbit/Herbet’s build system that actually runs shell expressions, drives version control and file‑type validation, generates static (and reactive)… | ||
| A Gentle Introduction to Modern Model Theory | Vlad Patryshev | 51m |
Modern model theory makes a concrete claim: separate theory from model and split algebraic vs geometric theories, and category theory need not rest on set… | ||
| Metaphorisms Deriving Divide and Conquer Recursive Programs | William Harvey | 49m |
Claims a recipeic path from Bird–Meertens formalism via metaphorisms to derive divide‑and‑conquer programs, shows the actual algebraic transformations used… | ||
| nothing matches | ||