array programming

Aaron Hsu's FnConf18 talk asks whether APL needs a static type system. He argues that APL's expressiveness and rapid iteration already deliver the benefits usually credited to types.

Aaron Hsu explains why programmers often find APL harder to learn than people with no programming background. He identifies eight patterns that contrast traditional software engineering practice with APL practice, starting from Ken Iverson's language design principles.

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.

Aaron Hsu shows how to manipulate and transform tree data in APL using arrays and inverted tables instead of pointers. He claims much smaller code, better performance and easier parallelisation.

A one-minute clip of Peter Norvig saying that Google found programming contest success correlates negatively or poorly with job performance. The description links to a blog post discussing it.

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.

A panel from the Lang NEXT 2014 conference on systems programming in 2014 and beyond. Language designers including Bjarne Stroustrup and Rob Pike discuss the topic, including C++ header compile times.

Felienne Hermans's Strange Loop keynote on the history and pedagogy of teaching programming. She questions exploration-only approaches like Logo and discusses research supporting explicit instruction and rote practice.

A SXSW talk by W Watson that uses Lacanian psychoanalysis, with nods to Zizek, to critique popular programming languages. It argues that people choose and defend languages for emotional and ideological reasons rather than rational ones.

Timothy Daly, an original author of the Axiom computer algebra system, talks about turning a large Common Lisp codebase into a literate program. He argues code should be written as readable manuals, and the talk was given at Write the Docs 2013.

Kevlin Henney argues that procedural programming never went away despite later paradigms such as OO and functional. He traces the history of structured programming and shows where procedural thinking still lives in modern code and why it matters for readability.

Steven G. Johnson, MIT professor and FFTW co-author, gives a JuliaCon 2019 keynote on metaprogramming and staged programming in Julia, showing how it enables high-performance numerical code and when not to use macros.

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.

Andrew Kelley, creator of Zig, introduces the language at the Recurse Center's Localhost series in 2018. He covers its goals of robustness, optimality and clarity, C interop, cross-compilation and explicit allocators.

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.

The first video in Photon of Scoopex's Amiga hardware programming series. It shows how to set up an assembler and write a minimal 68000 program that waits for a left mouse click.

A Dyalog demonstration of developing a Sudoku solver in APL, using an algorithm by Arthur Whitney with performance work by John Scholes. The narration steps through the array-oriented solution.

Aditya Siram introduces ATS, a statically typed ML-like language that compiles to C and offers type-safe pointer arithmetic and a full proof language. The Strange Loop talk shows off C interop, concurrency and verification features with non-trivial examples.

Chris Granger, creator of Light Table and the Eve language, gives a Berkeley data science lecture on what computation and programming might look like in ten years. He covers the path that led to Eve and ends with demos.

Shriram Krishnamurthi's PWLConf 2019 talk on the formal notion of expressive power of programming languages, based on Felleisen's paper. It explains how to tell when a feature adds power by whether emulating it requires global rewriting.

John Scholes builds a depth-first tree-search operator step by step in a Dyalog APL session. It covers higher-order functions and runs the search on the N-Queens problem.

Jon Purdy's Stanford EE380 seminar giving an overview of concatenative programming, from function composition theory and history down to low-level implementation and correctness benefits.

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 1995 Sun Microsystems film about the Self programming language, a prototype-based Smalltalk relative, showing its live, graphical programming environment.

Chris Granger presents Eve, a programming environment designed to be approachable for humans, at Strange Loop 2015. The talk covers the project's approach and design ideas.

A long recorded seminar in which Alan Kay discusses object-oriented programming, probably from the mid-1980s. He covers the original idea of objects, messaging and the work done at Xerox.

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.

A roughly hour-long live hacking session in which Go team members Andrew Gerrand and Brad Fitzpatrick write the new version of tip.golang.org, the site serving leading-edge Go documentation. It is unedited pair programming on a real Go project.

A JuliaCon 2016 talk by Shashi Gowda showing an APL implementation in Julia. APL code is translated to Julia and JIT compiled to machine code.

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.

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.

A two-hour live stream in which Aaron Hsu explains the architecture, design history and aesthetic of Co-dfns, his parallel APL compiler. He walks through the code and the reasoning behind its dense style.

Bruce Hauman live-codes Flappy Bird in ClojureScript in about six minutes, using figwheel to hot-reload changes into the running game. The demo shows game behavior being changed interactively without restarting.

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.

Tom Stuart's Ruby Manor 3 talk builds FizzBuzz using nothing but Ruby lambdas, working through Church encodings of numbers, booleans and data structures. It is a hands-on introduction to lambda calculus.

An Alan Kay talk on programming and scaling, covering theoretical limits of code size, engineering versus tinkering, and biological cells as inspiration for object-oriented design.

Aaron Hsu discusses design patterns and anti-patterns in APL and why the language is productive despite its write-only reputation. He argues that idioms matter more than libraries in array languages.

Edwin Brady, creator of Idris, presents Idris 2 and demonstrates type-driven development, where the compiler assists by filling holes and suggesting implementations from types.

Aditya Siram argues that functional programming has much to learn from Smalltalk's interactivity, using Pharo and Squeak to show live, visual, explorable programming environments.