function composition

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.

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.

Richard Feldman explains how pure functional languages can match or beat imperative ones on performance. Compilers can turn immutable code into in-place mutation, avoiding naive copying. The talk draws on his work on the Roc language.

A 1987 talk in which John Backus, creator of Fortran, presents function-level programming and the FL language, a successor to his FP work. It is an archival recording with links to the related paper.

Oskar Stalberg explains how Wave Function Collapse assembles island dioramas from handcrafted tilesets in Bad North. He covers the theory, implementation, tooling, and how he blends art and technology.

Felienne Hermans argues that Excel is the world's most popular programming language and shows how spreadsheets work as a pure functional language. She implements a few mathematical problems in spreadsheet formulas to illustrate why they are so powerful and approachable.

Johann Korndorfer's NVScene 2015 talk on building content with signed distance functions. It focuses on patterns that make SDF modelling more structured, arguing that SDFs capture a shape's essence like vector graphics do compared with polygons or voxels.

Michael Arntzenius's Strange Loop talk on Datafun, a functional query language that brings database-style querying into a general-purpose language. It discusses bridging database theory and programming languages.

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.

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.

3Blue1Brown visualizes the Riemann zeta function and the analytic continuation that extends it beyond where its series converges, building toward the Riemann hypothesis.

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

Scott Wlaschin shows how statically typed functional languages, using F# examples, can model a business domain so that invalid states cannot be represented. The type system acts almost like an instant unit test at compile time.

The first lecture in Bartosz Milewski's category theory series for programmers. It covers the motivation and philosophy behind category theory and why composition matters for handling complexity.

Russell Barkley gives the keynote at UNC's 2012 Burnett Seminar on ADHD. He presents it as an executive function disorder and discusses its effects and how to help.

Mathologer examines the infamous Numberphile claim that 1+2+3+... equals -1/12, explaining what is wrong with the calculation and how it connects to real math like the zeta function and analytic continuation.

A step-by-step animated explanation of how SHA-256 works, from padding and message schedule to the compression function and final hash, with source code for the animations.

Dr. Russell Barkley lectures on the neuroanatomy of ADHD and how to treat it, linking executive function and working memory to the disorder. It is part 3 of a CADDAC series.

A joint Erlang Factory 2016 keynote by Phoenix creator Chris McCord and Elm creator Evan Czaplicki on using the two together, including Phoenix.Presence design and PubSub optimizations.

Kaze Emanuar searches for the best sine approximation for the Nintendo 64, comparing the lookup tables in Mario 64 and Ocarina of Time with polynomial alternatives. It walks through numerics and 3rd, 4th and 5th order approximations.

A Strange Loop talk presenting an open-source library that integrates Clojure into the Unity 3D game engine. It covers REPL-based live coding, macros, DSLs and persistent data structures for game development.

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 introduces transducers in Clojure, a way to make map, filter and similar algorithms composable independent of the data source. This avoids duplicated implementations and intermediate collections across sequences, channels and streams.

Evan Czaplicki, creator of Elm, talks at Curry On 2015 about user-focused language design. He explains the principles behind Elm and how to make a functional, typed language as approachable as JavaScript.

Runar Bjarnason's Scala World talk argues that restraint and precision in components beat power and flexibility. Constraints on parts make them easier to compose into systems.

Ben Krasnow of Applied Science demonstrates an X-ray fluorescence gun that measures chemical composition, tears it down, analyzes its failure, and discusses a new XRF technology appearing on eBay.

Glenn Vanderburg presents Cló, a Clojure library that reimplements TeX's core typesetting algorithms as composable functions. He shows what translating procedural, literate-programming code into functional form teaches.

An American Airlines training video by Captain Warren VanderBurgh on control malfunctions and flight instrument anomalies. It discusses real incidents such as runaway trim and instrument failures and how crews should respond.

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.

Philip Wadler's Strange Loop talk on Propositions as Types, the link between logic and computation (the Curry-Howard correspondence). He traces its history through Church, Godel and Turing and shows how it shaped theorem provers and programming languages.

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.

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.

Brandon Rhodes' PyOhio 2014 talk on applying the Clean Architecture in Python. He shows how this high-level design pattern fits Python's features and addresses maintainability problems in large applications.

Evan Czaplicki's Strange Loop 2014 talk surveys the many formulations of functional reactive programming and how they relate historically and theoretically. It then shows how Elm's variant enables hot-swapping and its time-traveling debugger.

Ron Pressler's Curry On 2015 talk arguing that imperative languages should not be polluted with pure functional concepts like monads. He favors simple blocking code over non-blocking styles.

Gabriella Gonzalez argues that developers misunderstand marketing as deception or hype, and applies the technology-adoption ideas of Crossing the Chasm to Haskell. She looks at what keeps Haskell from reaching mainstream programmers and what a community can do about it.

Edwin Brady presents Idris 2, a rewrite of the Idris dependently typed language, and shows type-driven development in practice. The demos show the compiler filling in whole functions from their types.

3Blue1Brown's second neural network chapter explains cost functions and gradient descent, showing how a network learns by minimizing error during training.

Douglas Crockford's Nordic.js 2014 talk on 'the better parts' of JavaScript and programming in general. He argues against `this`, `new` and ES6 classes, and for classless, composition-based object patterns, with some broader remarks on building better structures for the future.