This essay explores the transition from Go's built-in net/rpc package to gRPC, highlighting the benefits and trade-offs of each approach. By examining the basics of gRPC and Protocol Buffers, readers can gain a deeper understanding of how these technologies enhance communication between services.

https://victoriametrics.com/blog/go-net-rpc/index.html

A PostgreSQL database explorer TUI (Terminal User Interface) application written in Go.

https://github.com/ddoemonn/go-dot-dot

This video tutorial delves into the implementation of Server-Sent Events (SSE) using Go for the server and JavaScript for the client, showcasing how SSE facilitates real-time, unidirectional communication. By exploring the key components of SSE, viewers can learn how to effectively integrate this technology into their applications.

https://www.youtube.com/watch?v=nvijc5J-JAQ

The article focuses on the importance of handling termination signals gracefully in applications deployed in orchestrated environments like Kubernetes. Graceful shutdowns are crucial to prevent data loss and system instability that can occur with abrupt terminations, ensuring that applications can exit cleanly and maintain consistency even when they are stopped or scaled down.

https://packagemain.tech/p/graceful-shutdowns-k8s-go

This blogpost delves into the implementation of session-based authentication in Go, highlighting its simplicity and security benefits. By exploring the process of creating and managing sessions, readers can understand how to effectively authenticate users and protect their applications from common security threats.

https://themsaid.com/session-authentication-go

This essay discusses the challenges of dealing with import cycles in Go, a language that strictly prohibits them. It outlines three strategies—introducing interfaces, restructuring packages, and using function pointers—to resolve these cycles, each with its own trade-offs. The author reflects on the complexity and frustration these restrictions can cause in large codebases, advocating for more flexibility in handling import cycles.

https://www.dolthub.com/blog/2025-03-14-go-import-cycle-strategies/

A high performant nosql engine engineered from first principles

https://github.com/nubskr/nubmq

This essay delves into the mysteries of the quantum double-slit experiment, questioning whether particles or their wave functions pass through the slits. It argues that neither the particle nor its wave function physically traverses the slits, challenging common interpretations of quantum mechanics. By exploring the concept of superposition and the distinction between physical and possibility spaces, the essay sets the stage for understanding how interference patterns emerge without physical traversal.

https://profmattstrassler.com/2025/03/13/did-the-particle-go-through-the-two-slits-or-did-the-wave-function/

This tutorial video demonstrates how to create a basic database proxy in Go, inspired by Figma's approach to handling SQL queries dynamically. It shows how to intercept and modify SQL queries, highlighting the benefits of using a proxy for security, observability, and performance improvements. The video guides viewers through setting up a simple proxy that rewrites table names in queries, illustrating the core concepts of database proxying.

https://www.youtube.com/watch?v=DU7_MQmRDUs

This blogpost critiques Go's handling of multiple return values, arguing that they interact poorly with other language features and should be promoted to full-blown tuple types. The lack of tuples in Go leads to complexities in error handling and data passing, requiring workarounds like defining custom structs to manage function results effectively.

https://herecomesthemoon.net/2025/03/multiple-return-values-in-go/

A simple, battle-tested and generic set type for the Go language. Trusted by Docker, 1Password, Ethereum and Hashicorp.

https://github.com/deckarep/golang-set

This blogpost explores the process of integrating authentication into an API using the Encore.go framework. It demonstrates how to create an API endpoint that requires authentication, leveraging Encore's built-in features to handle token validation and user data retrieval. The post also covers testing strategies for authenticated APIs, showcasing Encore's support for mocking authentication data during test scenarios.

https://dev.to/eminetto/creating-an-api-with-authentication-using-encorego-3lak

Library for parsing structured TODO comments from code.

https://github.com/icholy/todo

This article introduces two new features in Go 1.24: runtime.AddCleanup and weak.Pointer. These tools enhance efficiency by allowing developers to manage resources more effectively. The runtime.AddCleanup function schedules a function to run when an object is no longer reachable, while weak.Pointer allows safe references to objects without preventing garbage collection. Together, they provide powerful alternatives to traditional finalizers and can be used to build custom resource management solutions.

https://go.dev/blog/cleanups-and-weak

This blogpost chronicles the author's journey in creating their first Zig program, "zigping," a terminal-based utility similar to gping. Coming from a background in Go, the author highlights the challenges of manual memory management in Zig and explores its build system, error handling, and multithreading capabilities. The project serves as a learning ground for understanding Zig's unique features and overcoming the hurdles of transitioning from a garbage-collected language like Go.

https://pliutau.com/my-first-zig-program-zigping/

This article explores why Go uses pointers instead of references, a choice that often puzzles developers transitioning from languages like Java or Python. It explains that pointers provide explicit control over memory, enhancing code clarity and speed by avoiding unnecessary data copies. By using pointers, Go developers can ensure that changes to data are intentional and visible, making the language more efficient and easier to understand once mastered.

https://blog.cubed.run/most-people-dont-understand-why-go-uses-pointers-instead-of-references-bad755dea39f

The GoAdBlock project is written entirely in Go and is designed for network level DNS ad-blocking functionality. The project is public, under the MIT License.

https://github.com/vivek-pk/GoAdBlock/

This article discusses Microsoft's ambitious project to create a native port of the TypeScript compiler and tools, aiming to significantly improve performance. The native implementation promises to reduce build times by up to 10 times and enhance editor responsiveness, making it ideal for large codebases and AI-driven development tools. By mid-2025, a preview of the native tsc is expected, with a full release planned by the end of the year as TypeScript 7.0.

https://devblogs.microsoft.com/typenoscript/typenoscript-native-port/

This blogpost delves into the core concepts of Go's structs and interfaces, highlighting how they differ from traditional object-oriented programming (OOP) languages. It explores Go's philosophy of favoring composition over inheritance and using interfaces to define behavior rather than specify implementation. The article provides practical examples and patterns for using structs and interfaces effectively, emphasizing their role in creating more maintainable and flexible code.

https://getstream.io/blog/go-structs-interfaces/