code visualization

Blizzard's Timothy Ford explains in this 2017 GDC session how Overwatch uses an Entity Component System architecture for layered gameplay. He also covers its server-authoritative netcode with client-side prediction and how they keep the game responsive and fair.

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.

Christopher Domas presents his Cantor Dust tool at Derbycon 2012, a 3D visual approach to reverse engineering binaries by visualizing their structure dynamically.

Christopher Domas's REcon 2013 talk on dynamic binary visualization for reverse engineering. He shows how rendering binary data as interactive visual maps and trigraphs reveals structure that hex dumps hide, leading to his Cantor.dust tool.

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.

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.

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.

Robert 'Uncle Bob' Martin speaks at Yale School of Management about clean, well-written code and what makes good software development. The talk covers his views on OOP, architecture and professional practice.

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.

Greg Young's Code on the Beach 2014 talk on CQRS and event sourcing. He argues mature domains are built on facts that occurred rather than current state, and covers the business and technical benefits.

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.

Jason Turner's CppCon 2016 talk builds a simple Commodore 64 game using C++17, showing how constexpr and const let a modern compiler produce tight 6502 code. He walks through assembly output to show abstractions being optimized away.

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.

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.

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.

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.

Philip Roberts explains the JavaScript event loop, call stack, callbacks and asynchronous behavior with live visualizations using a tool he built. It demystifies terms like non-blocking and single-threaded.

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.

David Beazley's PyCon India closing keynote, in which he live-codes a stack machine and grows it into an interpreter that runs WebAssembly, then uses it to play a Rust-written game. It requires no prior WebAssembly knowledge.

A short !!Con 2016 talk by blind developer Sina Bahram on how he uses a computer and writes code with a screen reader at about 1,000 words per minute. He plays how common interfaces sound and challenges the audience to go a day using only the keyboard.

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.

Bob Beck of OpenBSD describes the first month of LibreSSL, the fork aimed at cleaning up OpenSSL, including oddities found in the code base and why it was cleaned rather than audited cryptographically.

Jay Parlar's Strange Loop talk shows how model checkers such as Alloy can find complex bugs in a system's design without running or reading any code. He walks through modeling architectures and checking every possible sequence of operations, including a real security bug and a UI feature-interaction bug.

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.

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.

Sean Parent's CppCon 2015 talk on better use of standard containers and the goal of having no incidental data structures. It argues that proper containers can greatly simplify code.

Scott Meyers explains how CPU caches work and why they matter for performance, covering cache levels, access speeds, associativity, and effects in multithreaded code. The focus is C++ and cache-aware, data-oriented programming.

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.

Bob Beck of OpenBSD gives a BSDCan 2014 talk on the first month of LibreSSL, the OpenSSL fork. He explains why they forked, what they removed, and examples of the problems found in the OpenSSL code base.

A reverse engineer walks through fixing a ten-year-old bug in Guitar Hero III without access to its source code, using a disassembler and decompiler. It is technical but explained step by step.

Chris Celio of UC Berkeley compares the RISC-V, ARM and x86 instruction sets, with quantitative data on instruction counts and code density. It examines how the compressed extension fares against Thumb and x86.

Rich Hickey introduces Clojure to the NYC Java Study Group in the first of a two-part talk. It covers reader syntax, core data structures, code-as-data, evaluation, special operators, functions, macros and sequences, assuming no Lisp background.

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.

Kevlin Henney revisits structured programming, from Go To Statement Considered Harmful to block-structured code and object orientation. He argues it still matters for how we write code today.

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.

Ron Garret tells the story of the Remote Agent Experiment on NASA's Deep Space 1, where autonomous software controlled a spacecraft in 1999. He describes debugging Lisp code remotely from millions of miles away.

Brian Kernighan's 2009 talk at Princeton on the Elements of Programming Style, discussing readable code, avoiding cleverness and flawed examples in programming tutorials.

Walter Bright explains to the Northwest C++ Users Group how the D programming language can interface directly with legacy C++ code. He covers why C++ is hard to interface with and how D approaches the problem.