Software Unscripted

This episode features a discussion with programmer Michael Newton comparing the functional programming languages F-sharp, Haskell, and Elm in professional production contexts.

This episode explores what web developers can learn from game development practices, focusing on performance, memory safety, and UI layout challenges like CSS.

Richard Feldman interviews Predrag Gruevski about the challenges of implementing semantic versioning in Rust's Cargo package manager and how it led to the creation of tools like Cargo Semver Checks and Trustfall.

A programmer with a Haskell background discusses his exploration of Smalltalk, covering its historical origins at Xerox PARC and the economic context of ARPA funding during the Cold War.

Host Richard Feldman interviews José Valim, creator of Elixir, about the differences between gradual and static typing, focusing on Elixir's prototype for set theoretic types and the trade-offs involved.

Mitchell Hashimoto discusses the trade-offs between native and cross-platform GUI development for his Ghostty terminal emulator, touching on platform-specific features and technical implementation challenges.

This episode explores how Lean 4's metaprogramming capabilities enable developers to program their IDE from within the system at compile time, featuring an interview with Harry Goldstein about his work integrating these features.

Host Richard Feldman interviews Andrew Kelley, creator of the Zig programming language, discussing technical aspects like memory management, I.O.

This episode discusses the XE exploit case involving homebrew's rolling releases, highlighting the security-performance trade-offs in software deployment.

Andreas Kling discusses the development of the scratch-built Ladybird Browser and SerenityOS, highlighting the challenges and benefits of creating independent components like JavaScript and CSS engines compared to other browser projects.

This episode features a discussion with Steve Klabnik about his blog post critiquing the polarized and unproductive discourse around AI in the programming community, covering topics from hype to skepticism and ethical implications.

Host Richard Feldman interviews Matt Godbolt about the Compiler Explorer tool, which disassembles and maps compiled programs to show how high-level code translates to assembly instructions.

This episode explores lambda set defunctionalization in the ROC compiler, explaining the technical challenges of handling closures with different captures and discussing why more languages don't implement such techniques.

This episode features an interview with Lucas Rosa about Aiken, a programming language for smart contracts, focusing on its unique integration of property-based testing and design trade-offs.

This episode explores the history, philosophy, and future of Smalltalk programming with creator Juan Vuletich, focusing on its live programming capabilities and object-oriented design principles.

This episode features an interview with Nathan Sobo about the history of Electron from Atom, the development of the Zed code editor, and the creation of GPUI for native UIs without Electron.

This episode features a deep dive into programming language design with José Valim, creator of Elixir, discussing topics like functional purity inference and tracing in the context of the Rock language.

This episode explores the differences between fuzz testing and property-based testing in software development, featuring an interview with AI compiler engineer Brendan Hansknecht.

This episode features an interview with Chris Nuernberger discussing his experiences optimizing code in the JVM and comparing it to C++ performance tuning, with insights from his background at NVIDIA and work on projects like Cortex.

This episode features an interview with Chris Lattner discussing the Mojo programming language's capabilities for high-performance GPU and CPU programming, its development progress, and its relationship to Python.

Host Richard Feldman interviews Louis Pilfold about the release of Gleam 1.0, a type-checked programming language for the Beam virtual machine, discussing its development, versioning philosophy, and technical features.

Host Richard Feldman interviews cybersecurity expert Kelly Shortridge about the recent CrowdStrike incident that caused widespread system failures through a problematic software update.

Jonathan Blow discusses the limitations of traditional programming languages like C and C++ in handling memory management and abstraction, contrasting them with functional languages' approaches.

Host Richard Feldman interviews Monica McGuigan about her transition from Scala to the Roc programming language, discussing functional programming concepts, language design, and learning experiences.

Host Richard Feldman interviews Carson Gross about HTMX and the argument that modern web development has regressed by moving away from hypermedia principles like sending HTML over the wire instead of JSON.

Database expert Glauber Costa discusses achieving million-reads-per-second performance with ScyllaDB versus Cassandra clusters, focusing on hardware optimization and OS-level implementation strategies.

Host Richard Feldman interviews Daniel Lemire about SIMD JSON, a high-speed parser that makes I/O the bottleneck, covering its development, applications to various data formats, and insights into performance benchmarking.

Host Richard Feldman interviews Ashley Williams, founder of Axo and former Rust core team member, about niche domain knowledge in software development.

Host Richard Feldman interviews Peter Saxton about the creation and design of the EYG programming language, exploring its influences from languages like Rock and Unison and the problems it aims to solve in functional programming.

Richard Feldman interviews Chris Krycho about LinkedIn's migration to TypeScript, covering the challenges of adopting it at scale, TypeScript's semantic versioning, and comparisons of type system complexity in various languages.

Host Richard Feldman interviews Conor Hoekstra about the evolution of programming languages, the current state and future of C++ in GPU and hardware contexts, and comparisons to historical languages like COBOL.

Host Richard Feldman interviews Thorsten Ball about the differences between compilers and interpreters, teaching compilers, and the excessive complexity in modern web development.

Richard Feldman discusses the origins and motivations behind creating the Roc programming language, inspired by his experience with Elm and aiming to extend its functional programming benefits to various domains beyond front-end development.

Host Richard Feldman interviews Nikita Prokopov about his blog post on software disenchantment, exploring why software seems inefficient despite hardware advances and discussing strategies to address these issues.

Host Richard Feldman interviews Eli Dowling about the intersection of programming language design and editor tooling, focusing on the Rock language and topics like error recovery, TreeSitter, and the limitations of macros.

This episode explores teaching programming to beginners, distinguishing between true and false beginners, and discusses the relationship between software architecture and industrial design.

This episode explores compiler design for performance, focusing on parallel processing opportunities in compilation stages beyond just GPU execution.

Alex Kladov discusses incremental compilation techniques, memory management strategies like arena allocation, and his experiences with long-lived compilers in this technical interview.

Host Richard Feldman interviews Ryan Fleury about pure functional programming in C, memory management techniques, and the false dichotomy between stack and heap in programming.

Host Richard Feldman interviews Brian Carroll about the practical benefits, challenges, and future potential of WebAssembly in programming, including its relationship with JavaScript.

Host Richard Feldman interviews Lane Wagner about Go's design decisions, including its use of tabs for indentation and comparisons with functional and imperative programming languages.

Host Richard Feldman interviews Wolfgang Schuster about his transition from game development to web development, focusing on differences in programming practices like game loops and frameworks.

This episode explores the intersection of functional programming and distributed systems, discussing languages like Gleam and Elixir, scalability trade-offs, and coordination protocols in distributed computing.

This episode features an interview with Louis Pilfold, creator of the Gleam programming language, discussing its unique design choices like replacing traditional if statements with pattern matching.

This episode explores how Descript's video editing software uses transcript alignment technology to enable editing by manipulating text, with insights into the challenges of video versus audio editing and broader industry topics.

This episode explores how AI tools like ChatGPT and Copilot are transforming programming education, focusing on teaching fundamentals and developing judgment skills rather than just generating code answers.

Host Richard Feldman interviews Chris Lattner about the creation and purpose of the Mojo programming language, focusing on solving hardware acceleration challenges.

Host Richard Feldman interviews software engineer Tom Ballinger about implementing undo-redo functionality in repls using fork-based approaches and its applications in systems like Redis and Factorio.

Kyle Boddy discusses the early software engineering challenges of building Driveline Baseball, focusing on synchronizing high-speed cameras for data-driven baseball player development.

Host Richard Feldman interviews Mike Bryzek about his unconventional software development strategies including testing in production, early investment in automation, and microservices approaches that led to successful companies.

Richard Feldman interviews Carson Gross about HTMX, software philosophy, and the impact of AI on teaching programming.

Mitchell Hashimoto describes building a terminal emulator in Zig and SwiftUI that has been his daily driver on macOS since May of last year.

Software Unscripted's "React Hooks Design Review" pairs Richard Feldman with Scott Trinh, an EdgeDB programmer who knew React before and after Hooks.

Richard Feldman interviews Alex Schroyer about array languages like APL and J, discussing their conciseness and how they change the way programmers think.

["Richard Feldman and Simon Lidell trace the LeftPad incident back to a Babel pull request that only needed line-number padding for syntax-error snippets.", "Simon Lidell says he wrote `line numbers` at 19 while working in a warehouse, then built `JS Tokens` after experimenting with a regex tokenizer for JavaScript.", "The PR that reached Babel started as a tokenizer swap, then pulled in `line numbers`, more options, and a function escape hatch that made the helper harder to justify.", "They compare NPM's ability to unpublish packages and run install scripts with Elm's package rules that avoid arbitrary code execution."]

Richard Feldman interviews Dylan Kearns about his open source Elm projects Elm GraphQL and Elm Pages, discussing software design and type safety.

Richard Feldman interviews Runar Bjarnason about the design of the Unison programming language and its unique features.

Richard Feldman interviews Jeroen Engels about the design of static analysis tools like linters, trade-offs of gradual typing, and build time performance.

Richard Feldman interviews the creators of the Crystal programming language about its design and evolution.

Host Richard Feldman interviews Hillel Wayne about formal methods, software history, and technical writing.