Navigating Unfamiliar Code with the Go Guru
Explore techniques for navigating unfamiliar Go code using the Go Guru tool, including naming conventions, free variables, and point analysis.
Inside the Map Implementation
Explore Go's map implementation, including hash functions, buckets, and performance considerations for efficient data storage and retrieval.
Go Without the Operating System
Explore Go programming without an operating system, delving into bare-metal development and runtime implementation for embedded systems and specialized environments.
Don't Just Check Errors - Handle Them Gracefully
Learn strategies for graceful error handling in Go, improving code reliability and maintainability through effective error management techniques.
Go Vendoring Deconstructed
Explore Go vendoring: its functionality, implementation, and limitations. Gain insights into this crucial dependency management feature for Go projects.
cgo Safely Taming the Beast
Explore techniques for safely using cgo in Go projects, addressing performance considerations and potential pitfalls when interfacing with C code.
Practical Advice for Go Library Authors
Practical advice for Go library authors, covering naming, construction, zero values, interfaces, goroutines, and design principles for efficient and clean code.
The Power and Elegance of Reflection
Explore the power and elegance of reflection in Go programming, learning its applications, benefits, and practical implementation through expert insights and examples.
Porting Go to the IBM Z Architecture
Explore porting Go to IBM z Architecture, covering mainframe basics, blockchain applications, and the porting process. Gain insights into optimization techniques and cryptographic implementations.
Evolutionary Optimization with Go
Explore the process of prototyping, optimizing, and productionizing a complex distributed system using Go's standard library, profiling tools, and iterative development techniques.
Building a High-Performance Key - Value Store in Go
Explore the internals of a high-performance key/value store in Go, learning basic design principles and techniques for efficient data storage and retrieval.
Go Anti-Patterns
Explore common Go anti-patterns, their impact on code quality, and learn effective refactoring techniques to write more idiomatic and maintainable Go code.
Go at the DARPA Cyber Grand Challenge
Explore how Go's features enabled efficient data capture and analysis during DARPA's Cyber Grand Challenge, with insights on optimization, profiling, and resilience in network traffic handling.
Runtime Generated, Typesafe, and Declarative - Pick Any Three
Explore runtime function generation, reflection, and tags in Go to create efficient, type-safe SQL layers, reducing boilerplate and enhancing code reusability.
Self Deploying Kubernetes Applications
Explore self-deploying Kubernetes applications using Go binaries, treating the world as a global-scale computer. Learn unique properties and application-centric abstractions for efficient deployment.
An Introduction to Go Tool Trace
Explore Go's execution tracer to diagnose concurrency issues, uncover latency bugs, and understand goroutine interactions for improved performance and debugging.
Operability in Go
Explore Go's standard library and runtime for improved service operations, covering instrumentation, stack inspection, and memory tracking techniques.
Writing Networking Clients in Go
Explore the high-performance NATS Go client, its APIs, and internal engine design for maximum throughput in the NATS Messaging System.
Forward Compatible Go Code
Explore strategies for writing Go code that remains compatible with future language versions, avoiding common pitfalls and ensuring long-term maintainability.
Understanding Channels
Explore the inner workings of Go channels, their operations, and how they interact with runtime systems for effective goroutine communication and concurrency patterns.
Valuable Lessons in Over-Engineering the Core of Kubernetes Kops
Explore lessons from over-engineering Kubernetes kops, discussing the journey of refactoring its core from complexity to clean, simple Go code.