array languages

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.

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 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.

Evan Czaplicki, creator of Elm, examines how programming languages are funded. He looks at where compiler engineers' salaries come from, why Go has about 5 engineers while Dart has about 30, and how this limits language design.

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.

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.

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.

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.

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.

A 2007 Google Tech Talk in which Cliff Click of Azul Systems presents a lock-free concurrent hash table that scales to 768 CPUs. He explains why it is correct by reasoning in a different way than usual happens-before and memory-order arguments.

Peter Alvaro's Strange Loop 2015 talk argues that query languages let you state what you mean, and applies that to distributed programming. It covers Datalog, Dedalus and the Bloom lineage for reasoning about distributed systems.

Andrew Kelley, creator of Zig, presents practical data-oriented design techniques for shrinking memory footprint and making programs cache friendly. He ends with a case study of how these ideas sped up the Zig compiler.

Devine Lu Linvega of Hundred Rabbits talks about low-power, offline computing, esoteric languages and the Uxn virtual machine, informed by years of sailing the Pacific. The talk frames computing sustainability through a permaculture lens.

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.

Richard Feldman's GOTO Copenhagen 2022 talk on why dynamic languages like Python, Ruby, PHP and JavaScript rose in the 1990s and why each now has a popular static type checker. It argues that modern static typing recovers the advantages that made dynamic languages attractive.

Curtis Poe's FOSDEM talk arguing that day-to-day Perl 6 is far simpler than its enthusiasts' talk of exotic features suggests. He compares basic math and string handling across languages.

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.

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.

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.

Bryan Cantrill argues that programming languages and platforms reflect core values, and compares languages through that lens, with Rust as a main example. He draws on his experience with Solaris, DTrace and ZFS.

Noel Rappin's MountainWest RubyConf talk introduces Smalltalk to Ruby programmers. He compares the two languages' object models, blocks, 1-based arrays, simple syntax and live programming environment, and walks through sample code.

Alex Martelli's Google Developers Day talk on classic design patterns (creational, structural and behavioral) and how they appear in Python. He stresses that patterns must be studied in the context of the implementing language.

An AdaCore talk on the history, present and future of the Ada language, including remarks from Robert Dewar. The title and description say little else.

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.

A Google talk from the Chisel community in which engineers recount designing the Edge TPU with the Chisel hardware construction language. It covers the productivity gains and the problems they hit.

A DConf 2019 talk by Robert Schadek arguing that spreadsheets are the world's dominant programming language and that D can be used to replace them. It looks at spreadsheet quirks and then at techniques for moving away from them.

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.

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.

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.

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.

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.

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.

Rob Pike's 2010 talk at OSCON's Emerging Languages Camp on where Go's concurrency style comes from. It traces the idea from Hoare's CSP through Squeak, Newsqueak and Limbo to Go.

Stephen Kell's Strange Loop talk argues that C and Unix already contain Smalltalk-like dynamism and introspection that can be exposed. He presents his liballocs research on bridging dynamic and compiled languages.

RustConf 2020 closing keynote by Sian Griffin that dives into Pokemon Blue glitches, notably Missingno and arbitrary-code-execution tricks. It uses them to explain how memory unsafety works and how memory-safe languages like Rust prevent such bugs.

Swift compiler engineers explain how Swift implements generics using dictionary-passing with reified type metadata. They compare it with Java-style uniform representation and C++ or Rust monomorphization.

Isaac Yonemoto's ElixirConf 2021 talk on Zigler, a library for writing Elixir NIFs in Zig. He looks at its internals and how it bridges the two languages while keeping the NIFs well behaved on the BEAM.

Lars Bergstrom of Google presents how Rust improves team productivity beyond safety and speed, with data on rewrites, defects and review. It compares Rust teams to those on legacy native languages and Go.