Episode

Is Go evolving in the wrong direction?

Podcast: Go Time: Golang, Software Engineering
Published: Jun 18, 2024
Duration seconds: 4429
Processing state: processed
Canonical source: https://changelog.com/gotime/319
Audio: https://op3.dev/e/https://cdn.changelog.com/uploads/gotime/319/go-time-319.mp3
JSON: /v1/public/podcasts/go-time-golang-software-engineering/episodes/is-go-evolving-in-the-wrong-direction
Markdown: /podcast/go-time-golang-software-engineering/is-go-evolving-in-the-wrong-direction.md

Actions

POST https://stenobird.com/v1/public/podcasts/go-time-golang-software-engineering/episodes/is-go-evolving-in-the-wrong-direction/transcription-requests
Idempotently request low-priority transcript generation for this episode.
GET https://stenobird.com/podcast/go-time-golang-software-engineering/is-go-evolving-in-the-wrong-direction.md
Read the agent-friendly Markdown representation of this episode resource.

Summary

A debate on whether Go's recent feature additions, like generics and iterators, are introducing unnecessary complexity or essential evolution. The hosts also explore the implications of restricting package internals and the broader industry obsession with language competition.

Topics

Go programming language
Generics
Software Engineering
Rust
Package Visibility
Software Complexity
API Design
Computer Science

Highlights

Main idea: While generics and iterators increase language complexity, they provide necessary standardization for the ecosystem
Failure mode: Using Go for tasks requiring heavy canonicalization (like XML/SAML) can lead to brittle code and C-library dependencies
Practical takeaway: The upcoming restriction on 'go:linkname' will break existing hacks but enforces better encapsulation and long-term stability
Main idea: The debate over Go vs. Rust often misses the point; the focus should be on software correctness rather than language performance benchmarks
Practical takeaway: Avoid using common nouns for package names to prevent namespace collisions and ambiguity in the standard library

Chapters

6:40 The Complexity of Generics and Iterators: Evaluating whether the addition of generics and new iterator patterns adds too much cognitive load to the Go language.
17:30 When Not to Use Go: A discussion on the pitfalls of using Go for specific encoding tasks like canonical XML that often require C interop.
40:25 The End of go:linkname Hacks: Analyzing the upcoming changes to package visibility and how restricting internal access will impact the ecosystem.
57:00 Beyond the Rust vs. Go Rivalry: Critiquing the industry's focus on language replacement and advocating for a focus on fundamental engineering principles.
1:08:05 The Importance of Engineering Rigor: Reflecting on how language silos form and why critical thinking is more important than mastering specific syntax.