Anton Zhiyanov·35wGo is #2 among newer languages
Programming language rankings for newer languages (version 1.0 released after 2010) show TypeScript leading, followed by Go in second place, then Rust, Kotlin, Dart, and Swift. The analysis combines data from IEEE, Stack Overflow, and Languish rankings, highlighting TypeScript's dominance and Go's strong position for backend development.
omg! ubuntu!·38wSuperFile is a Command-Line File Manager You’ll Enjoy Using
SuperFile is a modern terminal file manager written in Go that offers a colorful, icon-rich interface as an alternative to traditional tools like Midnight Commander. It features multiple panels, keyboard-driven navigation, vim-compatible keybindings, and integrates with external editors while maintaining simplicity and usability for command-line file operations.
Ayush Kumar·36wGoogle's New Golang based framework for Building AI-powered apps
Google has released Genkit Go 1.0, the first stable and production-ready version of their open-source AI development framework specifically designed for the Go programming language ecosystem. This framework enables developers to build AI-powered applications using Go.
ByteByteGo·34wHow Grab’s Migration from Go to Rust Cut Costs by 70%
Grab successfully migrated their Counter Service from Go to Rust, achieving a 70% cost reduction through improved resource efficiency. While latency remained similar, the Rust version required only 4.5 CPU cores compared to Go's 20 cores for handling 1,000 requests per second. The migration involved careful library selection, rebuilding internal tools like configuration systems, and overcoming challenges with Rust's borrow checker and async concurrency model.
Awesome Go·38wPreserving Order in Concurrent Go Apps: Three Approaches Compared
Explores three approaches to preserve order in concurrent Go applications while maintaining performance benefits. Compares ReplyTo channels, sync.Cond turn-taking, and permission passing chain patterns through detailed benchmarks. The permission passing approach emerges as the winner, offering good performance with zero allocations and clean abstractions for building reusable concurrent operations.
Awesome Go·37wGo Coding Official Standards and Best Practices
A comprehensive guide covering Go's official coding standards and best practices, including code formatting with gofmt, naming conventions, package design principles, error handling patterns, function design, concurrency guidelines, comment conventions, testing approaches, and performance optimization techniques. The guide emphasizes Go's philosophy of simplicity and provides practical code examples for each topic.
GitHub Blog·34wSpec-driven development: Using Markdown as a programming language when building with AI
A developer shares an experimental approach to building applications by writing specifications entirely in Markdown and using GitHub Copilot to compile them into actual code. The workflow involves maintaining app logic in markdown files, using AI to generate Go code, and keeping documentation synchronized with implementation. This spec-driven development method aims to solve context loss issues with AI coding agents while enabling faster iteration and cleaner specifications.
Three Dots Labs·35wSQLite Pub/Sub, Quickstart, and more — Watermill 1.5 Released
Watermill 1.5 introduces SQLite Pub/Sub support for event-driven applications without external message brokers, adds a hands-on Quickstart training program, and includes API improvements like deprecated CQRS marshalers and enhanced SQL package compatibility with pgx and ORMs. The Go library now supports 13 different Pub/Sub implementations and has grown to nearly 9k GitHub stars with contributions from 43 developers.
Beam Bloggers Webring·34wWhy I Chose Go
A developer shares their decision-making process for choosing Go to rewrite asdf, a version manager tool. They evaluated multiple languages including Rust, Elixir/Erlang, Nim, D, and V-lang, ultimately selecting Go for its fast compilation, simplicity, and strong open-source ecosystem. The rewrite took nearly a year but resulted in improved performance and maintainability.
Armin Ronacher·34w90%
A senior developer shares their experience building a 40,000-line infrastructure service where AI generated over 90% of the code. They detail their workflow using Claude and Codex, emphasizing the importance of maintaining architectural oversight, code quality standards, and system understanding while leveraging AI for implementation. The approach enabled rapid prototyping, constant refactoring, and exploration of new patterns, but required careful review and strong engineering judgment to avoid brittle systems.
shipping bytes·35wBuy vs build when it comes to dependency management
Explores the evolution of developer perspectives on dependencies across career stages, from junior engineers wanting to learn by avoiding them, to mid-level developers embracing them for speed, to senior engineers being cautious about complexity. Compares software dependency decisions to manufacturing choices, arguing that both require careful cost-benefit analysis rather than blanket rules.
Planet Golang·36wTest state, not interactions
State-based testing validates system behavior by checking outcomes rather than implementation details. Mock-based interaction testing creates brittle tests that break on harmless refactors while missing real bugs. Handwritten fakes that implement domain rules provide better test maintainability and reliability than generated mocks. LLMs often produce poor interaction-checking tests that add maintenance overhead without meaningful validation.
Go·37wA new experimental Go API for JSON
Go 1.25 introduces experimental encoding/json/v2 and encoding/json/jsontext packages to address long-standing issues in the original encoding/json package. The new v2 API fixes behavioral flaws like invalid UTF-8 handling and duplicate JSON keys, improves performance especially for unmarshaling (up to 10x faster), and provides better streaming capabilities. The jsontext package handles JSON syntax while v2 manages semantics, offering new interfaces like MarshalerTo and UnmarshalerFrom for better performance. The original v1 package will be reimplemented using v2 under the hood, allowing gradual migration while maintaining backward compatibility.
freeCodeCamp·35wHow to Implement Dependency Injection in Go - Explained with Code Examples
Dependency injection (DI) in Go involves passing dependencies into components rather than creating them internally, making code more testable and maintainable. The guide covers manual DI as the idiomatic Go approach, explains when complexity grows with nested dependencies, and explores DI libraries like Google Wire (compile-time), Uber Dig (runtime), and Uber Fx (with lifecycle management). Manual DI works well for most projects, while frameworks help manage complexity in larger applications. Best practices include keeping dependencies explicit, starting simple, and using interfaces for testability.
Hacker News·35wMESH: I tried HTMX, then ditched it
A developer explores HTMX for HTML-first web development but finds it lacks the structure of SPA frameworks. They create MESH, a framework that combines server-side rendering with web components using a "one component = one endpoint" principle. The project demonstrates building interactive features like drag-and-drop and real-time collaboration, ultimately replacing HTMX with custom JavaScript while maintaining the benefits of modular SSR.
The New Stack·34wGo Experts: ‘I Don’t Want to Maintain AI-Generated Code’
Two experienced Go programmers discuss the impact of AI-generated code on their language and the software development industry. While Go's popularity is rising partly due to AI compatibility, they express concerns about the quality of AI-generated code and its maintainability. The conversation explores whether bad AI code is worse than bad human code, the overwhelming volume of AI output, and how this affects junior developer learning. Despite concerns about code quality and the loss of mentoring opportunities, they remain optimistic about programming's future, viewing the current period as transitional.
Anton Zhiyanov·34wGo proposal: Hashers
Go 1.26 introduces the maphash.Hasher interface to standardize hashing and equality checks in custom collections. The proposal includes a ComparableHasher implementation for comparable types and enables developers to create custom hashers for specialized use cases like case-insensitive string comparison. This provides a consistent approach for building hash-based data structures like sets and maps with pluggable hashing behavior.
