incremental compilation

Yaron Minsky of Jane Street shows how the OCaml Incremental library lets trading UIs express data transformations that are easy to read and efficient on streaming data. It includes a live table demo.

Paul Phillips, a former Scala core contributor, argues after moving a million lines of code that much of what the software industry does is wrong. He critiques Scala and compiler design and calls for better approaches.

Martin Odersky's JVM Language Summit 2015 talk argues that compilers can be thought of as databases. It describes design ideas for the Scala compiler and for developer tools.

Alan Kay speaks at the DEMO Founder School session on why real progress takes invention rather than incremental innovation. He argues for problem-oriented thinking and long-term research funding.

Konrad Malawski's Strange Loop 2023 talk shows how the FoundationDB team adopted Swift incrementally in a C++ codebase. It covers Swift's C++ interoperability, which let them move single functions or entire types over one at a time.

Max Brunsfeld of GitHub presents Tree-sitter, a parsing system for programming tools that supports incremental, error-tolerant parsing. He demos its integration into GitHub.com and Atom for syntax highlighting and code navigation.

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.

Cliff Click of Azul Systems asks what a JVM is supposed to do, in a Google Tech Talk from 2011. He covers the services a JVM provides, such as garbage collection and compilation, and the messy reality beneath the abstractions.

Max Brunsfeld introduces Tree-sitter, a parsing system for developer tools that offers incremental parsing and robust error recovery through a uniform C API. The talk explains the design, based on LR extended to GLR parsing.

Charles Marohn of Strong Towns presents, in a Talks at Google session, the ideas from his book on why many North American towns struggle financially despite decades of growth. He argues for incremental, bottom-up city building as a path to local prosperity.

Andrew Kelley's roadmap talk on upcoming Zig compiler milestones, focused on compilation speed. It was given at a Zig community event in 2022.

Daniel Dunbar of Apple presents llbuild, a framework for building build systems, at the 2016 LLVM Developers' Meeting. He argues that the traditional way C compilers integrate with build systems limits compile speed, and proposes a new architecture.

Christian Thalinger presents at the 2015 JVM Language Summit on adding ahead-of-time compilation to the JVM, covering the HotSpot team's AOT work and its relation to warmup and deoptimization.

Chris Seaton talks about JRuby+Truffle, explaining how the Truffle and Graal combination optimises the tricky parts of Ruby and why it outperforms other Ruby implementations.

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.

Paul Biggar's Google Tech Talk on compiling and optimizing scripting languages, drawn from his work on the phc ahead-of-time PHP compiler. He covers runtime typing, aliasing and code generation challenges, and argues AOT can compete with JIT.

Rob Pike's October 2009 Google Tech Talk introducing Go, a new experimental systems language designed for fast builds, concurrency and garbage collection. It covers the goals, syntax and type system.

Chris Thalinger of Twitter describes the company's effort to run its Scala services on the Graal JIT compiler at Scala Days NYC 2018. It covers the performance gains Twitter saw and the work of running Graal in production.

Christopher Domas's Derbycon 2015 talk on the M/o/Vfuscator, a compiler that emits only x86 mov instructions, showing mov is Turing complete. It explains how a full machine is built from mov and why the output is a nightmare to reverse engineer.

Vim creator Bram Moolenaar's 2007 Google Tech Talk on habits for efficient text editing. He explains how to spot repetition and inefficiency, then use editor features to fix it.

Herb Sutter's CppCon 2022 talk on whether C++ can become ten times simpler and safer. He introduces his experimental Cpp2 syntax and the cppfront transpiler, explaining the limits on incremental improvement.

Lin Clark gives an illustrated, cartoon-style walkthrough of React Fiber, the rewrite of React's reconciler, explaining its incremental rendering and scheduling at React Conf 2017.

John McCall of Apple's Swift team presents at CppNow 2023 on introducing a memory-safe successor language into large C++ code bases. He argues incremental improvement of C++ hits hard limits and explains Swift's C++ interoperability for gradual migration.

Richard Feldman describes introducing Elm into a mixed React and jQuery front-end in production, and why the result was reliable, clean and fast enough to make the back-end team jealous.

Jose Valim introduces Nx, the project bringing numerical computing to Elixir, covering multi-dimensional tensors, automatic differentiation and JIT compilation to CPU and GPU.

Andrew Kelley's 2024 Zig roadmap talk, followed by a Q&A, covers the language's priorities and the state of the project. Topics include compilation speed, moving off LLVM toward a self-hosted toolchain, async, and the path to 1.0.