layer effects

A 2016 conference talk by a mobile game CEO on the tricks of free-to-play monetization, including player profiles and how to target high-spending whales.

Alexis King's ZuriHac 2020 talk on how effect systems in Haskell can be implemented efficiently. It looks at the performance cost of effect libraries and how to reduce it.

Civilization creator Sid Meier's GDC 2010 talk on applying psychology to game design. He discusses player perception, randomness, and win states, and why designers must account for how players experience events.

Richard Feldman argues that functional programming is not the norm largely because of historical accidents, such as C++ popularity, platform exclusivity, marketing spend and network effects, rather than merit. He traces the history of how languages become mainstream.

Moxie Marlinspike's DEF CON 18 talk on changing threats to privacy argues that surveillance arrived through convenient services and network effects, so opting out is not a real solution. It also includes his framing of getting social democracy rather than the fascism people feared.

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.

Sid Meier's GDC 2010 keynote on how players perceive probability in games, including how Civilization's odds were adjusted because players misjudged them.

Gary Bernhardt's RubyConf 2012 talk on testing in isolation without mocking everything. It goes through behavior versus data, mutation versus immutability, and how a functional core with an imperative shell yields natural isolation and parallelism.

Emery Berger argues that performance is hard to measure and deliver on modern systems, showing how code layout and link order can swamp optimization effects. He presents tools that evaluate performance more reliably.

Robert C. Martin (Uncle Bob) talks about clean architecture and design, including keeping the database and frameworks out of the center of an application. It is an hour-long conference talk.

Martin Jonasson and Petri Purho take a bland Breakout clone and add layer after layer of 'juice' such as easing, particles, screen shake and sound until it feels alive. A live demo makes the effect of small feedback details obvious.

Vlambeer's Jan Willem Nijman shows how to make an action game feel great by stacking small effects like screenshake, recoil and particles onto a basic shooter. It was presented at INDIGO Classes 2013.

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.

Emery Berger explains why performance is hard to measure and deliver on modern hardware, showing how code layout and alignment can swamp optimization effects. He presents Stabilizer for statistically sound evaluation and Coz, a causal profiler.

Andrew Ng presents unsupervised feature learning and deep learning, showing how algorithms can learn representations from unlabeled data instead of hand-designed features. He gives examples in vision and audio, including visualizations of features learned by successive layers.

Jonathan Blow's DevGAMM 2019 talk argues that software knowledge is being lost between generations and that growing layers of abstraction could lead to a decline in technological civilization.

Biologist Michael Levin explains the bioelectric layer that coordinates cells to build organs and bodies, showing footage of two-headed worms and introducing xenobots. He discusses implications for medicine and the nature of life.

Chris Ford builds up from a single sine wave through layered abstractions to a Bach canon, using Clojure and the Overtone audio environment. The talk shows music theory as a natural fit for functional programming.

Shashi Tharoor's Oxford Union speech arguing that Britain owes reparations to its former colonies, focused on the effects of British rule in India. It lists economic and political damage done by colonialism.

Jonathan Blow's 2010 Rice University talk argues that game designers refine their techniques in ways that can manipulate players, as with A/B-tested social games. He discusses the ethical responsibility of designers and what games can offer beyond addiction.

A 2018 GDC panel where Raph Koster, Starr Long, Richard Garriott and Rich Vogel look back on what went right and wrong building and running Ultima Online. They share candid stories from the early days, including player behavior and server architecture.

David Heinemeier Hansson explains what he learned about indoor air quality after his new house made his family sick. He covers CO2, VOCs, off-gassing, HVAC and ventilation, and cognitive effects, presented at a Basecamp meetup.

Carl Sagan's December 1985 testimony to Congress on the greenhouse effect, about 15 minutes long. He lays out CO2 warming, the risk of runaway effects and the danger of continued coal burning.

A talk by Yuri Iozzelli at a WebAssembly meetup on CheerpX, an x86 virtual machine running in the browser. It uses a JIT compiler that emits WebAssembly at runtime to run real native applications. It covers the architecture and demos such as porting a multiplayer C++ game.

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.

Bryan Cantrill's Velocity NYC 2015 talk argues for running containers directly on bare metal rather than layering them on virtual machines. He covers the history of containers and how SmartOS runs Linux workloads via syscall emulation.

David Schachter describes how he made a data-collection Python program run 114,000 times faster, drawing on decades of experience. The talk covers pipelining, cache effects and other optimization lessons.

Jonathan Blow talks at Gamelab 2018 about the design decisions behind Jai, the programming language he is building for game programmers. He covers low-friction development, quality of life and the effects of compile times.

David Brevik's GDC 2016 post-mortem of the original Diablo, covering how it evolved from a turn-based claymation DOS game into the genre-defining action RPG. It includes development anecdotes and lessons learned.

Matt Ranney of Uber talks at GOTO Chicago 2016 about what Uber learned from growing past 1,000 production microservices. He covers regrets, sprawl and organizational effects.

Matt Kulukundis reviews two years of Abseil's Swiss table hashtable, covering post-release optimizations, lessons from rolling it out across Google, design choices, and what global monitoring revealed.

Psychologist Kelly McGonigal argues in this TED talk that stress is harmful mainly if you believe it is, and that reaching out to others is an underrated way to reduce its effects.

Stuart Halloway shows how Clojure's spec library lets you build programs that are both agile and robust. He covers declarative, predicate-based specification layered on interactive REPL development.

Geoff Hinton's 2010 Google Tech Talk on deep belief networks, learning layers of representation one at a time from unlabeled data, and extending them with multiplicative interactions.

Michael Green of Thiel Macro presents a thesis that the growth of passive investing distorts how markets price new money flows. He ties short-term market behavior to longer-term demographic cycles and its effects on valuations and volatility.

Matt Godbolt builds a toy path tracer in C++ in three different styles and compares them on clarity, testability, compile time and run-time performance. The talk was given at CppCon 2019.

Steve Jobs introduces the first iPod at a small Apple event in 2001. He positions it as a music player and ties it to the Apple brand.

Tom Dale explains the internals of the Glimmer VM, Ember's rendering engine, which compiles templates to opcodes. The talk includes a performance benchmark demo.

Richard Wilkinson presents data showing that societies with larger income gaps do worse on health, lifespan, trust and other measures. He argues the effects track inequality itself rather than average income. It is a 17-minute TED talk.

A Graphics Programming Conference talk on how the game Tiny Glade renders meadows, trees and player-built castles. It covers real-time global illumination, tilt-shift depth of field, stable shadows with continuous time of day, ray marching and GPU-driven rendering on old hardware.