Go

Stay updated on Go language development. Simplicity, concurrency, and the language powering cloud infrastructure.

About this developer podcast

Go turns GitHub activity into short audio updates.

Episodes cover commits, pull requests, issues, and release work.

Use this page to listen, subscribe, and find related developer podcasts.

This show page is the public hub for the podcast. It has one stable listen URL.

Use it to find RSS feeds, recent episodes, related shows, and older episode links.

If the project is quiet, new episodes may pause until there is useful activity to summarize.

Recent episodes from Go

  1. Compiler Efficiency and HTTP Cleanup

    The Go compiler gets a major memory and binary-size win by sharing method wrapper code, while the networking stack sees a cluster of correctness fixes around HTTP/3 stability and header handling. Several smaller fixes address…

  2. Aliasing Bugs and Correctness Cleanup in Math Big

    Today's activity centers on correctness testing in the math slash big package, where a new aliasing test framework caught a real bug in Divide Mod, alongside performance and clarity fixes in buffered I O and standard library examples.

  3. Weekly Recap - Correctness Fixes Across the Stack

    This week's Go development centered on correctness and edge-case hardening, from network server shutdown races to math library aliasing bugs, alongside experimental groundwork for JIT compiler support. Sixteen pull requests and thirty…

  4. Guarding Against Bad Input, One Panic at a Time

    Two fixes landed today that both close off crash paths triggered by unexpected input: gofmt's rewrite tool and the encoding/asn1 package's BitString type. Neither issue was new, but both point to the same lesson—unvalidated assumptions…

  5. Correctness Cleanup Across the Stack

    Today's fifteen commits skew heavily toward quiet correctness fixes rather than new features, touching the compiler backend, the networking stack, and the new SIMD subsystem. The common thread is edge cases that were silently wrong and…

  6. Type Checker Cleanup and Correctness Fixes

    Robert Griesemer's team wrapped up a multi-commit refactor that unifies how the type checker handles assignment context, while a handful of separate fixes tightened correctness in the compiler, template escaping, and JSON decoding.

  7. Hardening the Edges of Networking and Testing

    Today's activity centers on closing correctness gaps in network server behavior and expanding fast test coverage for the go command, alongside a platform-specific bug fix that resolved five open issues at once.

  8. Correctness Fixes Across the Compiler and Runtime

    Today's activity centers on a wave of correctness fixes spanning the linker, compiler, standard library, and the SIMD generator toolchain, with several patches closing gaps between what Go assumes and what real-world hardware or external…

  9. Compiler Backend Consolidation and a Landlock Security Fix
  10. LoongArch Gets Serious Performance Attention
  11. Weekly Recap - Hardening the Network Stack
  12. Platform Edge Cases Under the Microscope
  13. Standard Library Cleanup and SIMD Tooling Rework
  14. Correctness Fixes Across HTTP, Parser, and Compiler
  15. HTTP Correctness and Chip-Level Performance
  16. Compiler Speed and Correctness Tuning
  17. Network Edge Cases and a Compiler Reorganization
  18. Squeezing Stop-The-World Pauses Out of Crypto and Concurrency
  19. Weekly Recap - Correctness Fixes and Performance Tuning Under the Hood
  20. Precision Tuning in the Runtime
  21. Correctness Fixes in Math, JSON, and Runtime Sampling
  22. Security Patches and Serialization Cleanup
  23. Compiler Squeezes Out Instructions, Tooling Speeds Up
  24. Trimming the Fat—Compiler and Crypto Cleanup
  25. Squeezing Cycles from the Compiler and Runtime
  26. Trimming the Fat in Hot Paths
  27. Weekly Recap - Correctness Fixes and Concurrency Cleanup
  28. Closing the Performance Gap in JSON and RISC-V
  29. Quietly Closing Security Gaps
  30. Timer Race Fix and Runtime Cleanup
  31. Trimming Waste in the Standard Library
  32. Fixing What Recent Changes Broke
  33. Correctness Fixes Hiding in Plain Sight
  34. Correctness Over Cleverness in the Compiler
  35. Weekly Recap - Trimming the Fat in Hot Paths
  36. Compiler Correctness Cleanup
  37. Compiler Precision Work Pays Off in the Details
  38. Security Fixes and Parser Performance
  39. Security Fixes Across Crypto Stack
  40. Compiler Squeezes Out More Speed at the Instruction Level
  41. Squeezing Cycles Out of the AMD64 Compiler
  42. Weekly Recap - Security Hardening and Compiler Correctness
  43. Fixing a Silent Data Corruption Bug in MIPS Register Allocation
  44. Cleaning Up the Small Stuff
  45. Correctness Fixes Across Testing, Runtime, and Security
  46. Compiler Correctness Sweep
  47. Shaving Cycles Everywhere
  48. Security Hardening Across the Build and Runtime
  49. Enum Proposals and Toolchain Edge Cases
  50. Weekly Recap - Compiler Precision and a Rocky Road to Optimization
  51. A Small Fix to a Long-Standing Doc Link
  52. Compiler Speed Gains, and Two Reverts Worth Remembering
  53. Hardware Atomics and Generic Inference Advance Together
  54. Closing the Gaps Between Intent and Implementation
  55. Go 1.28 Opens as Edge Cases Get Cleaned Up
  56. Tightening the Compiler, Documenting the Edges
  57. Weekly Recap - Documentation Cleanup and a Root Security Fix
  58. Documentation Debt and the Testing Package's Rough Edges
  59. The Great Doc Cleanup
  60. Consistency Fixes Across the Toolchain
  61. Root Security Fix and a Network-Free Test Suite
  62. Tooling Fixes Tighten Edge Cases
  63. Regex Engine's Stale Flag Bug
  64. Weekly Recap - Correctness Fixes and Developer Ergonomics
  65. Making the Toolchain Do More Heavy Lifting
  66. Clearer Errors, Honest Documentation
  67. Standard Library Enhancement and Contribution Guidelines
  68. Weekly Recap - ARM64 & SIMD Performance Focus
  69. Compiler Fixes and Tool Improvements
  70. ARM64 and SIMD Optimization Push
  71. Security and Reliability Fixes
  72. Compiler Fixes and API Modernization
  73. Crypto Testing and JSON V2 Progress
  74. HTTP/2 Performance and Reliability Improvements
  75. Weekly Recap - Performance Optimization and API Stabilization
  76. Security Header Handling
  77. Performance and Reliability Fixes
  78. SIMD API Refinement and Tool Chain Fixes
  79. Runtime Stability and Testing Improvements
  80. ARM64 Performance and Security Hardening
  81. SIMD Development and Tooling Fixes
  82. Weekly Recap - SIMD Development and JSON Optimization
  83. SIMD Support Lands in Master
  84. Weekly Recap - Tooling Improvements & Bug Fixes
  85. Network IP Performance Optimization
  86. Weekly Recap - Compiler Optimizations & Security Improvements
  87. Compiler Fixes and Security Documentation
  88. Runtime Map Performance Optimization
  89. JSON v2 Gets Experimental Protection & HTTP/3 Gets More Reliable
  90. Weekly Recap - Compiler Optimizations & JSON Improvements
  91. Compiler Register Mask Refactoring
  92. Runtime Performance and JSON Error Handling Updates
  93. RISC-V Assembly Enhancement
  94. Weekly Recap - HTTP/2 Modernization and SIMD Optimizations
  95. RISC-V Assembler Documentation Update
  96. Weekly Recap - HTTP/3 Testing & ARM64 SVE Assembly
  97. Bzr Support Removal and TLS Security Fix
  98. Weekly Recap - Performance Optimizations & Runtime Improvements
  99. Compiler Magic - Speed Boosts and Smart Optimizations
  100. Under the Hood Improvements

Episode archive for Go

  1. Linkname Revolution and Range-Over-Func Refinements
  2. Spring Cleaning and Developer Experience Polish
  3. Spring Cleaning and Stability Fixes
  4. Memory Profiling Gets Leaner
  5. Optimizer Wizardry and RISC-V Speed Boosts
  6. Spring Cleaning and Performance Tweaks
  7. Security Hardening and Performance Polish
  8. Windows Gets an Upgrade and Maps Get a Makeover
  9. Spring Cleaning and HTTP Security Fixes
  10. Cleaning House on LoongArch
  11. The Great Rollback and ARM64 Power-Up
  12. Struct Literals Get a Major Upgrade
  13. Runtime Refactoring Marathon
  14. The Great Test Parallelization Push
  15. HTTP/2 Gets a Major Makeover
  16. Cross-Platform Consistency & Developer Polish Day
  17. Performance Wins and Race Condition Fixes
  18. Generic Methods Coming in Go 1.27
  19. Spring Cleaning and Clarity
  20. The Assembly Detective Story
  21. Testing Gets Smarter and Maps Get Faster
  22. Security Fortress - Major Security Fixes and Language Evolution
  23. Memory Clearing Gets a Major Performance Boost
  24. Bug Fixes and Polish Day
  25. Spring Cleaning and Performance Boosts
  26. Float Optimization Blitz
  27. Spring Cleaning and Performance Wins
  28. Security Fixes and Performance Polish
  29. Compiler Cleanup and Zero-Sized Value Improvements
  30. ARM64 Power-Up and Debug Detective Work
  31. ARM64 Gets a Memory Access Upgrade
  32. When the Compiler Gets Picky About Pointer Shapes
  33. Developer Experience Polish and Cross-Platform Fixes
  34. The One-Line Fix That Packs a Punch
  35. Compiler Fixes and Validation Improvements
  36. JSON v2 Breaking Changes & ARM64 Performance Wins
  37. Under the Hood Improvements - Racing Conditions and Memory Safety
  38. RISC-V Gets a Speed Boost and Runtime Race Detective Work
  39. Runtime Cleanup Day
  40. The Great Type System Cleanup and Optimization Wins
  41. CGO Gets Cleaner and Cookie Parsing Gets Faster
  42. Compiler Deep Dive & Performance Wins
  43. Connection Reuse Revolution and Performance Wins
  44. SHA-1 Gets a Speed Boost on Loong64
  45. PowerPC Progress and Performance Polish
  46. Linker Gets a Memory Diet and Performance Tune-Up
  47. Security Hardening and Low-Level Optimization Bonanza
  48. The Great Equality Overhaul
  49. Go 1.27 Development Begins
  50. The Art of Optimization - Small Changes, Big Impact
  51. The Small Wins That Keep Us Going
  52. SIMD Gets Smarter - CPU Feature Detection Overhaul

More public developer podcasts

Browse other public Podlog show hubs with crawler-readable RSS and episode links.

  1. Openharness Daily 26 episodes
  2. Maestro Daily 53 episodes
  3. Navidrome Daily 72 episodes
  4. Next.js Daily 213 episodes
  5. Pi Mono 93 episodes
  6. OpenClaw 170 episodes
  7. RuView 131 episodes
  8. Godot Daily 158 episodes
  9. Agora Next Updates 228 episodes
  10. Rails Daily 212 episodes
  11. Home Assistant Daily 217 episodes
  12. Linux Kernel Daily 193 episodes
  13. React Daily 109 episodes
  14. Jabref Daily 64 episodes
  15. BlocksBeyondTheStars Daily 46 episodes
  16. Jabref Daily 65 episodes
  17. Next Js Daily 53 episodes
  18. Headroom Daily 62 episodes
  19. Agent Of Empires Daily 53 episodes
  20. Frigate NVR Updates 196 episodes
  21. Linux Kernel 187 episodes
  22. Homebrew 208 episodes
  23. TypeScript 97 episodes
  24. Ruby on Rails 201 episodes
  25. Redis 176 episodes
  26. Next.js 210 episodes
  27. Vue.js 149 episodes
  28. Rust 180 episodes
  29. Ruby Core Updates 203 episodes
  30. Python 193 episodes
  31. VS Code 211 episodes
  32. Node.js 205 episodes
  33. Django 197 episodes
  34. React Native 154 episodes
  35. PostgreSQL 197 episodes
  36. Kubernetes 206 episodes
  37. LangChain 191 episodes
  38. Ollama 195 episodes
  39. PyTorch 210 episodes
  40. Videorc Daily 53 episodes
  41. Shannon 83 episodes
  42. iCloud Photos Downloader 27 episodes
  43. Onlook Design Updates 34 episodes
  44. Buzz Transcription 80 episodes
  45. The Algorithm Daily 15 episodes
  46. TailwindCSS 119 episodes
  47. AtomVM Daily 15 episodes
  48. NativeScript iOS Daily 26 episodes
  49. Agora Next Daily 12 episodes
  50. Energy Inc Ace Mate Learning Daily 2 episodes
  51. tiny-gpu Daily 20 episodes
  52. OpenAI Skills 52 episodes
  53. Crush Daily 1 episode
  54. ControlNet Daily 0 episodes
  55. FinceptTerminal Daily 0 episodes