Go ​

Prefer using Go for all code I want to run not in the browser (scripts, web services, servers of all kinds) due to it's fast compile speeds & performance.

I love the tooling around it like VS Code and its Go plugin. The powerful go command line tool and the rich ecosystem of libraries and tools that people have built.

Go promotes composition over inheritance.

Tour of Go & Learn Go with Tests are great places to learn Go. Go Internals is nice for more in depth look.

GoReleaser is useful for publishing. revive & Staticcheck are great linters.

Only thing I dislike about Go is it's verbosity especially with respect to errors. But that decision was made so all programmers are forced to not only consider the happy paths of their code & write proper error logging.

That said, I am exploring writing more code in Rust specifically because of Tauri.

It's useful to setup linters like GolangCI-Lint or commands from Go Recipes.

Guide to Go profiling, tracing and observability is useful read.

Concurrency in Go Fundamentals & Go Concurrency Patterns are great to read to understand concurrency better. Concurrency is not Parallelism.

ko seems nice for deploying Go as containers.

Commenting Go code ​

• Comments documenting declarations should be full sentences.
• Comments should begin with the name of the thing being described and end in a period.

Error checking ​

• You can log.Fatal(err) when playing with code.
  • In actual applications you need to decide what you need to do with each error response - bail immediately, pass it to the caller, show it to the user, log it and continue, etc ...

Notes ​

• 1 module should be contained in 1 git repo. If you have need for multiple repos make them each a module.
• I can call functions from anywhere if they are in the same package.
• The package “main” tells the Go compiler that the package should compile as an executable program instead of a shared library.
• Note that any type implements the empty interface interface{} because it doesn't have any methods and all types have zero methods by default.
• Simply pushing my source code to GitHub, makes it go gettable.
• Interface types represent fixed sets of methods.
• the prevailing wisdom in Go is to use a flat directory structure and only create new directories when you are building self-contained functionality.
• go get = download the source code to your PC.
• go install = download, build, and put it in the path so you can use it.
• I don't need to comment all functions as some are self describing. I do need to comment exported functions however.
• What works well is to use Go to create an HTTP API and leave the rest (html templates etc) to a client-side frontend (e.g. React). That gives you the best of both worlds: a fast and lightweight backend in Go with a rich frontend in JS.
• This is a core concept in Go’s type system; instead of designing our abstractions in terms of what kind of data our types can hold, we design our abstractions in terms of what actions our types can execute.
• In Go, as long as you are not sharing data, you don't really have to care about whether something is concurrent or parallel, the runtime takes care of it for you. You just use goroutines, IO transparently happens on a dedicated threadpool, CPU heavy tasks are spread out over the available cores.
• How to edit Go packages locally
• The main sell point of Go is not simplicity, but overall balance and flexibility
• Better make copies of a struct than passing pointers to it.
• I have grown to strongly dislike passing options by variable argument in Go ("...Option"). It makes a terrible mess of package documentation. Much easier to find and understand fields in an Options or Config struct.
• Go's RTS is built around a rather simple concurrent mark/sweep GC with all of the trade-offs that this implies. In the case of GHC you have a choice between a throughput-oriented moving GC and an (admittedly somewhat young) non-moving collector. On the low-latency front Go indeed has something of a head-start here, but GHC is now competitive and is improving with every release.
• Name your package for what it provides, not what it contains.
• Just use channels on the fly to transfer data concurrently and be done with it.
• To improve testability in my Go programs, the only thing I do in func main is call out to another function, passing in the ‘global’ things it needs. I can call run in test code like a normal function, and use a buffer for stdout (to make assertions about what it outputs.)
• Don't use deferred functions in main(), don't call os.Exit/log.Fatal outside of main()
• go get stores downloaded files in GOMODCACHE (can be found via go env).
• gotip allows you to use Go from the tip. It’s much easier than building Go from source code
• Keep everything private until something outside the package needs to access it.
• Go 1.18 workspaces seem awesome. One file in the root for your workspaces definitions + dependency overrides (http://go.work) and then a specfile (go.mod) and lockfile (go.sum) in each package—bigger diffs, but exactly what you want for Docker, PaaS, and sparse checkout
• go install golang.org/x/tools/cmd/godoc@latest will install latest Go tools including Godoc.
• The major problem in Go is that error is an interface, not the "errors as values" approach, the large amount of err != nil boilerplate is only a syntax sugar problem (ie. "lack of things"), not a language problem. Adding that sugar should be a simple 200 line diff in the compiler, in fact, if it had macros (another "lack of things" problem) we wouldn't be complaining about it. The major problem with error handling is the over reliance on interface for everything in the language, it's a symptom, not the cause. Go should have focused on built-in primitives instead of relying in reflection and interfaces for most things. Constructs for multiplexing/demultiplexing channels, built-in stack and queue data structures, etc. We wouldn't need generics if the language addressed the "lack of things" one by one. The major problem with Go is that the creators ignored language research and just hacked a C compiler to look like a modern language.

Code ​

// Log error
if err != nil {
  log.Fatal(err)
}

// Check for boolean flag (--dev here)
boolArgPtr := flag.Bool("dev", false, "Explain command..")
flag.Parse()
if *boolArgPtr != false {
  // ..
}

Links ​

• Tour of Go (Solutions)
• Effective Go (HN) (HN)
• How to Write Go Code
• Go proverbs
• Go Internals (Code)
• Go 101 - Book focusing on Go syntax/semantics and all kinds of runtime related things.
• Notes on Go
• Avoiding complexity in Go
• Go Spec
• Gopher reading list
• Go Code Review Comments
• Performance without the event loop (2015)
• 7 common mistakes in Go and when to avoid them by Steve Francia
• Performance without the event loop (2015)
• What I learned in 2017 Writing Go
• Golang interfaces
• Go in 5 minutes
• Learn Go with Tests (Code) (HN)
• Using Instruments to profile Go programs
• Design Philosophy On Packaging
• Go best practices, six years in
• Standard Package Layout
• Style guideline for Go packages
• Share memory by communicating
• Go Build Template
• Go for Industrial Programming - Great insights.
• Sum Types in Go
• Gophercises - Free coding exercises for budding gophers.
• Joy Compiler - Translate idiomatic Go into concise JavaScript that works in every browser.
• The Go Type System for newcomers
• Web Assembly and Go: A look to the future (2018)
• How I Learned to Stop Worrying and Love Golang
• List of advices and tricks in the Go's world
• Golang challenge
• dep2nix - Using golang/dep to create a deps.nix file for go projects to package them for nixpkgs.
• GopherCon 2018 - Rethinking Classical Concurrency Patterns - Slides (Video)
• Standard Go Project Layout (Not a standard Go project layout)
• Building Web Apps with Go
• Golang Monorepo - Example of a golang-based monorepo.
• Lorca - Build cross-platform modern desktop apps in Go + HTML5.
• Data Structures with Go Language
• go-hardware - Directory of hardware related libs, tools, and tutorials for Go.
• HN: Go 2, here we go (2018)
• gotestsum - Runs tests, prints friendly test output and a summary of the test run.
• Nice example of a small Go CLI tool
• GolangCI-Lint - Linters Runner for Go. 5x faster than gometalinter. Nice colored output. Can report only new issues. Fewer false-positives. Yaml/toml config.
• Nice VS Code Go snippets
• revive - Fast, configurable, extensible, flexible, and beautiful linter for Go.
• Going Infinite, handling 1M websockets connections in Go (2019)
• Awesome Go Linters
• Awesome Go Books (Reddit)
• Leaktest - Goroutine Leak Detector.
• Practical Go: Real world advice for writing maintainable Go programs (2018) (HN)
• The State of Go: Feb 2019
• gomacro - Interactive Go interpreter and debugger with generics and macros.
• go2ll-talk - Live coding a basic Go compiler with LLVM in 20 minutes.
• Thoughts on Go performance optimization
• Go Package Store - App that displays updates for the Go packages in your GOPATH.
• Why are my Go executable files so large? Size visualization of Go executables using D3 (2019)
• goweight - Tool to analyze and troubleshoot a Go binary size.
• Go Patterns - Curated list of Go design patterns, recipes and idioms.
• Go Developer Roadmap - Roadmap to becoming a Go developer in 2019.
• Clear is better than clever (2019) (HN)
• Retool - Vendoring for executables written in Go.
• Why Go? – Key advantages you may have overlooked
• Go Creeping In (2019) (HN)
• Getting to Go: The Journey of Go's Garbage Collector (2018)
• Clean Go Code - Reference for the Go community that aims to help developers write cleaner code.
• Go Language Server - Adds Go support to editors and other tools that use the Language Server Protocol (LSP).
• Go talks
• TinyGo - Go compiler for small places. (HN) (Web)
• Yaegi - Another Elegant Go Interpreter.
• Delve - Debugger for the Go programming language.
• Experiment, Simplify, Ship (2019)
• Go programming language secure coding practices guide
• Ultimate Go Study Guide (HN)
• Redress - Tool for analyzing stripped binaries.
• Ask HN: Is there a project based book or course on Go for writing web APIs? (2019)
• Data Structure Libraries and Algorithms implementation in Go
• GitHub Actions for Go - Using GitHub Actions as CI effectively for Go.
• NFPM - Simple deb and rpm packager written in Go.
• Why Go and not Rust? (2019) (HN) (HN)
• Algorithms implemented in Go (for education)
• go-callvis - Visualize call graph of a Go program using dot (Graphviz).
• goo - Simple wrapper around the Go toolchain.
• Go Cheat Sheet - Overview of Go syntax and features.
• packr - Simple and easy way to embed static files into Go binaries.
• Uber Go Style Guide (HN)
• Interpreting Go (2019)
• gijit - Just-in-time trace-compiled golang REPL. Standing on the shoulders of giants (GopherJS and LuaJIT).
• unconvert - Remove unnecessary type conversions from Go source.
• Gox - Simple Go Cross Compilation.
• Learning Go: Lexing and Parsing (2016)
• Running a serverless Go web application (2019)
• Awesome Go Storage
• Go Modules: v2 and Beyond (2019)
• Let's Create a Simple Load Balancer With Go (2019) (HN)
• The Value in Go's Simplicity (2019) (HN)
• Google OAuth Go Sample Project - Web application
• Go’s features of last resort (2019) (Lobsters) (HN)
• Minigo - Small Go compiler made from scratch. It can compile itself. The goal is to be the most easy-to-understand Go compiler.
• Babygo - Go compiler made from scratch, which can compile itself. Smallest and simplest in the world.
• Writing An Interpreter In Go (HN) (Notes)
• Source Code for Go In Action
• garble - Obfuscate Go builds.
• Using Makefile(s) for Go (2019)
• The Go runtime scheduler's clever way of dealing with system calls (2019) (HN)
• Go Things I Love: Methods On Any Type (2019) (Reddit)
• Golang for Node.js Developers - Examples of Golang examples compared to Node.js for learning.
• Testing in Go: Test Doubles by Example (2019)
• Chime - Go editor for macOS. (HN) (GitHub) (ChimeKit)
• Go Things I Love: Channels and Goroutines (2020) (HN)
• go-ruleguard - Define and run pattern-based custom linting rules.
• Go by Example - Hands-on introduction to Go using annotated example programs. (Code)
• Introduction to Programming in Go book
• A Chapter in the Life of Go’s Compiler (2020)
• JWT Authorization in Golang (2019)
• govalidate - Validates your Go installation and dependencies.
• Go: Best Practices for Production Environments
• Go Code Review Comments
• A theory of modern Go (2017)
• Golang IO Cookbook
• cob - Continuous Benchmark for Go Project.
• Concurrency in Go - Fundamentals (2018)
• Go + Services = One Goliath Project (2020) (HN)
• Pure reference counting garbage collector in Go (HN)
• JSON to Go - Convert JSON to Go struct. (Code)
• The await/async concurrency pattern in Golang (2020)
• Exposing interfaces in Go (2019)
• Go Error Handling — Best Practice in 2020
• An Introduction To Concurrency In Go (2020)
• Concurrency in Go book (2017)
• PubSub using channels in Go (2020)
• Build Web Application with Golang book
• SOLID Go Design (2016)
• Algorithms with Go course
• Interfaces in Go (2018) - Interface is a great and only way to achieve Polymorphism in Go.
• Allocation efficiency in high-performance Go services (2017)
• service-training - Training material for the service repo.
• Starter code for writing web services in Go
• How I write Go HTTP services after seven years (2018)
• Let's Go! Learn to Build Professional Web Applications With Golang
• Go's Tooling Is an Undervalued Technology (2020) (HN)
• GoProxy - Global proxy for Go modules. (Web)
• Adrian Cockcroft: Communicating Sequential Goroutines (2016)
• Go FAQ
• gosec - Golang Security Checker. (HN)
• Inlined defers in Go (2020)
• Andre Carvalho - Understanding Go's Memory Allocator (2018) (Video)
• Make resilient Go net/http servers using timeouts, deadlines and context cancellation (2020) (Lobsters)
• tparse - Command line tool for analyzing and summarizing go test output.
• Go Walkthrough - Series of walkthroughs to help you understand the Go standard library better.
• Go modules by example
• curl-to-Go - Instantly convert curl commands to Go code. (Code)
• Best Practices for Errors in Go (2014)
• Go command overview
• Functional options on steroids (2020) (Reddit)
• Go internals: capturing loop variables in closures (2020)
• go-mod-upgrade - Update outdated Go dependencies interactively.
• go: observing stack grow and shrink (2020)
• Readiness notifications in Go (2020)
• GoReleaser - Deliver Go binaries as fast and easily as possible. (Example)
• Zen of Go - Ten engineering values for writing simple, readable, maintainable Go code. (Code) (HN) (Talk)
• go-clean-arch - Go Clean Architecture based on Reading Uncle Bob's Clean Architecture.
• Why Discord is switching from Go to Rust (2020) (HN) (Reddit) (Lobsters)
• Running Go CLI programs in the browser (2020) (Lobsters)
• GoDays Go talks (2020)
• Golang basics - writing unit tests (2017)
• Buffered channels in go: tips & tricks (2020)
• The Evolution of a Go Programmer
• Staticcheck - Collection of static analysis tools for working with Go code. (Web)
• Go Diagnostics
• Experience report on a large Python-to-Go translation (HN) (HN) (Lobsters)
• profefe - Collect profiling data for long-term analysis.
• Go support for Mobile devices
• Go for Cloud (2020)
• Why are my Go executable files so large? - Size visualization of Go executables using D3.
• Testing in Go: Clean Tests Using t.Cleanup (2020)
• Go Up - Checks if there are any updates for imports in your module.
• I want off Mr. Golang's Wild Ride (2020) (HN) (Lobsters)
• Early Impressions of Go from a Rust Programmer (2020)
• Install go tools from modules with brew-gomod (2020)
• Illustrated Tales of Go Runtime Scheduler (2020)
• Google Cloud Platform Go Samples
• prealloc - Go static analysis tool to find slice declarations that could potentially be preallocated.
• Why you shouldn't use func main in Go (Lobsters)
• Diago - Visualization tool for CPU profiles and heap snapshots generated with pprof.
• pkgviz-go - Generate a visualization of a Go package's types.
• Setup for Your Next Golang Project (HN)
• HN: Go Turns 10
• Benchmarking Go programs (2017)
• gopkg - Service provides versioned URLs that offer the proper metadata for redirecting the go tool onto well defined GitHub repositories. (Code)
• Go Binaries - On-demand binary server, allowing non-Go users to quickly install tools written in Go without installing go itself. (Article) (Web)
• gosize - Analyze size of Go binaries.
• tre - LLVM backed Go compiler.
• Statically compiling Go programs (2020)
• Understanding bytes in Go by building a TCP protocol (2020)
• Go Quirks (2020)
• Debugging with Delve (HN)
• GoDoc Tricks (Code)
• Thanos Coding Style Guide
• faillint - Report unwanted import path and declaration usages.
• Broccoli - Using brotli compression to embed static files in Go.
• Export data, the secret of Go's fast builds (2020)
• Awesome Go performance
• Understand Go pointers in less than 800 words or your money back (2017) (Reddit)
• Go & iOS: remember to enable Cocoa multithreading (2020)
• Go Tools - Various packages and tools that support the Go programming language.
• Collection of Technical Interview Questions solved with Go
• Go Project Design Documents
• Inlining optimisations in Go (2020)
• Examples for my talk on structuring Go apps
• Rob Pike interview: “Go has indeed become the language of cloud infrastructure“ (2020) (HN)
• I think you should generally be using the latest version of Go (2020) (Lobsters)
• Go Build Tools - Go's continuous build and release infrastructure.
• What's coming in Go 1.15 (Lobsters)
• Writing Useful go/analysis Linter (2019)
• How to check whether a struct implements an interface in GoLang (Lobsters)
• How the Go runtime implements maps efficiently (without generics) (2018)
• Write your own Go static analysis tool (2020) (Lobsters)
• Hand-crafted Go exercises and examples (HN)
• GoLand Tips & Tricks
• gorram - Like go run for any go function.
• errwrap - Go tool to wrap and fix errors with the new %w verb directive.
• mockery - Mock code autogenerator for golang.
• Writing type parametric functions in Go (2013)
• maybedoer: the Maybe Monoid for Go (2020) (Lobsters)
• Learning Go (2020)
• golintui - TUI tool that helps you run various kinds of linters with ease and organize its results, with the power of golangci-lint.
• Instrumentation in Go (2020) (HN)
• Go Vanity URLs - Simple Go server that allows you to set custom import paths for your Go packages.
• Pkger - Embed static files in Go binaries.
• asmfmt - Go Assembler Formatter.
• Diving into Go by building a CLI application (2020) ([HN]) (Reddit)
• Go and CPU Caches (2020)
• go-mod-outdated - Easy way to find outdated dependencies of your Go projects.
• Featherweight Go (2020) (HN) (Talk) (Implementation)
• lean - Smart Go module dependency inspection and pruning.
• impl - Generates method stubs for implementing an interface.
• Air - Live reload for Go apps. (HN)
• The Go compiler needs to be smarter (2020) (HN) (Reddit)
• Swag - Converts Go annotations to Swagger Documentation 2.0.
• The Cache Replacement Problem (2020)
• Tengo - Small, dynamic, fast, secure script language for Go.
• Getting Hands-on with io_uring using Go (2020)
• json2go web parser - Paste json to generate go struct. (Code)
• Writing Go CLIs With Just Enough Architecture (2020) (Reddit)
• Go SPA - Tiny Single Page Application server for Go with spa command-line tool.
• Featherweight Generic Go Generator
• An intro to Go for non-Go developers (2020) (Lobsters)
• Ultimate Go Programming Videos (2018)
• Building a better Go linker (2019)
• Gdlv - GUI frontend for Delve.
• The Next Step for Generics (2020) (HN) (Reddit) (Lobsters)
• oto - Go driven rpc code generation tool for right now.
• In Go, the compiler needs to know the types of things when copying values (2020) (Lobsters)
• exportloopref - Analyzer that finds exporting pointers for loop variables.
• A Concise Guide to the Latest Go Generics Draft Design (2020) (HN)
• fgprof - Sampling Go profiler that allows you to analyze On-CPU as well as Off-CPU (e.g. I/O) time together. (Tweet)
• How To Code in Go book by Digital Ocean (2020)
• astextract - Convert a go file to its ast representation.
• binclude - Include files in your binary the easy way.
• Go Modules- A guide for monorepos (2020)
• Generics for Go (2020) (Lobsters)
• Go is boring, and that’s fantastic (2020) (HN) (Reddit)
• godepgraph - Program for generating a dependency graph of Go packages.
• [RU] Multithreading in Go - Aliaksandr Valialkin (2018)
• A Go lesson learned: sometimes I don't want to use goroutines if possible (2020) (Lobsters)
• Why Go’s Error Handling is Awesome (2020) (HN) (Reddit)
• Keeping Your Modules Compatible (2020) (HN)
• Using go/analysis to fix your source code (2020)
• "Interface smuggling", a Go design pattern for expanding APIs (2020)
• What feature of Go is used often by experienced programmers, but not so much by a newbie? (2020)
• copyist - Mocking your SQL database in Go tests has never been easier. (HN)
• PopCount on ARM64 in Go Assembler (2020)
• GopherCon Europe: Online 2020
• Go’s History in Code (2020)
• The impact on middleware of expanding APIs with Go's interface smuggling (HN)
• Important Reading for Go
• Life without line numbers (2020)
• Go draft design proposal for file system interfaces and embedding files (2020)
• Gebug - Debug Dockerized Go applications better.
• Pkg.go.dev is more concerned with Google's interests than good engineering (2020) (HN)
• Break The Golang Context Chain (2020) (Lobsters)
• Go vs Rust: Writing a CLI Tool (2020) (HN) (Lobsters)
• File System Interfaces for Go – Draft Design (HN)
• GoPlus - Go+ language for data science. (Web) (HN) (Reddit)
• Proposal: Register-based Go calling convention (2020)
• Little Go Book
• Speeding up json processing in go (2020)
• Implementing traceroute in Go (2020)
• Notes on working with Go and computer systems
• DepsCheck - Dependency checker for Golang (Go) packages. Prints stats and suggests to remove small LeftPad-like imports if any.
• Fuzzing in Go (2020)
• Fundamentals of Go
• gore - Go REPL that works nicely. Featured with line editing, code completion, and more.
• Testing Database Transactions in Go (2020) (HN)
• An interesting mistake with Go's context package (2020) (HN)
• Even in Go, concurrency is still not easy (2020) (HN) (Lobsters)
• Learning Go notes
• The Within Go Repo Layout (2020)
• Writing multi-package analysis tools for Go (2020)
• Python and Go (2020)
• Surprises and Gotchas When Working With JSON (2020)
• Package Management With Go Modules: The Pragmatic Guide (2019)
• Polymorphism in Limbo and Go 2 (2020) (Lobsters)
• I wrote Go code for 3 weeks and you won’t believe what happened next (2020)
• depaware - Makes you aware of your Go dependencies. It generates a list of your dependencies which you check in to your repo.
• goup - Elegant Go version manager. (Article)
• C2go - C to Go translation tool.
• Statsviz - Instant live visualization of your Go application runtime statistics (GC, MemStats, etc.).
• Minimal go webapp (2020)
• Test with Go - Learn how to test real, complex software written in Go.
• Web Development with Go - Learn to Create Real Web Apps in Go.
• Prefer table driven tests (2019)
• go-module-knobs - List of go module knobs for controlling CI, vendoring, and when go commands access the network.
• Go day on Google Open Source Live - Go experts will share updates on everything from Go basics to Package Discovery and Editor Tooling.
• Chronos - Static race detector for the go language.
• Goda - Go Dependency Analysis toolkit.
• Go Regular Expressions (2020)
• Build a Go Router From Scratch (2020)
• Benchmarks of Go serialization methods
• Choosing the best adhesive for Go code
• Building a Mapping Language in Go with Parser Combinators (2020)
• go-bindata - Small utility which generates Go code from any file. Useful for embedding binary data in a Go program.
• Gopium - Smart Go Structures Optimizer and Manager.
• Nex - Lexer for Go. (Web)
• Go Training - Learning basic Go in one day.
• Ask HN: Go programming language is over ten years old. What do you think of it? (2020)
• Awesome Go code formatters
• Gofumpt - Stricter gofmt. (HN) (Lobsters)
• Go Wasm - In-browser IDE for Go using WebAssembly. (Code)
• Hash Tables Implementation in Go. The inner implementation. (2020)
• GopherLabs - Ultimate Workshop Track for Go Developer. (Code)
• Three Months of Go (from a Haskeller's perspective) (2016) (Lobsters)
• Rust vs Go (2020) (HN) (Reddit: Go) (Reddit: Rust)
• Gochk - Static Dependency Analysis Tool for Go Files.
• Manual Memory Management in Go using jemalloc (2020) (HN) (HN 2)
• go-critic - Highly extensible Go source code linter providing checks currently missing from other linters.
• Eleven Years of Go (2020) (HN)
• Go Systems Conf
• play-with-go.dev - Series of hands-on, interactive, browser-based guides that introduce the tools required to work with Go .
• go-safer - Go linter in the style of go vet to find incorrect uses of reflect.SliceHeader and reflect.StringHeader, and unsafe casts between structs with architecture-sized fields.
• A Concurrent Sudoku Solver with Channels (2020)
• structslop - Static analyzer for Go that recommends struct field rearrangements to provide for maximum space/allocation efficiency.
• GopherCon 2020 Playlist
• GopherCon 2020: Go Team AMA
• Digital Ocean App Platform sample Go application
• GoGraph - Builds graphs out of Go source code.
• rf - Refactoring tool for Go. (Docs)
• Statsview - Real-time Go runtime stats visualization profiler.
• Awesome Go Interview Questions and Answers (Code)
• semgrep-go - Go rules for semgrep and go-ruleguard.
• gocov - Coverage testing tool for Go.
• Go Server/API boilerplate using best practices, DDD, CQRS, ES, gRPC
• Golds - Experimental Go local docs server/generator and code reader.
• generate - Generates Go Structs from JSON schema.
• Go: A Documentary - Collects many interesting (publicly observable) issues, discussions, proposals, CLs, and talks from the Go development process. (Code)
• gotesplit - Splits the testing in Go into a subset and run it. It is useful for the CI environment.
• Go Resources - Find the best Go learning materials on the web.
• go-gin-starter - Opinionated Go starter with gin for REST API, logrus for logging, viper for config with added graceful shutdown. (Reddit)
• Gval - Provides support for evaluating arbitrary expressions, in particular Go-like expressions.
• Athens - Go module datastore and proxy.
• Unsafe string interning in Go (2020)
• go-clean-architecture - Write Go using clean architecture.
• Go with Clean Architecture (Article)
• Learn Go in 5 mins (Lobsters) (HN)
• gomod - Go modules analysis tool.
• Go as a dynamic plugin language for Go (Lobsters)
• GolangWeekly Searcher
• Go Cheat Sheet
• Elegancy of Go's error handling (2021) (Lobsters)
• holmes - Self-aware Go profile dumper.
• Go Repository Template - GitHub repository template for Go. It has been created for ease-of-use.
• GopherCon Europe 2020
• A Proposal for Adding Generics to Go (2021) (HN) (Reddit)
• Gomod2nix - Convert applications using Go modules -> Nix.
• So just how fast are channels anyway? (2017)
• Go Slice Tricks Cheat Sheet (Code)
• REST Servers in Go (2021) (HN)
• Non-blocking I/O in Go (2019)
• Go Profiler Notes - Notes on the various go profiling methods that are available.
• A Tour of Go 1.16's io/fs package (2021) (Lobsters)
• Packages as layers, not groups (2021)
• gosivy - Real-time visualization tool for Go process metrics.
• Working with SQL Relations in Go (2020)
• Real-world SQL in Go (2021) (Reddit)
• Go internals: invariance and memory layout of slices (2021)
• List of Go best practices
• Coming in Go 1.16: ReadDir and DirEntry (2021)
• On Go 2 Generics (2021) (Lobsters)
• Practical Go - Collection of real world advice for writing maintainable Go programs. (TOC)
• Leveraging the Go Type System (2021) (HN)
• Go generics proposal has been accepted (2021) (HN)
• Securing a Go Microservice with JWT (2021)
• Generics in Go Tutorial (2021)
• Go is not an easy language (2021) (HN) (Lobsters)
• Exploring "io/fs" to Improve Test Performance and Testability (2021)
• In Go-land you pay even for what you don't use (2021)
• 5 Common mistakes in Go (2021) (Reddit)
• How I build web frontends in Go (2021) (Reddit)
• Goroutines Are Not Significantly Lighter Than Threads (2021) (Lobsters)
• netaddr.IP: a new IP address type for Go (2021)
• Go Interface Examples - Examples of using Go interfaces to make cleaner, more testable code.
• Darker Corners of Go (2021) (Lobsters) (HN)
• The ecosystem of the Go programming language (2021) (HN)
• Practical Go Lessons Book (HN)
• Life of a Go module (2021)
• Gotchas in the Go Network Packages Defaults (2021)
• Common anti-patterns in Go (2021)
• How does Go know time.Now? (2021)
• Spaghetti - Dependency analysis tool for Go packages.
• Go HTTPS servers with TLS (2021)
• goenv - Go Version Management.
• Good books for advanced go topics and how things are working under the hood (2021)
• Understanding Allocations: the Stack and the Heap (2019)
• Why people hate Go? (2021)
• Ask HN: Are you using Go for web development? (2021)
• Generate Go client and server boilerplate from OpenAPI 3 specifications
• How to structure a go project? (2021)
• Mugo, a toy compiler for a subset of Go that can compile itself (2021) (HN) (Code)
• Mocking dependencies in Go with implicit interfaces (2021)
• gops - Command to list and diagnose Go processes currently running on your system.
• Go8 - Go + Postgres + Chi Router + sqlx, unit testing Starter Kit for API Development.
• xo - Command-line tool to generate Go code based on a database schema or a custom query.
• Tiny Container Challenge: Building a 6kB Containerized HTTP Server (2021) (HN)
• Build, notarize, and sign Golang binaries for MacOS with GitHub Actions (2020) (Code)
• Network Programming with Go by Adam Woodbeck (2021)
• Network Programming with Go by Jan Newmarch (HN)
• Go Modules Cheat Sheet (HN)
• uGo - Fast, dynamic scripting language to embed in Go applications.
• Best examples of a Go client (2021)
• The Ultimate Guide to JSON in Go (2021)
• Branchless Coding in Go (2021) (HN)
• pprof++: A Go Profiler with Hardware Performance Monitoring (2021) (HN)
• Calling C code from go (2018)
• profile - Simple profiling for Go.
• Thoughts on how to structure Go code (2021) (Reddit)
• Go With The Domain - Building Modern Business Software in Go. (HN)
• Learning Go Book (2021) - Idiomatic Approach to Real-World Go Programming. (Review)
• Constant-Time Big Numbers: An Introduction (2021)
• How to best use Go for writing web services (2021)
• GoReleaser Pro - Fork of the OSS version you already use everyday, with extra features. (Docs)
• Functional Programming in Go with Generics (2021) (HN)
• The Cult of Go Test (2016) (Lobsters)
• Rabbit - Lightweight service that will build and store your go projects binaries, Integrated with Github.
• xgo - Go CGO cross compiler.
• gopatch - Refactoring and code transformation tool for Go.
• A guide to linting Go programs (2021)
• Go: Fuzzing Is Beta Ready (2021) (HN)
• Optimistic Concurrency Control for Real-world Go Programs (2021)
• Go rules for Bazel
• Go Error Handling Proposals (HN)
• Go 1.17 Beta (2021) (HN)
• Everyday Go Book (2021) - Fast way to learn tools, techniques and patterns from real tools used in production. (Article)
• Go: Don’t just check errors, handle them gracefully (2016)
• Useful bootstrap checklist for Go Projects
• Building a Hotwired web app with Go and Templ (2021)
• Go 1.17 is deprecating the traditional use of 'go get' (2021) (HN) (Reddit) (Lobsters)
• Go Recipes - Handy commands to run in Go projects.
• Deploy a Go app with Dokku (HTTPS and auto-deployment) (2021)
• Go Concurrency - Worker Pool Pattern
• Awesome Go Workshops
• Pipeline Pattern in Go (2021)
• Fixed/Variable-length encoding in Go (2021)
• Notes on structured concurrency, or: Go statement considered harmful (2018) (Lobsters) (HN)
• Benchmarks in Go can be surprising (2021) (Reddit)
• Copyfighter - Statically analyzes Go code and reports functions that are passing large structs by value.
• Updating the Go Memory Model (2021) (HN)
• Marshaling Struct with Special Fields to JSON in Go (2021)
• Accessing PostgreSQL databases in Go (2021) (Lobsters)
• Does the Go community have a problem with reinventing the wheel? (2021)
• Goscript - Go specs implemented as a scripting language in Rust.
• gohere - Install Go into a local directory.
• Map[string]interface{} in Go: a user's manual (HN)
• How to Go Series
• Create Go App CLI - Create a new production-ready project with backend, frontend and deploy automation by running one CLI command. (Wiki) (Fiber Backend template)
• Enumer - Tool to generate Go code that adds useful methods to Go enums (constants with a specific type).
• http2curl - Convert Golang's http.Request to CURL command line.
• Zero downtime with Go with many API endpoints? (2021)
• Go binary parser for IDAPro
• A Tale of Two Copies (2021)
• Awesome Go Security
• Go Report Card - Web application that generates a report on the quality of an open source Go project. (Code)
• GoKart - Static analysis tool for securing Go code. (HN)
• HN: Generics enabled by default in Go tip (2021)
• Error stack traces in Go with x/xerror (2021) (HN)
• How to best handle DB migrations in Go (2021)
• In Go, pointers (mostly) don't go with slices in practice (2021) (HN)
• Go is pass-by-value — but it might not always feel like it (2021) (Lobsters)
• A Guide to Interfaces in Go (2021)
• Go pattern: graceful shutdown of concurrent events (2020)
• The Go Programming Language Book (2015) (Code)
• Cloud Native Go Book (2021) (Code)
• Go’ing Insane: Endless Error Handling (2021) (HN) (Lobsters) (Lobsters)
• Go: Code of Conduct Updates (2021) (HN)
• Go'ing Insane Part Three: Imperfect Interfaces (2021) (Reddit)
• Go: How to update APIs for generics (2021) (HN)
• Practical DDD in Go: Aggregate (2021)
• Taming Go’s Memory Usage, or How We Avoided Rewriting Our Client in Rust (2021) (HN) (Lobsters) (Reddit)
• Go Playground WASM - Go playground powered by WASM that runs in the browser. (Code) (HN)
• Examples of accepting interfaces and returning structs
• RTS: Request to Struct - Generate Go structs definitions from JSON server responses.
• Go Docker Dependency Cache - Improved docker Go module dependency cache for faster builds.
• ClickHouse Data Synchromesh - Data syncing in Go for ClickHouse.
• Go website code
• Rewriting Go source code with AST tooling (2021)
• Awesome Go Style Guides
• Simple Lists: a tiny to-do list app written the old-school way (server-side Go, no JS) (2021) (Lobsters)
• Common Anti-Patterns in Go Web Applications (2021) (Reddit)
• Things Go needs more than generics (2021) (HN)
• The fanciest way of releasing Go binaries with GoReleaser (2021)
• Type-Safe HTTP Servers in Go via Generics (2021)
• Hey linker, can you spare a meg? (2021) (Lobsters) (HN)
• An Optimisation Story: Building a Code Scanner for Large Go Apps (2021)
• asciicheck - Simple linter to check that your code does not contain non-ASCII identifiers.
• Interfaces and Nil in Go, or, Don't Lie to Computers (2021)
• Thoughts on structuring Go projects (2021)
• State Machines in Go (2021)
• Hunting down a C memory leak in a Go program (2021) (HN)
• You Don't Need a Library for File Walking in Go (2021)
• Pre-Commit-Go - Set of git pre-commit hooks for Go with support for multi-module monorepos, the ability to pass arguments to all hooks, and the ability to invoke custom go tools.
• Go Concurrency Patterns
• Functional Options are named args on steroids (2021) (Reddit)
• RustGo: calling Rust from Go with near-zero overhead (2017)
• Discord Gophers (GitHub)
• Make your Go go faster! Optimising performance through reducing memory allocations (2018)
• Gofire - Command Line Interface Generator tool for Go.
• Sorting a Dependency Graph in Go (2021)
• Go 1.18 will embed source version information into binaries (2021) (HN) (Reddit)
• What annoys you about Go? (2021)
• A comprehensive guide to go generate (2021)
• What could Go wrong with a mutex, or the Go profiling story (2021) (HN)
• Expectations for generics in Go 1.18 (2021) (HN) (Reddit)
• golang-dev - Google Groups
• Extracting type information from Go binaries (2021)
• Estimating memory footprint of dynamic structures in Go (2021)
• Serving compressed static assets with HTTP in Go 1.16 (2021)
• Mocking interfaces with typed functions in Go (2021)
• Continuous benchmarking with Go and GitHub Actions (2021)
• Improving JSON readability in Go (2021)
• Pandora - High-performance load generator in Go language.
• Uber Go Rules - Set of ruleguard rules that try to cover some parts of the Uber Go Style Guide.
• Visualize a hierarchy of embedded Go structs
• Go 1.18 summary (Article)
• goroutine-inspect - Interactive tool to analyze Go goroutine dump.
• Golang AST visualizer (Code)
• errchkjson - Go linter that checks types that are json encoded - reports unsupported types and unnecessary error checks.
• Golang News
• Using Generics in Go (2021)
• ineffassign - Detect ineffectual assignments in Go code.
• Twelve Years of Go (2021) (HN)
• go-perftuner - Helper tool for manual Go code optimization.
• Rust + Go - Shows how, by combining cgo and Rust's FFI capabilities, we can call Rust code from Go.
• Go Vulnerability Database
• Wild Workouts - Go DDD example application. Complete project to show how to apply DDD, Clean Architecture, and CQRS by practical refactoring.
• Best ways to learn Go for experienced devs (2021)
• Maintainable Go Projects (2021)
• A rough proposal for sum types in Go (2018) (HN)
• Contributing the Go Compiler: Adding New Tilde (~) Operator (2021) (Lobsters)
• Improving the code from the official Go RESTful API tutorial (2021) (Lobsters)
• Go Pattern: Scoped HTTP Handlers (2021)
• GOMODEST - Complex SAAS starter kit using Go, the HTML/template package, and sprinkles of JS. (Article) (Template)
• Berkeley Packet Filter in Go (2021)
• Using interfaces in Go (2021)
• go2cpp - Converter from Go to C++.
• Go Race Detector (2013) (Tweet)
• From JPEG to JFIF via an io.Writer (2021)
• golang-tip - Daily builds of active Go development branches.
• Writing an application using Go and PostgreSQL (2021) (HN) (Code)
• Go Playground
• Go Play Space - Advanced Go Playground frontend written in Go, with syntax highlighting, turtle graphics mode, and more. (Code)
• Go Does Not Need a Java Style GC (2021) (HN) (Reddit)
• Golang 1.18: What You Need To Know (2021) (Reddit)
• Practical SOLID in Go series
• Practical DDD in Go series
• GOOS=libc
• Faster software through register based calling (2021) (Lobsters) (HN)
• Property-Based Testing In Go (2021) (Reddit)
• golangci-lint-langserver
• Demo app showing an end-to-end CI pipeline with Github Actions, goreleaser and ko
• GopherCon UK 2021 - YouTube
• Faster Top Level Domain Name Extraction with Go (2021) (Lobsters)
• Go memory watchdog - Library to curb OOMs by running Go GC according to a user-defined policy.
• Go's io/fs package, with a touch of embed (2021)
• Search over a Go corpus (Code)
• GopherCon 2021 "Production AI with Go" Workshop
• golang-crossbuild - Set of Docker images containing the requisite cross-compilers for cross compiling Go applications.
• Hacking Go compiler to add a new keyword (2021) (HN)
• Gors - Experimental go toolbelt written in rust (parser, compiler).
• Become an expert Go cloud developer (Twitter)
• go-errorlint - Source code linter that can be used to find code that will cause problems with Go's error wrapping scheme.
• Awesome Go Education
• Introducing Serialized Roaring Bitmaps in Golang (2021)
• Golang Base Project - Minimal Go project with user authentication ready out of the box. All frontend assets should be less than 100 kB on every page load.
• Portscan - Port scanning examples to teach Go concurrency bounding.
• A Guide To Writing Logging Middleware in Go (2020)
• HN: Go Replaces Interface{} with 'Any' (2021)
• Go 1.18 Beta 1 is available, with generics (2021) (Lobsters) (HN)
• Trying Out Generics in Go (2021) (HN)
• Why Go Getting Generics Will Not Change Idiomatic Go (2021)
• In Go 1.18, generics are implemented through code specialization (2021)
• Simple Bank - Contains the codes of the Backend master class.
• Backend master class [Go, Postgres, Docker] (Code)
• Applied Go Courses
• gogrep - Syntax-aware Go code search, based on the mvdan/gogrep.
• Generics facilitators in Go (2021) (HN) (Lobsters)
• Invoking C Code from Go
• Go Optimizations 101
• GoDMT - Tool that can parse Go files into an abstract syntax tree and translate it to several programming languages.
• Three Minor Features in Go 1.18 (2021) (HN)
• golang-nuts - Google Groups
• Learning Go Generics with Advent of Code (2021)
• Share your must-know Go development tips (2021)
• 100 Go Mistakes and How to Avoid Them (2021) (Code)
• Go and CPU Caches (2020)
• Parallel Merge Sort in Go (2018)
• The Top 10 Most Common Mistakes I’ve Seen in Go Projects (2019)
• Golang Design Initiative (GitHub)
• Errors and Error Wrapping in Go (2021)
• Spaceship Go - Journey into the Standard Library. (Code)
• Go Fuzzing (HN)
• Statically Detecting Go Concurrency Bugs
• perfguard - Static analyzer with emphasis on performance.
• Optimizing the size of the Go binary (Lobsters)
• Compiling a Go program into a native binary for Nintendo Switch (2022) (HN)
• Effective Error Handling in Golang (2022) (Reddit)
• Learn Programming with Go, One Game at a Time (Reddit)
• Saving a Third of Our Memory by Re-ordering Go Struct Fields (2020) (Lobsters) (Reddit) (HN)
• Large-scale, semi-automated Go GC tuning (2020) (HN)
• Visualizing Concurrency in Go
• What I'd like to see in Go 2.0 (2022) (HN)
• Set of materials for Go workshops
• Minimal working examples of Go's unique features
• Goloader - Load and run Go code at runtime.
• Go binary size SVG treemap - Make treemap breakdown of Go executable binary.
• TSC is being ported to Go (2022) (HN) (Reddit)
• Mocking outbound http requests in go: you’re (probably) doing it wrong (2021)
• Go Compiler Explorer
• Know Go: Generics Book (Code)
• The Power of Go: Tools Book (Code)
• Optimizing GoAWK with a bytecode compiler and virtual machine (2022)
• Dumpster diving the Go garbage collector (2022)
• Go performance from version 1.2 to 1.18 (2022) (HN) (Lobsters)
• Mastering Your Error Domain (2022)
• When does a Goroutine actually start executing the code? (2022)
• Go internal ABI specification
• Efficient Go Book (2022) (Code)
• Go performance channel (Twitter)
• Profiling Go programs with pprof
• Scheduling In Go : Part I - OS Scheduler (2018)
• Internals of Go's new fuzzing system (2022) (HN)
• Powerful Command-Line Applications in Go: Build Fast and Maintainable Tools by Ricardo Gerardi (2021)
• enumcheck - Allows to mark Go enum types as exhaustive.
• dupl - Tool written in Go for finding code clones. Can find clones only in the Go source files.
• Go Webinar Course
• gup - Update binaries installed by "go install".
• “Sustainability with Rust” post misleading about Go (2022) (HN) (Tweet)
• Accepting payments in Go using Stripe (2022) (Reddit)
• Retrofitting Async/Await in Go 1.18 (2022)
• Better Go Playground - Powered by React and Monaco editor. (Code)
• How generics are implemented in Go 1.18 (2022) (HN)
• Reproducing Go binaries byte-by-byte (2017)
• Is Go's Grammar Context Free? (2022) (Lobsters)
• Can Generics Rescue Go's Clunky Error Handling? (2022)
• Go: A Documentary
• Awesome Go Security Resources
• Best Go Tutorials in Town (2022)
• Clean architecture/ best practices in Go (2022)
• Isolating problematic Cgo code (2022)
• Scripting with Go (HN)
• Network Automation with Go Book
• go-global-update - Update globally installed go binaries.
• gowatch - Command line tool that builds and (re)starts your go project every time you save a Go or template file.
• Go 1.18 Released (2022) (HN)
• Building a Backconnect Proxy in Go (2022)
• gospel - Lints Go source files for misspellings in comments, strings and embedded files.
• Write once, store anywhere: Extensible file systems for Go (2022) (HN)
• GoReSym - Go symbol parser that extracts program metadata.
• Паттерны проектирования с примерами на Go
• Behind the Scenes of Go Scheduler (2022)
• Pro Go Book (2022) (Code)
• An Introduction To Generics (2022) (Lobsters) (Reddit) (HN)
• Why We Write Everything in Go (2022)
• Go Fuzz Testing (2022) (HN)
• IASM - Interactive Assembler for Go.
• Generics can make your Go code slower (2022) (HN) (Lobsters) (Reddit)
• Generics Can Be Fast (If They’re Value Types) (2022) (Reddit)
• How Go Mitigates Supply Chain Attacks (2022) (Lobsters) (HN)
• Faster sorting with Go generics (2022) (HN)
• Rethinking Visual Programming with Go (2022)
• Go Concurrency Guide - Practical concurrency guide in Go, communication by channels, patterns.
• Quick tip: Easy test assertions with Go generics (2022) (Reddit)
• Go Generics for Field Level Database Encryption (2022)
• Where can I learn about pointer & goroutines in depth? (2022)
• Best Go books for 2022
• A Deep Dive Into Go Concurrency (2022)
• Breaking the Monolith at Twitch: Part One (2022) (Reddit)
• When To Use Generics (2022) (Reddit)
• Go's use at Google
• A Study of Real-World Data Races in Go (2022)
• Building a Golang JSON HTTP Server (2021)
• Golang dev with Kubernetes, Helm and Skaffold (2022)
• PMGO - Process manager for Go applications.
• The Go Programming Language and Environment (2022) (HN) (HN)
• Beating grep with Go (2022) (Lobsters)
• Lies we tell ourselves to keep using Go (2022) (HN) (Tweet) (Reddit) (Lobsters)
• Experience Report: 6 months of Go (2022) (Reddit) (HN)
• A faster lexer in Go (2022) (HN)
• Implementing a Merkle tree for an Immutable Verifiable Log (in Go) (HN)
• goplay: Embed Go Playground on your Website (2022) (Code)
• Safer Enums in Go (2022) (Lobsters) (HN)
• Parallel tree running (2022)
• Concurrency in Go resources
• Calculating type sets is harder than you think (2022) (HN)
• Operator constraints in Go (2022) (HN)
• Go Nulls and SQL (2022) (HN)
• We Already Have Go 2 (2022) (Lobsters)
• Debugging Go applications with Delve Workshop
• Go Concurrency Exercises - Exercises for Go's concurrency patterns.
• Nightly builds with GoReleaser and GitHub Actions (2022)
• Trail of Bits public Semgrep rules
• Why Infer Types? (2022) (HN)
• exhaustruct - Go analyzer that finds structures with uninitialized fields.
• God - Automation tool to deploy and manage Go services using systemd on GNU/Linux machines.
• Mock programs to test os/exec in Go (2022)
• Goroutines Under The Hood (2020)
• Performance of coroutine-style lexers in Go (2022) (HN)
• Data Race Patterns in Go (2022) (HN)
• Issues with Go (2022)
• Mastering Go Concurrency
• The Y Combinator in Go with generics (2022) (HN)
• Largest Go codebases to study (2022)
• Ten Reasons Why I Don't Like Go (2016) (HN)
• Making Quamina Faster (2022)
• Go Template Preview - Quick test and visualize your Go templates live. (HN)
• Go grammar for tree-sitter
• Advanced Go Fuzzing Techniques (2022)
• Surprising result while transpiling C to Go (2022) (HN)
• Learn Go by fixing tiny incorrect programs
• Go Patterns - Fanning
• Go Course: Master the fundamentals and advanced features (Code)
• We Halved Go Monorepo CI Build Time (2022) (HN)
• Awesome Go Education (Code)
• Small Tables with Go generics (2022) (HN)
• gotraceui - Efficient frontend for Go execution traces.
• Nancy - Tool to check for vulnerabilities in your Go dependencies, powered by Sonatype OSS Index.
• go-graph - Searching Go code with a graph database. (Using Graphs to Search for Code)
• What to forget when coming to Go from other languages? (2022)
• Ask HN: Should I learn Rust or Go? (2022)
• PocketBase - Open source real time Go backend in one file. (Web) (HN) (Docs) (JS SDK)
• What’s new in Go 1.19? (2022)
• Go memory ballast: How I learnt to stop worrying and love the heap (2018)
• Implementing a simple jq clone in Go, and basics of Go memory profiling (2022)
• Goscript Internals: Goroutine, pointer and the VM architecture (2022)
• Lensm - Go assembly and source viewer. (HN) (Article)
• A Guide to the Go Garbage Collector (HN)
• Favorite Go Hosting Service (2022)
• Goof - Lets you call functions in your binary with just the string of their name.
• gx - Go -> C++transpiler meant for data-oriented gameplay and application programming especially for WebAssembly.
• gorepro - Easily reproduce Go binaries.
• How to learn more about optimizing/compiling Go programs (2022)
• Resources to learn Go (2022)
• Writing a Hash Table in Go (2021)
• Using Firecracker and Go to run short-lived, untrusted code execution jobs (2021) (HN)
• Align the happy path to the left edge
• Go Flow Levee - Static analysis tool works to ensure your program's data flow does not spill beyond its banks.
• Go 1.19 Released (2022) (HN)
• [WTF] Go Unicode Hack to Get Pseudo-Generics
• Shared memory and Go
• The ‘fat service’ pattern for web applications (2022) (Lobsters)
• Fixing Memory Exhaustion Bugs in My Go Web App (2022)
• Rob Pike's simple C regex matcher in Go (2022) (HN)
• Preferred resource for 'advanced' Go (2022)
• Hooking Go from Rust (2022) (HN)
• How do you monitor your Go apps?
• Cost of a Integer Cast in Go (2022) (HN)
• Bill Kennedy - Practical Memory Profiling (2022)
• GopherCon Europe: Berlin 2022 - YouTube
• Vulnerability Management for Go (2022) (HN)
• Go Developer Survey 2022 Q2 Results (HN)
• mkctr - Cross platform container builder for go.
• Neither self nor this: Receivers in Go (2016)
• Structured, leveled logging in Go's standard library (HN) (Lobsters)
• goast - Go AST (Abstract Syntax Tree) based static analysis tool with Rego.
• Proposal: profile-guided optimization (2022)
• Coolest Go open source projects you have seen (2022)
• Goroutine-analyzer - Visual goroutine stack dump debugging tool. (HN)
• fgtrace - Full Go Tracer.
• GopherCon UK
• Michael Knyszek - Respecting Memory Limits In Go (2022)
• Bitmap Indexes in Go: Search Speed (2019) (HN)
• Go Watch - Missing watch mode for the go command. It's invoked exactly like go, but also watches Go files and reruns on changes.
• Maps and Memory Leaks in Go (2022) (HN)
• Path to OOD with Go - Workshop
• Gobra - Automated, modular verifier for Go programs, based on the Viper verification infrastructure.
• Redefining for Loop Variable Semantics (Lobsters)
• How to build a WaitGroup from a 32-bit integer (2022)
• Rapid prototyping in Go (2022)
• Go: Redefining For Loop Variable Semantics (HN)
• Autostrada - Codebase generator for Go projects. (Reddit)
• Go News Twitter
• Go Worker Pool: The Concurrency Powerhouse (2022)
• When is a slice of any not a slice of any? (2022)
• Incremental parsing in go (2022) (HN)
• Slides and Links for 2022 GopherCon talks
• GopherCon (GitHub)
• GoLang Tutorials Blog
• Another iterator proposal from the Go team (Lobsters)
• No safe efficient ways to do three-way string comparisons in Go (2022) (HN)
• Russ Cox - Compatibility: How Go Programs Keep Working (2022)
• Goat - Extended flavor of the Go programming language, aiming for increased value safety and maintainability.
• Using Go's runtime/cgo to pass values between C and Go (2022)
• Golang Aha! Moments: Generics (2022)
• Size visualization of Go executables using D3
• The Problem with Go (2022) (HN)
• Thread-Local State in Go (2022)
• alphavet - Go linter to detect functions not in alphabetical order. (HN)
• Thoughts on the "Guard" Proposal for Go's Error Handling (2022) (Reddit)
• Go Concurrency Patterns: Pipelines and cancellation (2014)
• How I write offline API tests in Go (2022)
• A GC-Friendly Go Interning Cache (2022)
• Thirteen Years of Go (2022) (HN)
• go-mutesting - Framework for performing mutation testing on Go source code.
• Making a Go program 70% faster with a one character change (2022) (HN)
• Google’s Go Style Guide (HN) (Reddit) (Lobsters)
• Google Go Style Best Practices
• Most modern Go books (2022)
• Why is Go's Garbage Collection so criticized? (2022)
• From Service to Platform: A Ranking System in Go (2022)
• The Carcinization of Go Programs (2022) (Lobsters) (HN)
• musttag - Go linter that enforces field tags in (un)marshaled structs.
• Ask HN: What do you like/dislike about Go? (2022)
• Building CloudQuery: High Performance Data Integration Framework in Go (2022)
• Make Go usable in Shell on Fish or Zsh
• Donia Chaiehloudj - TinyGo: Getting the Upper Hen (2022)
• Production Ready Go Concurrency (2022) (Talk)
• Functional table-driven tests in Go (2022)
• New in Go 1.20: wrapping multiple errors (2022) (HN)
• Obscure Go Optimisations - Bryan Boreham (2022)
• Coverage profiling support for integration tests
• 7 days Go programs from scratch
• Go 2 Draft Designs
• Building Go programs with Nix Flakes (2022) (HN)
• Rubbing control theory on the Go scheduler (2022)
• Go CPU Utilization - Attempt at measuring the CPU utilization of a Go program.
• Faster Go code by being mindful of memory (2022) (Lobsters)
• Hacking Go's Runtime with Generics (2022) (HN)
• Guide to Go profiling, tracing and observability
• Domain-Driven Design with Go (2022) (Code)
• Go is modern PHP (2022)
• Go SSA Playground - Tool for exploring Go's SSA intermediate representation. (Code)
• Go Proposals
• Event-Driven Architecture in Go (2022) (Code)
• Concurrency is not Parallelism by Rob Pike
• Yoda - Get a summary of Go files to programmatically query them.
• Go disables Nagle's Algorithm by default (2022) (Lobsters) (HN)
• Go is Almost Perfect (Reddit) (Reddit)
• Pre Commit Go hooks
• GopherCon 2022: Zach Musgrave - Performance in a High-throughput SQL Database
• teler-waf - Comprehensive security solution for Go-based web applications.
• Awesome Go with stars
• taint - Static taint analysis for Go programs.
• Go 1.20 Release Notes
• A simple problem that isn’t (2023)
• Go proposal: sum types based on general interfaces
• Transform JSON to Go type
• What’s New in Go 1.20, Part I: Language Changes (2023)
• implement "find definition" in 77 lines of go (2023)
• Basic observations of Generics in Go (2022)
• Mage - Make/rake-like build tool using Go. (Code) (Awesome)
• gokrazy: instance-centric configuration released (2023)
• Atomic operations composition in Go (2023)
• Weaver - Trace Go program execution with uprobes and eBPF.
• traceutils - Code for decoding and encoding runtime/trace files as well as useful functionality implemented on top.
• gocheckcompilerdirectives - Check that go directories (//go: comments) are good.
• Parsing in Go Examples for Talk
• Go Random Chat - Modern real-time random chat with high performance and linear scalability, written in go.
• Asobiba - Go playground in WebAssembly. (Code)
• Reducing Go execution tracer overhead with frame pointer unwinding (2023) (HN)
• Go 1.20 released (2023) (HN)
• Go 1.20 Experiment: Memory Arenas vs Traditional Memory Management (2023)
• Polymorphic, Recursive Interfaces Using Go Generics (2023)
• Go arm64 Function Call Assembly (2023)
• User or *User - Do We Need Struct Pointers Everywhere? (2023) (Reddit)
• Profile-guided optimization preview (2023)
• Profile-guided optimization in Go 1.21 (2023)
• Go Programming Blueprints - Second Edition (Review)
• All your comparable types (2023)
• What was your greatest struggle when learning Go? (2023)
• Profile-guided optimization (2023)
• Go Performance Tools Cheat Sheet (2021)
• Advanced Testing with Go by Mitchell Hashimoto (2016)
• Best practices writing Go (2023)
• ireturn - Accept Interfaces, Return Concrete Types.
• bingo - Like go get but for Go tools! CI Automating versioning of Go binaries in a nested, isolated Go modules.
• Findings from six months of running govulncheck in CI (2023) (Lobsters)
• Serialize a struct to bytes to send it through the network in Go (2022)
• Making Go telemetry opt-in is a mistake (2023) (Lobsters)
• Cross-compile Go application for major platforms with Zig and GoReleaser with CGO
• FlameScope for Go (2023)
• Code coverage for Go integration tests (2023) (HN)
• Efficiently writing binary data in Go (2023)
• Higher-order functions in Go (2023)
• Building Modern CLI Applications in Go (2023) (Code)
• ko - Build and deploy Go applications. (Docs) (Lobsters)
• gsv - Tool to view the size of a Go compiled binary.
• Go Gen Tools - Go code generator for gRPC.
• GitHub Actions and Go (2023)
• The simplicity of single-file Go deployments (HN)
• betteralign - Make your Go programs use less memory.
• Go linters configuration, the right version (2023) (Lobsters)
• What design pattern / technique made your programming in Go easier? (2023)
• The Smallest Go Binary (5KB) (2023) (Reddit)
• Type Specialization in Go (2023)
• Profiling Go Programs (2023)
• Go in depth YouTube channels?
• Write integration tests with dockertest in Go (2023)
• What are some backend-related stuff that Go isn't good at? (2023)
• revgen - Speed up go:generate by auto detecting code changes.
• Quines in Go
• go-tool-cache - Share your cache over the network.
• Go Channels explained
• Gokiburi - Automatic Test Runs for Go Projects.
• Go proposal: less error-prone loop variable scoping
• go-opentelemetry-lint - Go linter to find and automatically fix issues with OpenTelemetry spans.
• Learn Concurrent Programming With Go Book
• Clean Code & Hexagonal Architecture API in Go
• Go Class - YouTube
• How to start a Go project in 2023 (HN) (Reddit)
• How to include Git version information in Go (2023) (Lobsters)
• 50 Shades of Go: Traps, Gotchas, and Common Mistakes for New Go Devs
• Finding The Best Go Project Structure (2023)
• How to Rewrite a Service - Michal Bock (2023)
• Go on GPU (2023)
• Goxygen - Generate a modern Web project with Go.
• Go’s best-kept secret: ‘executable examples’ (HN)
• Generate "if err != nil {" block
• Go memory arenas guide (Reddit)
• Go, don't collect my garbage (2017) (HN)
• Go interview prep
• Initializing Large Static Maps in Go (2023)
• Go: Execution tracer overhaul (HN)
• roumon - Universal goroutine monitor using pprof and termui.
• Bit Hacking (with Go code) (2023) (HN)
• Go Concurrency Patterns
• Gopher Wrangling: Effective error handling in Go (2023) (HN)
• Go 1.21 (2023) (HN)
• teststat - Stats for go test -json result.
• 5 Ways to Write a Go Database Model (2023) (Reddit)
• Coroutines for Go (2023) (HN) (Lobsters)
• Analyzing Go Build Times (2023)
• Ten years of “Go: The good, the bad, and the meh” (HN)
• WebAssembly and Go: A Guide to Getting Started (2023)
• Threads and Goroutines (2023) (HN)
• Go Concurrency: Fan-out, Fan-in (2023) (Lobsters)
• Go iterator experiment
• Go-stly Access Rights (2023) (Lobsters)
• Common pitfalls in Go benchmarking (2023)
• Go 1.22 Inlining Overhaul (2023) (HN)
• Scripting with Go: a 400-line Git client that can create a repo and push itself to GitHub (2023) (Lobsters)
• What are your favorite, open source Go projects from a code quality perspective (2023)
• nilnil - Go linter that checks that there is no simultaneous return of nil error and an invalid value.
• Experimenting with Go project templates (2023) (Lobsters)
• What’s New in Go 1.21 a Comprehensive Notes (2023)
• Things I'm excited for in Go 1.21 (2023)
• asasalint - Go linter, lint that pass any slice as any in variadic function.
• Go 1.21 Release Notes (HN) (Reddit)
• What I worked on for Go 1.21 (2023)
• golings - Rustlings but for Go this time.
• Understanding Go 1.21 generics type inference (2023)
• Learning Go Projects
• Rust vs. Go in 2023 (HN)
• Backward Compatibility, Go 1.21, and Go 2 (2023) (HN)
• Forward Compatibility and Toolchain Management in Go 1.21 (2023)
• Go Insiders Community / X
• Avoiding Pitfalls in Go (2023)
• The One Thing I'd Change About Go (2023) (Lobsters)
• NilAway - Static Analysis tool to detect potential Nil panics in Go code.
• Advanced Go Concurrency (2020) (Reddit)
• Example Cloud Run Go app with lightweight structured logging using slog
• Perfectly Reproducible, Verified Go Toolchains (2023) (HN)
• Bring your own interface (2023) (Lobsters)
• CGO Performance In Go 1.21 (2023) (Lobsters)
• Scaling gopls for the growing Go ecosystem (2023)
• Much Ado About Nil Things: More Go Pitfalls (2023) (Lobsters)