database sync

The first lecture of Andy Pavlo's CMU 15-445 Intro to Database Systems (Fall 2019), covering course introduction and the relational model.

Rich Hickey, creator of Clojure and designer of Datomic, gives a JaxConf 2012 talk that takes apart traditional database architecture. He presents a different way to think about databases and explains the reasoning behind Datomic's fact-based design.

Steve Klabnik walks through the history of Rust and how its design evolved toward async/await, including the alternatives tried and dropped. He also discusses the difficulty of adding a major feature to a language.

Without Boats, a Rust language team member, explains the design of Rust's async/await at RustLatam 2019. He covers the history and constraints behind zero-cost, allocation-free async state machines.

David Beazley's workshop screencast builds asynchronous programming in Python from scratch, starting from callbacks and continuations and replacing threads to show how concurrency works underneath.

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.

Nathaniel J. Smith's PyCon 2018 talk introducing Trio, a Python concurrency library designed around usability and structured concurrency. He live-codes a problem and analyzes pitfalls in other async libraries.

Jon Gjengset's long live-coding Crust of Rust episode on async/await, focused on the mental model for using it rather than on Futures, Pin and Wakers internals. Topics include awaiting multiple futures, cancellation, executors and select.

A Linear engineer talks about scaling the company's sync engine, which keeps client data local and synchronized. It follows an earlier talk on the same system.

Chris Boden shows how an operator starts a large hydroelectric turbine generator and manually synchronizes it to the grid using a needle phase meter.

A Harvard lecture demonstration in which five metronomes on a movable board gradually fall into synchronization through coupling. Removing the coupling lets them drift out of step.

Kevin Fang comically retells GitLab's 2017 incident in which an engineer deleted the production database, based on the company's postmortems. It walks through the confusion and failed backups.

Fox Business interview in which Oracle co-founder Larry Ellison claims Oracle will beat Amazon at cloud databases. He argues the world's valuable data lives in Oracle and says Amazon struggled to move off it.

A Netflix JavaScript talk on using Reactive Extensions (Rx) for asynchronous UI code. It covers Observables, composing events such as drag and drop, and sequencing Ajax requests.

Veritasium explores how synchronization arises spontaneously in nature, with metronomes, fireflies and bridges, drawing on Steven Strogatz's work on chaos and complexity.

Mark Raasveldt of CWI presents DuckDB, an embeddable analytical database described as the SQLite for analytics, in a CMU Database Group talk. He explains why it was built, what it is for, and how it works.

SQLite creator Richard Hipp gives a history of SQLite and explains where it shines as a database at the edge of the network with no DBA. He covers long-term support, testing and how it is used in products.

Neil Fraser of Google presents Differential Synchronization, the algorithm behind MobWrite, for keeping multiple copies of a document in sync in real time. The talk argues the approach is robust, convergent and efficient.

Lukas Eder's Devoxx talk on how modern cost-based SQL optimizers rewrite and plan queries in ways developers would not expect. It argues that declarative SQL, used well, can run complex queries very fast.

Jonathan Worthington's YAPC Asia 2015 talk on parallelism, concurrency and asynchrony in Perl 6. It covers the language's concurrency features.

React Helsinki meetup recording featuring a talk on lessons with Apollo GraphQL and Linear co-founder Tuomas Artman on real-time sync for web apps. The sync talk explains Linear's local-first architecture.

A guest lecture Jon Gjengset gave at Two Sigma on using Rust for large, high-performance systems. It covers why Rust suits such projects, the Noria research database, a concurrent data structure used in it, and practical experience.

Aaron Boodman of Replicache asks why sync engines have not yet fixed web app complexity and what is missing for them to go mainstream. The talk lays out the ideas that led to the Zero sync engine.

A Clojure/conj 2014 talk by Lucas Cavalcanti and Edward Wible on four uses of Datomic. They cover HTTP caching, audit trails, mobile database sync and authorization, drawing on the immutable transaction log.

Database pioneer Michael Stonebraker argues that 'big data' is really at least four different problems: big volumes with small analytics, big analytics, velocity, and variety. He comments on where each market is heading.

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

Martin Odersky's JVM Language Summit 2015 talk argues that compilers can be thought of as databases. It describes design ideas for the Scala compiler and for developer tools.

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.

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.

Veritasium explains why the one-way speed of light has never been measured, only the round-trip speed, since measuring it requires synchronized clocks that assume the answer. It explores the implications for relativity.

Pink Floyd's Echoes played in sync with the final Jupiter and Beyond the Infinite segment of Kubrick's 2001: A Space Odyssey. The song's length closely matches the sequence.

Jon Gjengset's long live-coding stream explains Rust's Pin and Unpin types: why they exist, how they work, and how they connect to futures and async/await. It also covers moving from pre-pinning code to the new model.

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.

Raymond Hettinger's PyBay 2019 talk on the mental strategies he uses when programming in Python, such as chunking, solving a simpler related problem, and repeating tasks manually until patterns emerge. This version is re-synced with the slides.

A short satirical sketch in which a Q&A about web servers turns into a profane rant about threads, blocking and non-blocking I/O. It lampoons the hype around Node.js and async programming.

A FOSDEM 2023 talk from the Matrix team on Matrix 2.0, covering sliding sync, the Element X client rewrite and next-generation calling. It explains how Matrix aims to match the speed of proprietary messengers.

An AWS re:Invent 2018 session on how DynamoDB was built as a hyper-scale NoSQL database. It discloses underpinnings of the service and how it is run for over 100,000 customers.

Technology Connections explains why car turn signals appear to drift out of sync at stoplights and how thermal and other flasher designs work. It also covers how synchronization could be achieved.

Andrew Kelley's 2024 Zig roadmap talk, followed by a Q&A, covers the language's priorities and the state of the project. Topics include compilation speed, moving off LLVM toward a self-hosted toolchain, async, and the path to 1.0.

Jon Gjengset's 2020 PhD dissertation presentation at MIT on partial state in dataflow-based materialized views, the idea behind the Noria database. The Q&A is cut out.