bytecode vm

Christian Schafmeister presents lessons from six years of implementing Clasp, a Common Lisp compiler using LLVM as its backend that interoperates with C++. He explains handling a dynamic, memory-managed language on LLVM.

Cliff Click of Azul Systems asks what a JVM is supposed to do, in a Google Tech Talk from 2011. He covers the services a JVM provides, such as garbage collection and compilation, and the messy reality beneath the abstractions.

Allan Jude of Klara presents work on making ZFS scale on fast NVMe storage, covering fixes to the TaskQueue interface and removal of bottlenecks. The talk was given at EuroBSDcon 2022 and describes raising write throughput from about 3 to over 7 GB/sec.

Bryan Cantrill of Joyent describes the experience of porting KVM to SmartOS, an Illumos-based OS, at KVM Forum 2011. He covers the process, the pain points and how DTrace helped.

Christian Thalinger presents at the 2015 JVM Language Summit on adding ahead-of-time compilation to the JVM, covering the HotSpot team's AOT work and its relation to warmup and deoptimization.

A 2023 LLVM Developers' Meeting keynote by Abdul Dakkak, Chris Lattner and Jeff Niu introducing Mojo, a Python-family systems language built on MLIR and LLVM for heterogeneous computing.

Daniel Dunbar of Apple presents llbuild, a framework for building build systems, at the 2016 LLVM Developers' Meeting. He argues that the traditional way C compilers integrate with build systems limits compile speed, and proposes a new architecture.

Lex Fridman interviews Chris Lattner, creator of LLVM, Clang and Swift, about compilers, Swift for TensorFlow, TPUs and ML accelerators. The talk covers how hardware and software meet to produce efficient code.

Quentin Perret of Google gives a technical deep dive into protected KVM (pKVM) on Arm64, a confidential computing approach for CPUs without hardware extensions. It explains how the nVHE hypervisor manages stage-2 MMU access control to protect guest memory.

Swift compiler engineers explain how Swift implements generics using dictionary-passing with reified type metadata. They compare it with Java-style uniform representation and C++ or Rust monomorphization.

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.

Christian Schafmeister's Google Tech Talk on Clasp and CANDO, a Common Lisp implementation on LLVM and C++ used to design molecules, including energy minimization and force-field calculations.

Mitchell Hashimoto walks through his setup for running a NixOS virtual machine on a Mac as his development environment, with a config repo on GitHub.

Andreas Kling live-codes a prototype JavaScript JIT compiler for the LibJS engine used in SerenityOS and Ladybird. He builds a standalone bytecode VM, a simple interpreter, and then a simple JIT in about 80 minutes.

ThePrimeagen interviews Chris Lattner, creator of LLVM, Clang, Swift and Mojo, with TJ DeVries, in a long live-streamed conversation. They discuss language design and Lattner's experience building Swift.

Cliff Click, author of HotSpot's JIT compiler, shares hard-won advice for people writing virtual machines at the VMSS16 workshop. Topics include interpreters, JITs and performance lessons.

Dan Bornstein's Google I/O 2008 talk on the internals of Dalvik, the virtual machine that runs Android code. It covers the motivation for its design, the dex format and its register-based interpreter, plus tips for writing code that suits the platform.

Chris Thalinger of Twitter describes the company's effort to run its Scala services on the Graal JIT compiler at Scala Days NYC 2018. It covers the performance gains Twitter saw and the work of running Graal in production.

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.

Lex Fridman's long interview with Chris Lattner, creator of LLVM and Swift, covering the future of computing and programming languages. It touches on compilers, hardware, and his work at Apple, Tesla, Google and SiFive.

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.

A Curry On talk by Lars Bak, known for V8 and Dart, on building a secure and robust IoT development platform. It discusses language and VM design choices for small devices.

Cliff Click of Azul Systems gives a Google Tech Talk on running Java business applications on a machine with about a thousand cores. He covers hardware and software codesign, including garbage collection hardware and the JIT.

Dave Plummer interviews Dave Cutler, architect of VMS and Windows NT, in a roughly three-hour conversation about his career and the history of Windows.

Lex Fridman's long podcast conversation with Chris Lattner, creator of Swift, LLVM and MLIR and co-founder of Modular. Topics include the Mojo language, the future of programming and AI, and hardware.

A Computer History Museum oral history interview with Dave Cutler, covering his youth, early work on operating systems at DuPont and Digital Equipment, and his path toward VMS and Windows NT. This is part one of a long-form interview.

Chris Seaton talks about JRuby+Truffle, explaining how the Truffle and Graal combination optimises the tricky parts of Ruby and why it outperforms other Ruby implementations.

HDTVTest reviews the Apple Pro Display XDR using measurements and a side-by-side comparison with a Sony BVM-HX310 dual-layer LCD reference monitor. It examines how well the display handles HDR against a professional reference.

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.

John McCutchan of Google explains how Dart and the Dart VM expose SIMD instructions to speed up web software. He covers what SIMD is and how it applies to graphics and games.

Developer Voices interviews Chris Lattner about Mojo, a Python-compatible language aimed at CPU/GPU performance built on LLVM and MLIR. It covers performance features, the type system and why Mojo uses Python syntax.

Java Language Architect Brian Goetz talks at a Clojure conference about the challenges of evolving a mature language like Java while preserving compatibility with existing code and developer expectations. It also gives a look at where the platform is headed.

Chandler Carruth's CppCon 2016 talk tries to defuse the heated debate over undefined behavior in C and C++. He explains from the compiler writer's perspective why UB exists and how it enables optimization.

Cliff Click walks through a small performance example on a modern out-of-order CPU. He covers pipelining, ILP, CISC vs RISC, multicore, and why cache misses and the memory subsystem dominate performance.

A Google Tech Talk by the author of Kilim, a Java library for lightweight actor-style message passing. It argues that message passing can replace shared-memory concurrency and claims performance competitive with or better than Erlang for huge numbers of actors.

John A. De Goes's Scalapeno keynote argues that Scala's popularity is declining because of compile times, complexity and compatibility problems. He proposes a path for Scala to survive, including a simplified functional subset.

Chandler Carruth's GoingNative 2012 talk on Clang, covering how the compiler helps defend C++ code from mistakes. It makes the case for Clang's diagnostics and tooling.

Chandler Carruth's CppNow 2013 keynote on how C++ builds complex software from simple emergent structures, and how compilers optimize them through inlining and value semantics.

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.

The complete six-stage album series Everywhere at the End of Time by The Caretaker, about 6.5 hours of music that depicts the progression of dementia through distorted, decaying old ballroom recordings.