Transcript

A (0:00)

Up Next, on episode 50 of Stack Overflow, Joel and Jeff sit down with Steve Yeage to discuss his JavaScript compilation project, a generalized googly approach for plugging language support into editors, and the overall importance and philosophy of language tooling from IT Conversations. Hi, this is Phil Windley. Today I'm excited to bring you another great program from Stack Overflow with Joel Spolsky and Jeff ATWOOD Here on it conversations.

B (0:39)

The Conversations Network is a 501c3 nonprofit, and we need your help. For a tax deductible donation of as little as $5 per month, you can support this channel and the rest of the Conversations Network. So please visit conversationsnetwork.org to become a member and help us continue to bring our programs to the world for free. Our audio files are delivered by Limelight Networks, the high performance content delivery network for digital media.

A (1:04)

And now, here's Stack Overflow.

B (1:06)

You know, John Cage is the composer who pissed everyone off with this 4 minutes and 37 seconds composition, which was a dude sitting at a piano for four minutes and 37 seconds.

A (1:14)

33.

B (1:15)

Is it 33?

A (1:16)

B (1:16)

33. Oh, man, I'm four seconds off.

A (1:18)

You just. Well, I think you might have your own new composition. Our guest today on this Echo Flow podcast is Mr. Steve Yegi.

B (1:28)

Howdy. Howdy.

A (1:29)

Formerly of Amazon and the Navy. Even before that, currently of Google in Kirkland, where Michael and I are visiting. Jeff is on the line from Emeryville.

C (1:42)

Well, actually El Cerrito, but close, very close.

A (1:44)

El Cerrito, Yeah. That's a different Mexican restaurant outside of Berkeley.

B (1:49)

Yeah.

C (1:51)

So how is. How's the Googleplex treating you?

A (1:55)

It's pretty nice. It's not. This isn't the plex.

Summary

Stack Overflow Podcast – Episode #50 (April 19, 2011)

Overview

Episode #50 of the Stack Overflow Podcast features Joel Spolsky, Jeff Atwood, and guest Steve Yegge (then of Google, formerly Amazon and the Navy). The main theme is the evolution and importance of programmer tooling, especially language tooling, code editors, type systems, and the culture surrounding software development. The conversation spans from the practicalities of IDE support for multiple languages, internal tool-building at Google, the merits and quirks of languages like JavaScript and APL, developer entitlement, and the moderation philosophy behind Stack Overflow itself.

Key Discussion Points and Insights

1. Google Developer Culture and Perks

Steve describes the Google Kirkland office, noting the abundance of free, healthy food and the contrast with other tech employers (02:09).
Discussion about employees quickly adapting to perks and developing a sense of entitlement: “How quickly we grow to feel entitled to things that were only invented 15 minutes ago.” (15:12, Joel)
Riff on the idea that new college grads should have to work somewhere else before appreciating Google (16:14–16:48).

2. The Importance and Evolution of Programming Tools

Google’s increasing focus on developer productivity due to hiring slowdowns (11:49–12:21).
Comparison of tooling at Microsoft (notably IntelliSense) versus Google:
- “IntelliSense... It’s like crack, or so I hear.” (13:01, Steve)
- Tools are a major differentiator in productivity, perhaps even more than language features (13:08–13:51).
Steve’s project at Google: building a scalable, language-agnostic infrastructure for editor/IDE language support:
- Motivation: Avoid writing N x M plugins for every editor/language (20:34).
- Central thesis: Language implementers should provide rich symbol tables, abstract syntax info, and expose metadata for IDEs through a service/API, rather than losing it during compilation (28:15–29:25).
- Vision: “Commoditize IDE backends... turn the problem around.” (27:00–28:15)
- Status: “It’s pretty preliminary. It’s a very tiny, small team... but there’s a lot of excitement about it.” (29:28–29:48)
Industry movement towards standardized language service APIs (33:11–33:52).

3. Programming Language Anecdotes and Philosophy

The peculiar history and usage of APL and its derivatives (05:00–07:26).
Language silos, call-stack sharing, and the difficulty of true cross-language interoperability, highlighted by experiences at Foo Camp (18:44–19:26).
Visual Studio, Eclipse, and IntelliJ all achieve strong language support, but mostly via painstaking per-language engineering.

“Programming languages are silos... there’s very little call stack sharing”
— Steve (18:44)

Steve: In the future, IDEs and compilers should “commoditize” language features, making the old “text language you type into vi” look primitive (28:28–29:28).

4. JavaScript, Type Systems, and Frameworks

Steve explains Google’s advanced JavaScript compiler:
- Performs sophisticated static analysis and type inference (21:53–23:30).
- Enables compile-time warnings and hints, approaching the safety net of statically-typed languages.
The challenge of making such tooling work across JavaScript frameworks (like jQuery, Prototype, Dojo) due to custom inheritance models and naming conventions (31:19–33:11).
Joel and Jeff discuss the widespread adoption and love for jQuery:
- “From our perspective, it’s almost like a running joke how often jQuery comes up. People seem to really fall in love with it.” (36:41, Jeff)
Historical context of JavaScript’s rushed design, its heritage from Scheme and Self, and quirks like the ‘this’ keyword (43:00–44:07).
The ongoing debate between static and dynamic typing, and whether robust tooling can mitigate the weaknesses of dynamic languages (41:43–42:44).

5. The Progress of Abstraction and Tooling

Complaints about JavaScript as a "not quite good enough" language, but recognition that tooling can close some gaps (46:18–47:03).
Movement towards compiling other languages (like Java or even C) to JavaScript, and how that mirrors the early days of C++ compilers (47:21–48:15).
Discussion on “higher levels of abstraction” being the essence of modern programming progress (49:44–50:20).

6. Software Community Culture and Moderation

Depth discussion about Stack Overflow’s approach to “off-topic” or quirky questions, including a real example: “programming at sea” (63:10–65:36).
The tension between fostering an interesting, fun community and maintaining focus (66:17–71:34).
Philosophy of algorithmic over manual moderation:

“Don’t tweak posts, tweak algorithms. Don’t worry about individual things ... always try to make the algorithm better.”
— Joel (73:06)

7. Anecdotes: Workplace Culture, Unix, and Community

Steve’s early experiences at previous employers, workplace craziness, and what makes a good company environment (10:45–11:49).
Extended question about Joel’s historical issues with Unix, deployment difficulties, and why Windows can offer more consistency for application authors (55:04–61:25).
Humorous closing stories about Amazon’s “Rufus the dog” launching new sites and Steve’s time living next to strippers in Seattle (50:47, 75:25–76:09).

Notable Quotes & Memorable Moments

On tools vs. language:

“It’s not the language. It’s got nothing to do with language ... the tools are amazing.” (13:26, Steve)
On developer entitlement/perks:

“How quickly we grow to feel entitled to things that were only invented 15 minutes ago.” (15:12, Joel)
On language interoperability:

“There is no just. What about threading semantics? What about object semantics?” (19:26, Steve)
On static vs. dynamic typing:

“If compilation is available to you, it doesn’t excuse you from writing unit tests ... but it sure helps.” (41:26, Steve)
On the evolution of developer tooling:

“It’s totally backwards today. It’s ghetto ... I think we’re in the middle ages of programming.” (28:24, Steve)
On community and moderation:

“Don’t tweak posts, tweak algorithms. Don’t worry about individual things ... always try to make the algorithm better.” (73:06, Joel)

Timestamps for Key Segments

Google perks and entitlement: 02:09–16:48
Steve’s project: generalized, scalable language tooling: 11:49–29:48
JavaScript, compiler infrastructure, and type inference: 21:53–24:33
Static vs. dynamic typing debate: 41:43–42:44
Discussion about Stack Overflow moderation philosophy: 63:14–73:06
Joel’s Unix rant and software deployment woes: 55:03–61:25
Workplace anecdotes (Amazon dog, strippers): 50:47, 75:25–76:09

Closing Thoughts

Episode #50 dives deep into the underappreciated complexities of programming language tooling, why powerful tools can strongly influence language choice, and the ecosystem-wide push towards making language intelligence more universally accessible—regardless of the editor or language in question. Steve Yegge’s insights predict trends that would shape future open-source tooling and language service APIs. The show also provides a warm, irreverent inside look at developer culture, Stack Overflow’s community management values, and the quirks that make software development and its practitioners endlessly fascinating.

wavePod

Stack Overflow Podcast - Episode #50