Jonathan Blow on Web Development in detail

Advice for New Web Developers (Core Stance)

Jonathan Blow suggests that a key “right track” for modern web development is not to blindly commit to today’s default tooling/language ecosystem. He contrasts the ease of getting something running on-screen with the long-term quality and engineering tradeoffs the web has made.

Historical Context (Why He Personally Avoided Early Web Work)

• He was at UC Berkeley’s Experimental Computing Facility (XCF) and notes the trivia that the .XCF file extension traces to that experimental lab.
• He describes allocation/workstation scarcity at the time (home PCs weren’t equivalent to Unix workstations) and mentions a controversy between student groups over computing allocations.
• He cites Pei-Wei as having written one of the first web browsers: the Viola browser (now nonexistent), framed as an early example of “web with embedded programming.”

Early Web Browser Model: Text + Embedded Interpreted Language

• The Viola browser was more than a text renderer; it included an embedded interpreted language, described as “a lot like JavaScript” but not semantically identical.
• Later, JavaScript (around the mid-1990s, with Brendan Eich implementing it in 10 days) is presented as succeeding because it was initially lightweight—primarily manipulating browser state—rather than being “real program” heavy.

Main Technical Critique: “We Forgot What We Knew About Programming”

Blow argues the web ecosystem effectively threw away prior strengths of conventional systems:

• Before the web, developers had languages with strong type checking and consistent targeting of back-ends at a comparable quality level.
• The web pushed an approach where software increasingly depends on interpreters and wrappers around a single dominant substrate, instead of providing developers with multiple well-designed language choices plus robust compilation/tooling.

He contrasts this with the idea that if web execution were closer to a well-defined, machine-like substrate, it would enable better tooling.

JavaScript Dominance and Its Consequences

• He notes that JavaScript became the default language for most software and argues this was unexpected compared to earlier designers’ assumptions.
• He implies that modern workflows rely heavily on interpretation and platform-specific constraints, which can:
  • reduce debuggability
  • increase complexity
  • (historically) encourage transpilers/bloat—though he frames this as avoidable with better foundations

WebAssembly as a “Sort of” the Missing Piece

• Blow acknowledges WebAssembly as an attempt to provide a more instruction-set-like substrate for the web.
• However, he argues it does not fully achieve the ideal of being “equivalent to machine language” that’s cross-platform and well-defined in practice.
• He also notes that it isn’t the default in most real-world usage.

Business / Power Dynamics Affecting the Technical Direction

Blow argues that market incentives have shaped the web’s technical evolution:

• Major browser makers (especially Google) benefit from being among the few entities that can make browsers, creating disincentives to make it easy for developers to retarget or control execution independently.
• He further claims Apple has actively pushed against improving the web so it remains dependent on the App Store model.
• More generally, he suggests major companies share incentives to protect market share and prevent erosion from competition.

Quality and Tools Argument: Why a Better Substrate Matters

Blow argues that if the web execution model supported a more machine-like, well-defined target, developers could get:

• real debuggers
• higher analyzability
• better understandability
• improved robustness and software quality

He frames this as “best of both worlds”:

• keep web convenience (open a page and run something)
• regain older-school engineering quality

Tutorial-Style / Guide Element (Conceptual)

The “guide” here is conceptual rather than step-by-step. The implied recommendation is to value and build toward web infrastructure that restores lost programming strengths—especially debuggability and tooling—rather than optimizing solely for quick in-browser execution.

Main Speakers / Sources

• Jonathan Blow
• Mentions / conversational sources: Pei-Wei, Marc Andreessen, Brendan Eich
• References to W3C meeting minutes (including discussions involving Apple and other companies)