implicit context

Stuart Halloway argues that simplicity is objective, with a definition and etymology useful to programmers, rather than a subjective buzzword. He shows how this view informs Clojure's design and how to make programs simpler.

Rich Hickey's keynote at RailsConf 2012, a close sibling of his 'Simple Made Easy' talk. He distinguishes simple (not intertwined) from easy (familiar), and argues that software complexity comes from complecting things, with Rails-specific examples including large gem collections.

Alan Kay's 2015 talk on the power of simplicity, arguing that systems become simpler by building on more sophisticated fundamental building blocks and that big research horizons drove invention at Xerox PARC. It ranges across computing, tools and scaling software.

Rob Pike's dotGo 2015 talk argues that Go only seems simple, and that its simplicity hides real complexity that is part of the design. He explains the thinking behind Go's restraint in features.

James Powell's nearly two-hour PyData talk builds up Python's data model, decorators, generators and context managers, coding live in Vim. It aims to take intermediate programmers toward real Python expertise.

Jonathan Blow speaks at UC Berkeley's CSUA about how to program independent games. He argues for keeping code simple, avoiding unnecessary work, and shipping.

Rich Hickey's Strange Loop 2011 keynote separates 'simple' (not intertwined) from 'easy' (familiar or near at hand) and argues that software complexity comes from complecting things. It offers a vocabulary for judging designs and abstractions.

Jack Diederich's PyCon 2012 talk argues that classes are overused in Python and walks through real code, refactoring away unnecessary classes, exceptions and modules. It popularized the heuristic that a class with two methods, one being __init__, should be a function.

Rob Pike presents Go Proverbs at Gopherfest 2015, a set of pithy aphorisms about Go design such as 'Clear is better than clever' and 'A little copying is better than a little dependency'.

A short excerpt of Rob Pike's Lang.NEXT 2014 talk where he describes Go's target audience as young Google programmers who are not researchers. The language has to be easy for them to understand and adopt.

Rich Hickey's Strange Loop 2011 keynote distinguishing 'simple' (not intertwined) from 'easy' (familiar or near at hand). It argues that software complexity comes from complecting things and that we should pick simple constructs.

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.

Okta developer advocate Nate Barbettini explains OAuth 2.0 and OpenID Connect in a roughly hour-long talk. It starts from the problems the protocols solve and walks through the flows. The description notes the implicit flow material is now out of date.

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.

David Beazley's PyCon 2010 talk explains how the Python Global Interpreter Lock works and shows experiments where multithreaded code runs slower, even on more cores, due to lock contention and context-switching overhead.

Bret Victor's talk proposing a new kind of maker space built for seeing and understanding a project's behavior: inside it, across time and across possibilities. It argues for scientific understanding over recipes and rules of thumb.

Raph Koster's 2014 GDC Next talk on what science says about creativity, with practical steps game designers and developers can use to be more creative. It frames creativity as applying existing patterns in new contexts.

Alex Martelli's Google Developers Day talk on classic design patterns (creational, structural and behavioral) and how they appear in Python. He stresses that patterns must be studied in the context of the implementing language.

Edward Kmett speaks at the Boston Haskell meetup about type classes and the design tradeoffs of global coherence compared with other approaches to implicit instances. It covers why uniqueness of instances matters for reasoning and refactoring.

Douglas Crockford tells how JSON was discovered rather than invented, and how its simplicity made it a dominant data interchange format. He also covers surrounding history such as earlier Netscape usage and the 'Good, not Evil' license story.

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.

A Clojure/conj 2019 talk by Wilker Silva on how namespace-qualified keywords and context-free federated names can be used pragmatically for data modeling, drawn from his experience at Nubank. It builds toward a graph-based view of connecting data from many sources.

Douglas Crockford's YUIConf 2012 evening keynote tries to explain monads in a way programmers can actually understand, in the context of JavaScript. He aims to break the 'monad tutorial curse'.

Neuroscientist Beau Lotto runs the audience through color and pattern illusions to show that perception is shaped by context and evolutionary history rather than being a direct readout of the world. The talk is playful and hands-on, and it argues that the brain interprets ambiguous signals.

A Google I/O 2011 talk by Andrew Gerrand and Rob Pike on building and deploying a web application in Go. It argues that Go offers speed, reliability and simplicity together.

Robert C. Martin (Uncle Bob) gives a talk on the SOLID principles of object-oriented and agile design, in the context of encapsulation and clean code.