code visualization

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

TED curator Chris Anderson interviews Linus Torvalds about his personality, his engineer's pragmatism, and the creation of Linux and Git. Torvalds also discusses taste in code and why he open sourced Linux.

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.

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.

Tom7 explains how he built a SIGBOVIK 2017 paper made only of printable ASCII bytes that is also a valid DOS executable. He writes a C compiler targeting printable x86 without self-modifying code and solves the puzzles the constraint creates.

3Blue1Brown visualizes high-dimensional spheres to explain a surprising puzzle about how a sphere fits in a box as dimensions grow. It builds geometric intuition for counterintuitive properties of high-dimensional space.

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.

Julia co-creator Stefan Karpinski explains why multiple dispatch makes Julia code and types reusable across packages with so little friction. He covers sharing basic types and sharing generic algorithms.

3Blue1Brown visualizes the Riemann zeta function and the analytic continuation that extends it beyond where its series converges, building toward the Riemann hypothesis.

Matt Adereth's Clojure/conj talk covers the history of keyboards and how he used Clojure generating OpenSCAD to design and build his custom Dactyl ergonomic keyboard, including 3D printing and laser-cut parts.

An Alan Kay talk on programming and scaling, covering theoretical limits of code size, engineering versus tinkering, and biological cells as inspiration for object-oriented design.

Alex Russell's Chrome Dev Summit 2016 talk on building web experiences that work on slow, flaky networks and low-power devices. It argues developers should focus on the performance of real-world mobile hardware rather than desktop machines.

A recording of the TASBot block at Awesome Games Done Quick 2017, where a robot plays games via tool-assisted speedruns, including Super Mario 64 and Portal on an SNES via arbitrary code execution, and ending with a Twitch Plays segment. It showcases console exploits and creative hardware hacking.

Dr. Jason Fung lectures on why obesity became an epidemic since the 1970s, arguing insulin and hormones rather than calories drive weight gain. He explains why calorie counting fails and touches on low-carb eating and fasting.

Ben Eater writes a program in a made-up machine language and walks through the control logic an 8-bit breadboard CPU needs to execute it. It is part of his build-an-8-bit-computer series.