event loop

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.

Jake Archibald's JSConf.Asia 2018 talk "In the Loop" explains the browser event loop, covering tasks, microtasks, requestAnimationFrame, and how rendering interleaves with JavaScript. It uses visual walkthroughs to show why code runs in surprising orders and why setTimeout fixes are unreliable.

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.

Greg Young, who coined CQRS, gives an in-depth GOTO 2014 talk on what event sourcing is, when it is valuable and when it is not, along with its trade-offs and common misconceptions.

Greg Young, who coined CQRS, looks back on a decade of domain-driven design, CQRS and event sourcing at DDD Europe 2016. He discusses where event sourcing applies and how simple its core can be.

Martin Fowler's GOTO Chicago 2017 talk on the different things people mean by event-driven architecture. He identifies four patterns, including event notification and event-carried state transfer.

Konrad Malawski's Strange Loop 2023 talk shows how the FoundationDB team adopted Swift incrementally in a C++ codebase. It covers Swift's C++ interoperability, which let them move single functions or entire types over one at a time.

Martin Kleppmann argues that databases are global shared mutable state and proposes treating them as an ever-growing log of immutable facts. Derived data such as caches, indexes and views is then built by stream processors like Apache Samza. The talk draws on Kafka and LinkedIn's experience with commit logs.

Evan Czaplicki, creator of Elm, examines how programming languages are funded. He looks at where compiler engineers' salaries come from, why Go has about 5 engineers while Dart has about 30, and how this limits language design.

Reggie Watts performs at TED 2012, blending vocal looping, beatboxing, poetry and comedy across musical genres in a larger-than-life improvised set.

Martin Kleppmann's Kafka Summit 2018 keynote asks whether Kafka can be considered a database. He covers event logs and related data-systems ideas.

Jack Rusher's Strange Loop 2022 talk argues that most programming languages are still designed around punchcard-era assumptions. He makes the case for live, interactive programming environments, drawing on Lisp, Smalltalk and REPL-driven development.

Guy Steele's Strange Loop 2010 talk argues that programmers should not have to think about parallelism, and that languages should support algorithms built on independence and divide-and-conquer. He also recounts fitting a program onto a single punch card.

Pokey Rule presents Cursorless, a spoken language designed for editing code by voice, built on tree-sitter parsing with smart structural and simple token-level primitives. The talk is from Strange Loop 2023.

Martin Kleppmann's GOTO Berlin 2016 talk on how collaborative editors, offline apps, and multi-datacenter databases handle concurrent updates. It covers conflict resolution approaches including operational transformation and CRDTs, with a worked look at text CRDTs.

Ryan Dahl's JSConf EU talk introducing Node.js to the world. He explains the motivation for event-driven, non-blocking I/O, with JavaScript chosen mainly for its asynchronous nature.

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.

Joe Armstrong, co-inventor of Erlang, gives a funny and opinionated Strange Loop talk on the tangled state of software: build tools, package managers, entropy and the physical limits of computation. He argues for ideas like naming things by content hash and throwing away your first version.

Michael Hendricks of PriceCharting shares tricks and pain points from running Prolog in production for 18 months at Strange Loop. It argues Prolog is a productive modern language beyond logic puzzles, and includes a demo of changing code mid-execution.

Evan Czaplicki's Strange Loop 2014 talk surveys the many formulations of functional reactive programming and how they relate historically and theoretically. It then shows how Elm's variant enables hot-swapping and its time-traveling debugger.

Jon Moore's Strange Loop 2017 talk argues that rate limiting is the wrong tool for protecting services from noisy clients. He proposes concurrency-based capacity management and quotas instead.

Aditya Siram introduces ATS, a statically typed ML-like language that compiles to C and offers type-safe pointer arithmetic and a full proof language. The Strange Loop talk shows off C interop, concurrency and verification features with non-trivial examples.

Devine Lu Linvega of Hundred Rabbits talks about low-power, offline computing, esoteric languages and the Uxn virtual machine, informed by years of sailing the Pacific. The talk frames computing sustainability through a permaculture lens.

Chris Granger presents Eve, a programming environment designed to be approachable for humans, at Strange Loop 2015. The talk covers the project's approach and design ideas.

Felienne Hermans presents Hedy, a gradual programming language for teaching kids that moves through levels from almost no syntax toward full Python. The talk covers why error messages and syntax are scary for beginners.

Michael Arntzenius's Strange Loop talk on Datafun, a functional query language that brings database-style querying into a general-purpose language. It discusses bridging database theory and programming languages.

Adam Neely's Ableton Loop 2017 talk links rhythm, pitch and synaesthesia. He shows that polyrhythms sped up become chords, so tempo and pitch are related by ratios.

Sean Parent's GoingNative 2013 talk surveys new and overlooked C++ features and shows how to use them for simple, correct, clear code. It stresses using standard algorithms rather than raw loops.

Ryan Dahl tells the history of Node.js and why he created it at a Phoenix meetup. He explains the push for non-blocking IO on a clean slate rather than extending an existing ecosystem.

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.

Raymond Hettinger's PyBay 2018 keynote on preventing, finding and fixing bugs under a time budget. He covers testing practice, type annotation tradeoffs and the limits of coverage metrics.

Will Wilson of FoundationDB explains how the team tested their distributed database using deterministic simulation. By running the whole system in a simulator with injected faults and reproducible seeds, they could find rare concurrency and network bugs.

Evan Czaplicki, creator of Elm, discusses the hard parts of running an open source project: online community conflict, why its patterns arise, and a cultural history of open source. He offers ideas for more civil, productive communication.

Aditya Siram introduces Shen, a small hosted Lisp with macros, a built-in Prolog and an optional type system. The talk demos a full web app moving between functional, logic and imperative styles, including turning JSON into a type with macros.

Richard Feldman describes introducing Elm into a mixed React and jQuery front-end in production, and why the result was reliable, clean and fast enough to make the back-end team jealous.

A DevGAMM talk by Jonathan Blow arguing that civilizations can lose technological capability and that software quality is already deteriorating. He discusses how knowledge fails to transfer between generations.

Dr. Michael Greger presents his book How Not to Die at Google NYC, arguing that diet and lifestyle changes can prevent or reverse many of the top causes of death. He walks through evidence on whole-food plant-based eating.

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.

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.

Ryan Dahl, the creator of Node.js, introduces the event-driven I/O framework built on V8 with examples, and discusses the v0.4.0 release and its new APIs.