composable parallelism

Rob Pike's Go talk distinguishing concurrency, the structuring of independent processes, from parallelism, their simultaneous execution. It uses Go channels and goroutines to illustrate.

Kiran Pamnany's Cambridge Julia Meetup talk on Julia's shared memory parallelism and its new task scheduler. It argues that fork-join and work-stealing models nest poorly and presents depth-first scheduling for composable parallelism.

Jonathan Worthington's YAPC Asia 2015 talk on parallelism, concurrency and asynchrony in Perl 6. It covers the language's concurrency features.

Andrei Alexandrescu's CppCon 2015 talk argues that std::allocator is badly designed. He proposes building high-performance allocators from small composable, templated pieces.

Simon Peyton Jones explains nested data parallelism and Data Parallel Haskell, an approach to exploiting multicore and distributed hardware while keeping a simple single-control-flow programming model.

Guy Steele's Strange Loop 2010 talk argues that programmers should not have to think about parallelism, and that languages should support algorithms built on independence and divide-and-conquer. He also recounts fitting a program onto a single punch card.

Guy Steele presents a small geometric problem and compares four computational approaches: a classic sequential solution and three parallel-friendly ones. Each is illustrated pictorially and with working code, weighing total work against time to solution.

Jack Moffitt presents the architecture of Servo, Mozilla's experimental browser engine written in Rust, focusing on parallelism across cores, GPUs and SIMD and the safety properties gained from Rust.

Jack Moffitt presents Servo, an experimental browser engine written in Rust and designed to be parallel at every level, using multiple cores, the GPU, fork-join concurrency and SIMD. The talk covers motivations, architecture and plans for the project.

Guy Steele's JuliaCon 2016 keynote on the Fortress language, its features and the lessons learned from the project.

Alan Kay's tribute to Ted Nelson at the Intertwingled festival, presented using a revived Smalltalk-78 system running on emulated 1970s Xerox PARC hardware. It shows live, user-programmable software from that era.

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.

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.

A short animated simulation comparing how Multics and Unix were developed, showing why Unix's small composable programs and pipes gave it a efficiency advantage. It frames Unix as a moonshot achievable by a small team.

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.

Andrew Adams, a Halide developer, presents the Halide language for image processing and tensor computation. The talk explains the separation of algorithm from schedule with illustrated examples of parallelism, locality and redundancy tradeoffs.

Edward Kmett's talk to the NY Haskell User Group on the lens library, building from fmap and function composition up to lenses, folds and traversals. It shows how these composable combinators access and modify parts of data structures.

Sasa Juric's EMPEX talk demonstrates Elixir and Erlang's process model and what makes the BEAM runtime distinctive, such as fault-tolerant parallelism by design.

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.

The second talk in the Mill CPU series by Mill Computing, covering the Belt, the Mill's operand-passing model that replaces general registers. It explains the cost of register renaming in conventional wide CPUs and how the Belt reaches high instruction-level parallelism.

Machine Learning Street Talk interviews Paul Lessard about Categorical Deep Learning, which uses category theory and monads to make neural network architectures more interpretable and composable. They also discuss neural networks' limits in reasoning and unbounded computation.