li-cycle

Stefan Karpinski's European Lisp Symposium 2016 talk asks whether Julia is a Lisp. He covers the features it borrows from Lisp, such as macros and closures, and where it departs, including syntax and its type system, with generated machine code shown.

Julia co-creator Stefan Karpinski explains why multiple dispatch makes Julia code and types reusable across packages with so little friction. He covers sharing basic types and sharing generic algorithms.

Daniel Azuma's ElixirConf 2018 talk on whether Docker and OTP conflict. He shows they can coexist and uses Horde and DeltaCrdt, with a live tank-game demo, to keep state alive across container kills.

Aral Balkan's re:publica 2015 talk argues that people are the product of surveillance-based business models. It makes an ethical case against data monopolies and for privacy as a human right.

Chris McCord's ElixirConf 2018 keynote introduces Phoenix LiveView, which renders HTML on the server and updates the page over websockets. It includes a demo showing that latency is not the bottleneck one might expect.

José Valim's ElixirConf US 2023 closing keynote on the foundations of the Elixir type system, covering set-theoretic types and gradual typing with strong arrows.

Kiran Pamnany's Cambridge Julia Meetup talk on Julia's shared memory parallelism and its new task scheduler. It argues that fork-join and work-stealing models nest poorly and presents depth-first scheduling for composable parallelism.

Steven G. Johnson, MIT professor and FFTW co-author, gives a JuliaCon 2019 keynote on metaprogramming and staged programming in Julia, showing how it enables high-performance numerical code and when not to use macros.

Dave Chinner's linux.conf.au 2012 talk on XFS scalability, covering pain points with large numbers of files and complex metadata, and the work to fix XFS metadata performance.

Julia co-creator Jeff Bezanson candidly lists fundamental problems with the language at JuliaCon 2019, including modularity, types and compiler latency, and how they might be solved.

Robin Deits presents the JuliaRobotics organization and shows how Julia is used to visualize, simulate and control a humanoid robot. The talk touches on real-time performance and composability across packages.

Isaac Yonemoto's ElixirConf 2021 talk on Zigler, a library for writing Elixir NIFs in Zig. He looks at its internals and how it bridges the two languages while keeping the NIFs well behaved on the BEAM.

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.

Nicholas Zakas of Yahoo discusses architecture for large, modular JavaScript web applications. He lays out the theory behind building front ends that scale in complexity.

Peter Hutterer's linux.conf.au 2020 talk on creating libinput, the unified userspace input library, and the difficulties of handling the many quirks of input devices.

Robert Moss's JuliaCon 2015 talk describes using Julia as a specification language for ACAS X, the next-generation airborne collision avoidance system that succeeds TCAS.

A JuliaCon 2016 talk by Shashi Gowda showing an APL implementation in Julia. APL code is translated to Julia and JIT compiled to machine code.

Roman Elizarov compares Kotlin Coroutines with OpenJDK Project Loom virtual threads, looking at their design goals and how those translate into different implementations and tradeoffs. He addresses how the two can coexist.

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.

Bret Victor's talk on Drawing Dynamic Visualizations. It argues that visualization tools offer either the directness of hand drawing or the dynamics of programmed graphics, and shows a tool that combines both.

Peter Rizun and Andrew Stone present results of tests running 1 GB blocks on a Bitcoin test network at Scaling Bitcoin Stanford. The talk argues for big-block scaling and discusses its consequences.

Lichess founder Thibault Duplessis talks at Big Techday 10 in Munich about how Lichess works and how he built it. He covers the project's origins and technical challenges including cheating detection.

JPL's David Cummings presents at the 2025 Flight Software Workshop how the team diagnosed and fixed the 2023 Voyager 1 anomaly from billions of miles away. It walks through the flight computer and the memory fix.

Greg Kroah-Hartman's Linaro keynote on contributing to the Linux kernel, explaining why maintainers prefer upstreamed code and how they view contributions.

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.

William Byrd presents at Papers We Love NYC on what he calls the most beautiful program ever written, a Lisp interpreter written in Lisp. He walks through the metacircular interpreter and related ideas, and demos relational programming and program synthesis near the end.

In this TED talk, Lawrence Lessig argues that American politics is corrupted by Congress's dependence on funding from a tiny fraction of citizens. He uses rapid-fire visuals and calls for a bipartisan push to reclaim the Republic.

Christian Schafmeister's Google Tech Talk on designing spiroligomer molecules and building Clasp, a Common Lisp on LLVM that interoperates with C++, to program molecular design. It covers the chemistry, automatic differentiation for force fields, and how the compiler is built.

Allan Savory's TED talk arguing that desertification of grasslands can be reversed with holistic managed grazing, which he says would also help reverse climate change. TED notes that other scientists have challenged his claims.

Dan Geer's Black Hat 2014 keynote argues that cybersecurity is a matter of power and policy rather than wishful thinking. He covers surveillance, the vulnerability market, software liability and privacy as the capacity to misrepresent yourself.

Chris McCord's ElixirConf EU 2019 keynote introducing Phoenix LiveView, which builds interactive server-rendered apps without writing JavaScript. It explains how only changed dynamic parts are sent over a websocket.

Titus Winters' CppCon 2017 talk argues for C++ and Google's Abseil to be maintained as a live at head language, relying on testing and automated tooling rather than never changing or promising no compatibility. It covers Hyrum's law and the limits of semantic versioning.

Christopher Domas presents his Cantor Dust tool at Derbycon 2012, a 3D visual approach to reverse engineering binaries by visualizing their structure dynamically.

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.

Steve Blank tells how World War II, Stanford's Frederick Terman and military and intelligence agencies shaped the rise of Silicon Valley. The talk centers on the Cold War electronic warfare and signals intelligence work that seeded the region's tech industry.

Bob Beck of OpenBSD describes the first month of LibreSSL, the fork aimed at cleaning up OpenSSL, including oddities found in the code base and why it was cleaned rather than audited cryptographically.

Excerpts from Linus Torvalds's DebConf 14 talk on why desktop Linux struggles. He covers application distribution, distros breaking backwards compatibility, wasted package management effort and how Windows does app distribution better.

Jon Ronson's TED talk on public shaming on Twitter, centered on Justine Sacco and others whose lives were upended by online mobs. He argues we have become a baying crowd and should rethink how we treat each other online.

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.

Rob Pike's Go talk distinguishing concurrency, the structuring of independent processes, from parallelism, their simultaneous execution. It uses Go channels and goroutines to illustrate.