legacy code

Michael Feathers' GOTO Chicago 2018 talk on reducing error checks and conditional logic in code. He offers a framework for handling errors and decisions at the level of code and architecture.

Casey Muratori shows how typical 'clean code' object-oriented patterns can cost large factors in performance. He benchmarks them against simpler data-oriented code.

3Blue1Brown's discovery-oriented introduction to error correction codes, building up Hamming codes from the puzzle of locating a flipped bit. It explains the parity-check idea and why it is so efficient.

MattKC fits a playable Snake game into a QR code by writing tiny x86 machine code and patching the ZBar scanner so it can run the decoded data.

OpenAI's 2021 live demo of Codex translating natural language into code, from Hello World to building a game and a Microsoft Word plugin.

Ned Batchelder's PyCon 2012 talk gives a quick overview of what Unicode is, then focuses on what a Python programmer needs to handle text correctly. It presents the 'Unicode sandwich' strategy: decode bytes at input, work with Unicode internally, encode at output.

Veritasium builds a QR code by hand to explain how it works. It covers the history of Morse code and barcodes, how QR codes encode data, why damaged codes still scan, and how safe they are.

Elm creator Evan Czaplicki's talk on how a file grows and when to split code up. He argues for keeping code in one file until it hurts and warns against premature extraction.

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.

A DEF CON 29 talk by Richard Henderson about encoding the EICAR antivirus test string into QR codes and barcodes and scanning them at real systems. Many systems that do not expect such input misbehave or collapse, including a parking garage system.

8-Bit Show And Tell walks through the BASIC source code of the original Commodore 64 Sid Meier's Pirates!. It covers bugs, quirks and traces of abandoned features and scenarios left in the code.

Raymond Hettinger's PyCon 2013 talk on transforming code into idiomatic Python through a series of before-and-after refactorings. It shows how to use iterators, dictionaries, named tuples and other language features well.

Misko Hevery's Clean Code Talk shows how to use object-oriented techniques such as polymorphism to remove repeated if and switch statements. The result is code that is easier to test, understand and maintain.

Casey Muratori's invited lecture on where bad code comes from, rebroadcast from a Twitch stream. He critiques conventional wisdom such as SOLID and Clean Code and argues about how those habits lead to slow, poorly structured software.

Brian Will follows up his earlier anti-OOP video by walking through four short code examples, including Java code in the style of Uncle Bob, to show how object-oriented design complicates simple programs. It argues that OOP hides and scatters state and adds needless indirection.

Evan Czaplicki, creator of Elm, gives an elm-conf 2016 talk on the non-code side of building a language. It covers the philosophy behind Elm's development approach, including batching work and the priorities of different language communities.

Paul Irish walks through the jQuery source code and shares ten lessons and interesting techniques from it, aimed at JavaScript developers who want to learn from a widely used library.

Adam Tornhill's GOTO Copenhagen 2019 talk on how to prioritize technical debt in large codebases. It argues for combining code complexity with change frequency (hotspots) from version control data, rather than trying to quantify debt in the abstract.

A Y Combinator video on vibe coding, the term Andrej Karpathy coined for letting LLMs write code. It reports what YC founders say about debugging, models and how much of their code is AI-written.

Greg Kroah-Hartman's Linaro keynote on contributing to the Linux kernel, explaining why maintainers prefer upstreamed code and how they view contributions.

Dan Abramov's talk on the wet codebase, using visualizations to show how removing all duplication too early produces wrong abstractions that are hard to unwind.

Pokey Rule presents Cursorless, a spoken language designed for editing code by voice, built on tree-sitter parsing with smart structural and simple token-level primitives. The talk is from Strange Loop 2023.

Matt Parker follows the community effort to speed up his slow Wordle-solving code, which ended up running hundreds of millions of times faster. He walks through the techniques contributors used.

Tavis Rudd describes how RSI forced him to program by voice, and shows the Python and Emacs Lisp system he built with voice recognition. A live demo creates and deploys a small system without touching the keyboard.

Bryan Cantrill's Monktoberfest 2016 talk on how software engineers pass knowledge down through oral tradition, from folk rhymes to programmer lore and stories like why C lacks a logical XOR. He argues for writing software with future generations in mind.

Brian Fitzpatrick and Ben Collins-Sussman argue that the 'genius programmer' ideal harms collaboration. They advocate trading ego for growth, sharing work early, and understanding how tools shape social behavior.

Brian Will critiques object-oriented programming and rewrites a roughly 3800-line OO program in a procedural style, cutting code and complexity. It is part of a series of OOP critiques.

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.

Erlang co-creator Joe Armstrong's Code BEAM SF 2018 keynote revisits good ideas from the history of computing that were dropped, and asks which should be revived. It also touches on Erlang and Elixir.

Joe Armstrong, creator of Erlang, and Jeremy Ruston, creator of TiddlyWiki, discuss hypertext, Ted Nelson's idea of intertwingled knowledge, and a way to combine TiddlyWiki with Erlang. It is a Code Mesh LDN 2018 talk.

Douglas Crockford's code::dive 2022 talk on what the next programming language should look like. He presents ideas behind his Misty language, including message-passing actors.

A 2018 GDC talk by NetherRealm's Michael Stallone on the engine changes, optimizations and tooling needed to roll back and re-simulate up to 8 frames in 16 ms in Mortal Kombat and Injustice 2. It is a deep dive into deterministic rollback netcode.

Raymond Hettinger explains Python's dataclasses module, showing the problem it solves and its key design decisions. He places it in a progression from tuples and dicts through named tuples and attrs.

LearnCode.academy presents a roadmap of web development technologies to learn in 2016 and 2017, spanning front-end, back-end and DevOps tools.

Edwin Brady presents Idris 2, a rewrite of the Idris dependently typed language, and shows type-driven development in practice. The demos show the compiler filling in whole functions from their types.

Code Rush is a one-hour documentary following Netscape engineers in Silicon Valley through the company's last year as an independent firm. It covers the Mozilla open-source announcement, the frantic push to ready the source for release by March 31, 1998, and the toll on engineers' lives before the AOL acquisition.

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.

Irving Finkel of the British Museum lectures at the Royal Institution on the invention and decipherment of cuneiform writing in Mesopotamia, and why it is so hard to translate.

Code Rush is a 2000 PBS documentary following Netscape engineers during the year they open-sourced the browser as Mozilla. It shows the pressure and long hours of work in Silicon Valley at the height of the dot-com era.

Leslie Lamport argues that programmers, like architects, should write rigorous specifications before coding, especially for concurrent and distributed systems. The talk introduces the case for writing specs (the TLA+ mindset) as a way of thinking above the code.