scheme

Nada Amin's Strange Loop talk on programming languages that build on themselves, centered on towers of interpreters and nestable interpretation in Scheme. She shows how interpreters can be stacked and collapsed.

Dan Friedman and William Byrd demonstrate miniKanren, a logic programming system for Scheme, in an unconference talk. It includes generating programs by running relations in reverse.

A short Portuguese-language excerpt of Gerald Sussman's 2016 NYC Lisp Meetup talk explaining why MIT replaced the Scheme-based 6.001 (SICP) course with Python courses. The full talk is linked in the description.

Andy Keep's Clojure/Conj talk on writing a nanopass compiler, built from many single-task passes with formally defined intermediate languages. It covers the framework's origins in a compiler teaching course at Indiana University.

William Byrd presents at Papers We Love NYC on what he calls the most beautiful program ever written, a Lisp interpreter written in Lisp. He walks through the metacircular interpreter and related ideas, and demos relational programming and program synthesis near the end.

Gerald Sussman's 2011 Strange Loop keynote argues we still do not know how to compute, comparing biological systems with how we program machines. It touches on propagators, constraint programming and robustness.

Gerald Jay Sussman speaks at Dan Friedman's 60th birthday celebration about how programming helps formulate and clarify ideas. He argues that ambiguous mathematical notation hinders understanding.

Part 4 of John Carmack's QuakeCon 2013 keynote, covering OpenGL, functional programming, Haskell, Lisp and Scheme, typing, multithreading, events and garbage collection.

Robert Smith of Rigetti Computing talks at a Bay Area Lisp and Scheme meetup about using Common Lisp for quantum computing. He covers the technical, sociological and psychological sides of working across disciplines.

Jim Weirich's RubyConf 2012 talk derives the Y combinator step by step, live-coding in Ruby lambdas. It builds up an understanding of functional programming and lambda calculus from first principles.

Sasa Juric explains what makes Erlang and Elixir suited to server-side systems, focusing on the BEAM concurrency model rather than syntax or ecosystem. He demonstrates processes, supervision, and fault tolerance.

Rich Hickey's Strange Loop 2011 keynote distinguishing 'simple' (not intertwined) from 'easy' (familiar or near at hand). It argues that software complexity comes from complecting things and that we should pick simple constructs.

Richard Feldman's elm-conf talk on designing models so that bugs from impossible application states cannot occur, using Elm's compiler and types. It demonstrates techniques for making invalid states unrepresentable.

Richard Feldman argues that functional programming is not the norm largely because of historical accidents, such as C++ popularity, platform exclusivity, marketing spend and network effects, rather than merit. He traces the history of how languages become mainstream.

Rich Hickey's JaxConf 2012 keynote examines what values are and why immutable values matter as information systems grow more complex and data gets bigger. It contrasts places with values and builds the case for immutability.

Rich Hickey's Clojure/Conj 2018 keynote argues that Maybe/Option types and rigid type signatures are a poor way to model data that changes over time. He builds the case around optionality, schema growth and compatibility, and presents the ideas behind Clojure spec as an alternative.

Rafal Dittwald's Clojure/north talk shows how to move from writing Java-style code in Clojure to thinking in data-driven, functional terms. He walks through a JavaScript example, refactoring imperative code step by step into a functional core.

Rich Hickey's philosophical talk from the first Clojure Conj in 2010. He argues that good design comes from deliberate, away-from-keyboard thinking, and describes how to feed the background mind so it solves problems.

Rich Hickey's talk at Clojure's tenth anniversary on the kind of programs Clojure is designed for. He argues for situated programs that deal with changing requirements, and for dynamic typing and data over static types.

Rick Reed of WhatsApp explains at Erlang Factory 2014 how the service scaled to billions of messages with a very small engineering team. He covers the FreeBSD and Erlang stack, Mnesia usage, server counts and bottleneck work.

Tim Ewald's Clojure/conj talk uses furniture making with hand tools versus machine tools as an allegory for software. It explores how automation changes what we make and how we think about our work, and why Clojure's small set of simple tools matters.

Gary Bernhardt's RubyConf 2012 talk on testing in isolation without mocking everything. It goes through behavior versus data, mutation versus immutability, and how a functional core with an imperative shell yields natural isolation and parallelism.

Rich Hickey's keynote on software versioning, arguing that breaking changes are the real problem and that libraries should only grow by providing more and requiring less. It critiques semantic versioning and ties into Clojure spec.

Christian Schafmeister's Google Tech Talk on designing spiroligomer molecules and building Clasp, a Common Lisp on LLVM that interoperates with C++, to program molecular design. It covers the chemistry, automatic differentiation for force fields, and how the compiler is built.

Rich Hickey's Strange Loop 2011 keynote separates 'simple' (not intertwined) from 'easy' (familiar or near at hand) and argues that software complexity comes from complecting things. It offers a vocabulary for judging designs and abstractions.

Rich Hickey's 2013 talk applies language-design thinking to whole systems, covering names, queues, data, failure, and the interfaces between programs. It ends with a call to action for building systems holistically.

Guy Steele's invited talk at Clojure/conj on the informal metanotation computer scientists use in papers to describe languages. He traces how this notation developed and why it is often unspecified and arcane.

Stefan Karpinski's European Lisp Symposium 2016 talk asks whether Julia is a Lisp. He covers the features it borrows from Lisp, such as macros and closures, and where it departs, including syntax and its type system, with generated machine code shown.

Joe Armstrong, co-inventor of Erlang, gives a funny and opinionated Strange Loop talk on the tangled state of software: build tools, package managers, entropy and the physical limits of computation. He argues for ideas like naming things by content hash and throwing away your first version.

Mark Bastian contrasts top-down object-oriented design with bottom-up, data-oriented design in Clojure. He models a board game as plain data plus small composable functions and compares it with a roughly 22-class OOP version.

Chuck Moore, inventor of Forth, presents GreenArrays' 144-core asynchronous chip at Strange Loop 2013. He explains how idle cores draw almost no power and how tight code minimizes energy use.

Jack Rusher's Strange Loop 2022 talk argues that most programming languages are still designed around punchcard-era assumptions. He makes the case for live, interactive programming environments, drawing on Lisp, Smalltalk and REPL-driven development.

Rich Hickey's keynote at RailsConf 2012, a close sibling of his 'Simple Made Easy' talk. He distinguishes simple (not intertwined) from easy (familiar), and argues that software complexity comes from complecting things, with Rails-specific examples including large gem collections.

Paul Chiusano's Strange Loop 2019 talk introduces Unison, an open-source functional language for distributed, elastic systems. It covers content-addressed code identified by hashes of the syntax tree, a codebase manager, and algebraic effects called abilities.

Brian Lonsdorf explains why Underscore.js falls short as a functional programming library, then introduces currying, composition and point-free style in JavaScript. He argues for data-last argument ordering.

Scott Wlaschin's NDC talk on using statically typed functional programming, F# in particular, to model a business domain. Types are used to represent the domain precisely and to encode business rules so that illegal states cannot be built, with the compiler acting as an instant unit test.

Chris Ford builds up from a single sine wave through layered abstractions to a Bach canon, using Clojure and the Overtone audio environment. The talk shows music theory as a natural fit for functional programming.

Juan Pedro Bolivar Puente explains immutable and persistent data structures in C++ and how they support value semantics. He presents the Immer library, rrb-trees, and a prototype text editor that opens a huge file instantly.

Chris McCord's ElixirConf EU 2019 keynote introducing Phoenix LiveView, which builds interactive server-rendered apps without writing JavaScript. It explains how only changed dynamic parts are sent over a websocket.

Michael Hendricks of PriceCharting shares tricks and pain points from running Prolog in production for 18 months at Strange Loop. It argues Prolog is a productive modern language beyond logic puzzles, and includes a demo of changing code mid-execution.