About this video

• Video Title: Jonathan Blow on Programming Language Design
• Channel: Software Unscripted Podcast
• Speakers: Richard Feldman, Jonathan Blow
• Duration: 01:41:43

Overview

This video features a conversation between Richard Feldman and Jonathan Blow, focusing on the design principles and considerations behind programming languages, particularly Blow's own language. They discuss topics such as metaprogramming, compile-time execution, language feature interoperability, memory safety, performance, dependency management, and the philosophy of language design for expert users versus broader accessibility.

Key takeaways

• Compile-Time Execution: Blow discusses the utility and potential criticisms (like security concerns) of compile-time execution, emphasizing a focus on exploring the benefits rather than solely on security limitations.
• Language Design Philosophy: The conversation touches upon orthogonality as a design principle but highlights the importance of programmer convenience and quality of life, suggesting a balance between these factors.
• Determinism in Programming: Blow explains his stance on determinism, valuing power and exploration over absolute guarantees, similar to his approach to memory safety, opting for programmer responsibility.
• Dependency Management: The discussion explores different strategies for managing dependencies, contrasting "vendoring" with URL-based resolution and the trade-offs involved, particularly concerning long-term software stability and availability.
• Memory Management and Performance: The conversation revisits the evolution of CPUs and memory speed, explaining why early assumptions about garbage collection becoming negligible have not fully materialized and the performance implications of different memory management approaches.
• Software Quality and Evolution: Both speakers express concern about the perceived degradation of software quality and the lack of objective measurement in the industry, advocating for a focus on actual results and user experience.
• Operating System and Plugin Design: The discussion delves into the limitations and complexities of modern operating systems and plugin architectures, highlighting the lack of robust sandboxing solutions and the trend towards inefficient inter-process communication like Language Server Protocol.

Based on the transcript, Jonathan Blow speaks positively about:

• C++: He discusses its features and inheritance from C, particularly in relation to abstraction, stack, and heap memory management, though he also expresses frustration with it ("I was using C++ and I was depressed every day by C++").
• Scheme: He mentions using it in college and notes its relatively simple language semantics, but also points out its inefficiency and difficulty in debugging due to its structure (or lack thereof).
• Standard ML of New Jersey: Mentioned as a language he used in college.
• Prolog: Briefly mentioned as a language he used.
• Go and Swift: He cites these as good modern examples of languages that balance garbage collection with performance and ergonomics by unboxing things.
• Rust: He references a critique of game development in Rust, implying awareness and consideration of the language.

It's important to note that while he discusses these languages, his primary focus is on the design decisions and trade-offs, rather than declaring any single language as "the best." His own language is being designed with specific goals in mind, informed by his experiences with others.

Jonathan Blow talks about Rust at these timemarks:

• 24:14 (12:02:14) - He mentions Rust in the context of a critique of a talk about game development in Rust.
• 40:14 (13:20:14) - He further elaborates on the critique he had regarding game development in Rust, specifically concerning the use of entity component systems and the borrow checker.

Based on the transcript, Jonathan Blow's mention of Zig is brief and primarily in the context of discussing memory management and the broader landscape of systems programming languages. He doesn't go into extensive detail about his specific thoughts on Zig itself, but he groups it with languages that offer more manual control over memory.

Here's what can be inferred:

• Manual Memory Management: He mentions Zig in a discussion about memory safety and performance, where he contrasts languages with garbage collection to those that offer more direct memory control, like C, C++, Rust, and implicitly, Zig.
• Part of the "Systems Programming" Conversation: He includes it as an example of a language that appeals to developers who prioritize performance and low-level control, aligning with the "shadow community" he alludes to.

He doesn't offer a strong critique or endorsement of Zig specifically, but its inclusion suggests he sees it as a relevant player in the space of modern systems programming languages that aim for high performance and control.