foundry model

Scott Wlaschin's NDC talk on using statically typed functional programming, F# in particular, to model a business domain. Types are used to represent the domain precisely and to encode business rules so that illegal states cannot be built, with the compiler acting as an instant unit test.

Richard Feldman's elm-conf talk on designing models so that bugs from impossible application states cannot occur, using Elm's compiler and types. It demonstrates techniques for making invalid states unrepresentable.

Andrej Karpathy gives a one-hour general-audience introduction to large language models, covering what they are, how they are trained, comparisons to operating systems, and security challenges such as jailbreaks.

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.

Scott Wlaschin shows how statically typed functional languages, using F# examples, can model a business domain so that invalid states cannot be represented. The type system acts almost like an instant unit test at compile time.

A panel with Tony Hoare, Joe Armstrong and Carl Hewitt, hosted by Francesco Cesarini, on the history and future of concurrency. The three creators of CSP, Erlang and the actor model discuss their differing approaches.

Luke Wagner of Fastly explains what a WebAssembly component is, how it relates to familiar concepts, and what the Component Model enables. It emphasizes security, composability and modularity.

Simon Brown's Agile on the Beach 2019 talk presents the C4 model, a lightweight approach to diagramming software architecture with a shared vocabulary and simple notation.

A JuliaCon talk by a NASA Launch Services Program engineer on modeling spacecraft separation dynamics in Julia. He describes replacing a Simulink-based workflow for checking launch vehicle separation requirements with Julia and ModelingToolkit, with large speedups and much shorter code.

A DEF CON 23 talk by Marc Rogers and Kevin Mahaffey walking through the architecture of the Tesla Model S, what Tesla got right and wrong, and how the interconnected systems can be hacked. It also covers the data the car collects.

Rich Hickey's Clojure/Conj 2018 keynote argues that Maybe/Option types and rigid type signatures are a poor way to model data that changes over time. He builds the case around optionality, schema growth and compatibility, and presents the ideas behind Clojure spec as an alternative.

Zig creator Andrew Kelley's RedisConf 2020 talk on modeling data flow with asynchronous I/O in Zig. It explains how Zig's async/await avoids function coloring, and Loris Cro demonstrates OkRedis, a zero-allocation Redis client.

Olivier Giroux's CppCon 2019 talk recounts the roughly ten-year effort to bring std::atomic and the C++ memory model to CUDA GPUs, through ten stories from that work.

Sasa Juric explains what makes Erlang and Elixir suited to server-side systems, focusing on the BEAM concurrency model rather than syntax or ecosystem. He demonstrates processes, supervision, and fault tolerance.

Rick Houlihan's AWS re:Invent 2018 deep dive on advanced DynamoDB design patterns. It covers index overloading, GSI sharding, composite keys, graph processing and transactions.

Audio of Charlie Munger's 1995 Harvard speech on the psychology of human misjudgment, laying out a framework of cognitive biases and mental models for decision making. It covers factors like incentives, social proof and denial.

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.

Martin Fowler's GOTO 2012 introduction to NoSQL databases: where they came from, their data models, how consistency thinking differs, and when to use them. He argues they won't make relational databases obsolete and introduces polyglot persistence.

Herb Sutter's deep C++ and Beyond 2012 talk on atomics and the C++ memory model, covering why programmers chasing top performance need to understand hardware ordering. This is part one of two.

A five-minute excerpt of Rich Hickey's Clojure Made Simple talk, with new slides, ranting about HttpServletRequest and specificity. He argues for using generic maps instead of many specific classes and getters.

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.

David MacKay's 2007 Google Tech Talk presents Dasher, a text-entry system driven by continuous gestures and a language model, reaching about 35 words per minute with one finger and 25 hands-free. It explains the information-theory reasoning behind the design.

Johann Korndorfer's NVScene 2015 talk on building content with signed distance functions. It focuses on patterns that make SDF modelling more structured, arguing that SDFs capture a shape's essence like vector graphics do compared with polygons or voxels.

Part two of Herb Sutter's C++ and Beyond 2012 session on atomic weapons, a deep dive into the C++ memory model, atomics, memory ordering, and hardware behavior. It ends with the modern meaning of volatile.

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.

UC Berkeley EECS colloquium by OpenAI's John Schulman on reinforcement learning from human feedback. He covers why RL helps with truthfulness, hallucination, and the limits of behavior cloning.

An AWS re:Invent 2019 session for advanced DynamoDB users on design patterns used by large customers, including Amazon retail. It covers GSI sharding, index overloading, graph processing, composite keys and transactional workflows.

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 Linux.conf.au 2013 talk that explains git's internal model using a playful, toy-based approach. It presents git operations as operations on a graph of commits, aimed at people who find git confusing.

Sociologist and comedian Harald Eia argues in a TEDxOslo talk that Nordic social democracies produce more rich people per capita than the US or UK. He credits high taxes, welfare and strong unions for creating a safety net that enables risk taking.

Jafar Husain's ACM keynote presents Netflix's JSON Graph and Falcor, which let web developers treat all cloud data as one virtual JSON model. It combines reactive programming with REST principles.

Kelsey Hightower introduces Kubernetes to sysadmins at PuppetConf 2016, with a demo. He explains the declarative model and how it changes the contract between infrastructure and applications.

David Rock gives a Google Tech Talk based on his book Your Brain at Work, using neuroscience to explain why focus and productivity are hard at the office. He gives strategies for managing mental energy and distraction.

Scott Jenson, a veteran UX designer formerly at Apple and Google, argues that the 'UX/UI' split pits programmers against designers and narrows ambition in open source. He makes the case that desktop UX has stagnated and that open source projects could lead experimentation beyond current interaction models.

James Gosling gives a personal talk at the 50th anniversary seminar of Simula about using the language from 1974 and how it shaped his thinking. He explains how Simula's object model and coroutines influenced the design of Java.

Jason Cohen's MicroConf talk on designing a bootstrapped business by starting from your own strengths, goals and constraints. He works backward to the business model, pricing, market and product that fit, with practical points like annual prepay and pricing tiers.

Richard Cook's short Velocity 2013 talk on resilience in complex adaptive systems, arguing systems operate near the edge of failure and that the surprise is how rarely they fail. He presents a model of how pressures push systems toward failure boundaries.

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.

Mark Bastian contrasts top-down object-oriented design with bottom-up, data-oriented design in Clojure. He models a board game as plain data plus small composable functions and compares it with a roughly 22-class OOP version.

In this 2019 GDC session, Petri Purho of Nolla Games explains the technical side of Noita's physics engine, including scaling a falling-sand simulation to large continuous worlds and adding destructible rigid bodies. It also shows how the emergent physics drives the gameplay.