tool

Tim Ewald's Clojure/conj talk uses furniture making with hand tools versus machine tools as an allegory for software. It explores how automation changes what we make and how we think about our work, and why Clojure's small set of simple tools matters.

Paul Irish and Pavel Feldman present the newest Chrome Dev Tools features at Google I/O 2011, including live CSS editing, saving changes, breakpoints and network analysis. It also covers remote debugging.

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.

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.

Philosopher Daniel Dennett visits Google to discuss his book Intuition Pumps and Other Tools for Thinking, describing thought experiments and thinking tools across psychology, biology, computer science and physics.

Matthew Griffith, creator of elm-ui, presents a toolkit for designing layouts in Elm as an alternative to CSS. He explains the opinionated approach to layout and styling.

Google I/O 2011 session by Ray Cromwell and Philip Rogers on writing 2D and 3D games with HTML5 and GWT. It covers porting game libraries and physics engines, sharing code with Android, and publishing to the Chrome Web Store, and showcases the ForPlay library.

Scott Wlaschin demystifies functional programming terms like monads, monoids, functors and catamorphisms by showing how they fit into a small toolkit. He applies them to problems such as missing data, list handling, and functional dependency injection.

Urban Bruhin, LibrePCB's main author, introduces the open-source EDA tool at FOSDEM 2018. He explains why he started it and how its library concepts differ from KiCAD.

Chandler Carruth's CppNow 2023 talk on modernizing compiler design for the Carbon toolchain, using data-oriented design and modern hardware assumptions. It covers lexing, parsing and compact data structures aimed at compiler performance.

Steve Yegge's Stanford seminar on GROK, Google's internal large-scale, cross-language source code analysis system. It covers how the system helps with code search and understanding across Google's huge codebase.

Bret Victor's talk from Dropbox's DBX conference about living by a guiding principle, in his case that creators need an immediate connection to what they are making. He shows live-coding and time-manipulation demos that let ideas take form at the speed of thought.

Bret Victor's talk "Inventing on Principle" argues that creators should find a guiding principle to fight for. He shows demos of immediate-feedback tools, such as live-updating code and animation editors.

Bret Victor's talk at CUSEC 2012 in which he argues that creators need immediate feedback and should organize their work around a guiding principle. He demonstrates live-coding and animation tools that show results as you type, and describes his own principle that creators must see what they are making.

Bruce Hauman presents Figwheel, a ClojureScript tool for live, interactive development with hot code reloading. He explains the main ideas, demonstrates how it works, and shares tricks for getting the most out of it.

A one-hour OCaml Workshop 2020 talk on the state of the OCaml Platform, covering IDE support, next steps for the tooling and plans for 2020-2021.

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.

Rachel Potvin describes the scale of Google's codebase and its custom monolithic source repository. She explains the reasons for the monorepo model, the tooling that makes it workable, and its tradeoffs.

Tudor Girba's Curry On! 2019 talk on moldable development, the idea that developers should build custom tools and views for each software system they work on. It draws on the Pharo and Glamorous Toolkit environments.

Dan Abramov live-codes hot reloading with time-travel debugging at React Europe 2015, debuting Redux and its devtools. The slides themselves are driven by application state.

Cheng Lou's react-europe 2016 talk lays out a mental framework for thinking about abstraction levels in JavaScript tooling, from Angular and Grunt to Webpack and React. It uses that framework to reason about the cost of abstractions and how to choose between competing solutions.

Paul Irish's Chrome Dev Summit 2016 talk surveys the state of the art in Chrome DevTools debugging. It covers workspaces, diffs, CSS coverage, Node debugging, editor improvements and Lighthouse.

Bret Victor's talk on Drawing Dynamic Visualizations. It argues that visualization tools offer either the directness of hand drawing or the dynamics of programmed graphics, and shows a tool that combines both.

A RacketCon talk presenting Fructure, a prototype extensible structured editing engine in Racket. Language providers define syntactic forms and refactorings as rewrite rules, and editing operates on program structure rather than on text.

Perry Metzger, an Emacs user since 1983, gives a talk on why he has used one editor for decades. It mixes history, philosophy and speculation about Emacs's future, and teaches some Emacs fundamentals.

Gil Tene of Azul Systems explains common pitfalls in measuring latency and response time, including why averages mislead and the problem of coordinated omission. He introduces open source tools like HdrHistogram for better measurement and reporting.

Titus Winters' CppCon 2017 talk argues for C++ and Google's Abseil to be maintained as a live at head language, relying on testing and automated tooling rather than never changing or promising no compatibility. It covers Hyrum's law and the limits of semantic versioning.

Dirk Hohndel explains why the Subsurface dive log project migrated from Gtk to Qt, the obstacles encountered, and advice for other applications frustrated with Gtk. It is a linux.conf.au 2014 talk.

Matt Godbolt's CppCon 2017 talk shows what modern compilers do with your C++ code, using Compiler Explorer to inspect generated assembly. It covers surprising optimizations and how the tool works.

Science writer Jay Dixit explains how he uses Emacs as a non-programmer to write, edit and research more productively. He shows his plain-text writing workflow and what led him from tools like Scrivener to Emacs.

Gary Bernhardt's Cascadia Ruby Conference 2011 talk on using the Unix shell for practical problem solving. He builds pipelines interactively by iterative refinement, using small tools as levers.

TJ DeVries coins the term PDE (Personalized Development Environment) to describe editors like Neovim that you shape to your own workflow. He contrasts this with out-of-the-box IDEs and discusses why customizable tools appeal to developers.

Google engineers describe Google's internal build system, a unified, language-agnostic system used across the company. It was presented as a 2012 NYC tech talk.

Chandler Carruth's GoingNative 2012 talk on Clang, covering how the compiler helps defend C++ code from mistakes. It makes the case for Clang's diagnostics and tooling.

An F8 2015 talk touring the tool-chain Facebook uses to let thousands of engineers build mobile apps, including its move to Mercurial, an Atom-based IDE and continuous integration.

Sandi Metz takes an ugly section of conditional code and refactors it into a few simple objects, bridging object-oriented theory and practice. The talk includes her take on the Gilded Rose refactoring kata and the idea that duplication is cheaper than the wrong abstraction.

Will Wilson of FoundationDB explains how the team tested their distributed database using deterministic simulation. By running the whole system in a simulator with injected faults and reproducible seeds, they could find rare concurrency and network bugs.

Ian Cooper's DevTernity talk revisits Kent Beck's original TDD ideas and shows where misunderstandings crept in. It argues tests should target behaviors through public interfaces rather than implementation details, so suites support refactoring instead of resisting it.

Rafal Dittwald's Clojure/north talk shows how to move from writing Java-style code in Clojure to thinking in data-driven, functional terms. He walks through a JavaScript example, refactoring imperative code step by step into a functional core.

Bryan Cantrill's GOTO Chicago 2017 talk on debugging production systems under pressure, centered on the incident where an operator's mistyped command rebooted an entire Joyent datacenter. It covers human factors, automation and architecture.