Huge Golang Guide

1. golangci-lint

2. golangci-lint-config-examples

3. gci

    gci write --skip-generated -s standard -s default -s localmodule .
   

4. automemlimit

5. gofumpt

6. mingo

1. What does the . in a Go import statement do

   • Allows functions inside the package to be called directly, but is not recommended

2. When should you use errors.As and when to use errors.Is for your own custom errors

   • errors.Is for var errors, errors.As for struct errors that has to be initialized (especially if it has custom fields)

3. When to use Golang's default MUX versus doing your own

4. Should I use ServeMux or http directly in golang

5. When to use and not to use generics

6. How to test a unexported (private) function in go (golang)?, the article

7. How to add new methods to an existing type in Go?

8. Go constants beyond basics

9. Why to not choose Ginkgo

10. Return zero value for generic types

11. Truncating a string in templates

12. Slices behavior

13. When and why to use functional options pattern. 1 2:

    • Default values should be useful, using a struct the default values is implicitly communicated in the struct, and its better to give useful default values. Using functional options it is implicitly done in the NewXXX functions. (In other words when it is hard to distinguish default values from a valid setting)
    • Functional options can return errors
    • Functional options allow setting a combination of values like WithAws, WithAzure etc. Users can also create their own useful combinations.

14. Should you return nil or empty slice

15. Why append a nil slice is OK, while assign a nil map isn't OK?

16. Why recover() can only be used in a defer function and not directly

    • a.k.a. defer recover() doesnt work but defer func() {recover()} does
    • extra

17. Breaking out of a select statement when all channels are closed

1. init() in Go Programming

2. Go best practices, six years in

3. How I write HTTP services in Go after 13 years

4. Channel Axioms

5. Proper HTTP Shutdown in Go

6. Golang Trick: Export unexport method for test

7. Mastering Go Structs: 7 Advanced Techniques for Efficient Code

8. Understanding Go's UTF-8 Support

9. Google style guide assertion libraries

10. Understanding Singleflight in Go

11. Go Singleflight panic and GoExit behaviours

12. Go interface guards, for when there are no static conversions in code

13. Function types and single-method interfaces

    • You can use function types to mock stuff, wow

14. Limiting amount of parallel goroutines with buffered channels

15. Type assertion vs type switches

    • Apparently you can use a variable in a type switch case

16. Golang slices behaviour

17. Issues with comparing pointers of zero sized type

    • Language spec states that equality of pointers to distinct zero size variables is unspecified

18. Channel Closing

    • Don't close a channel from the receiver side
    • Don't close a channel if the channel has multiple concurrent senders

19. Golang benchmarking

20. There is no memory safety without thread safety

    • data_race_issue.go
    • Go stores values of interface types like Thing as pairs of a pointer to the data and a pointer to the vtable. Every time repeat_swap stores a new value in globalVar, it just does two separate stores to update those two pointers. In repeat_get, there’s thus a small chance that when we read globalVar in between those two stores, we get a mix of a pointer to an Int with the vtable for a Ptr. When that happens, we will run the Ptr version of get, which will dereference the Int’s val field as a pointer – and hence the program accesses address 42, and crashes.
    • Can be solved by mutex

21. Go's data race detector blind spot

22. Calculating multiple file hashes in a single pass

23. Reading multiple times from an io reader

24. Gin is a very bad software library

1. nil_error behaviors

2. Constants

3. Go 1.23 timer changes

4. Go subtests

5. Go slice tricks

6. Go Concurrency Patterns: Pipelines and cancellation

7. A Guide to the Go Garbage Collector

1. Go concurrency patterns

2. 7 Deadly Mistakes Beginner Go Developers Make (and how to fix them)

   • You can label loops apparently
   • map, slice, values in an interface are not addressable
   • Pointer receivers can only accept pointers, while value receivers can accept both values and pointers

3. Golang struct configuration pattern

   • Use a struct to pass optional values
   • Allow the constructing function to take a list of functions that can modify the options to allow for extensibility

4. GopherCon 2016: Francesc Campoy - Understanding nil

   • 16:30
   • Use nil to disable channels
   • Nil is valid as a read only empty map

5. The standard library now has all you need for advanced routing in Go

6. GothamGo 2018 - Things in Go I Never Use by Mat Ryer

   • Lazy initialization (20:54)
     • sync.Once: Guarantees thing inside code block will be called exactly once
   • You can pass {the struct you want to work on} to {a method called on the struct using dot, ex. Struct.method(actualObject)}, don't do this but its interesting (22:20)

7. Golang UK Conference 2016 - Dave Cheney - SOLID Go Design

   • Single Responsibility Principle
     • Structure functions and types into packages that exhibit natural cohesion
     • Avoid shared, utils, which causes the packages to have multiple responsibilities
   • Open / Closed Principle
     • Open for extension, closed for modification
     • Use embedding rather than inheritanca
   • Liskov Substitution Principle
     • Implicit interfaces, use small interfaces and express the dependencies between packages as interfaces
     • Require no more, promise no less
   • Interface Segregation Principle
     • Clients should not be forced to depend on methods they don't use
     • Ex. A Save function should only need a Writer, instead of Read or File, or even Close, therefore it can work with network writer, file writers etc
   • Dependency Inversion Principle
     • High level modules should not depend on low level modules, both should depend on abstractions
     • Abstractions should not depend on details. Details should depend on abstractions
     • Import graph should be acyclic, push responsibility as high as possible in the import tree

8. Golang UK Conference 2016 - Mat Ryer - Idiomatic Go Tricks

   • 9:16: defer log.Println("------") even if exits abnormally this code will print
   • defer can also be used for teardown functions for any setup / timers that need to stop at end of the line
   • 21:18: Retry code
   • 22:10: Empty structs to group methods methods don't capture the receiver, so the variable need not expose the private type
   • 23:40: Semaphore code, limit hom many stuff is executed at once

9. How To Build A Chat And Data Feed With WebSockets In Golang?

10. Go Proverbs with Rob Pike

1. 100 Go Mistakes and How to Avoid Them

   • Screenshots

2. 50 Shades of Go

1. runtime.NumCPU
2. runtime.GOMAXPROCS()

1. Introduction to gRPC

2. What is the difference between grpc and websocket?

3. Will WebSocket survive HTTP/2

4. gRPC vs WebSockets

5. Docker stop containers

6. Docker distroless Docker exec failed: No such file or directory when CGO is enabled

7. Golang's null safety proposal discussion

8. Postgres don't do this

9. Stop using JWT for sessions

10. JWT vs Cookies for token based auth, also useful

11. When to use grpc, graphql, rest or trpc

12. Why your backend shouldn't serve files

13. Conventional commit messages

14. The Thundering Herd Problem

15. Retries

    • this is really really really fuckin good

16. Visualizing garbage collection allocations

1. Fragment, minimizes token usage as well

2. Aliases

3. Meta-fields, ex. __typename

4. Default variables

5. Interface types

6. Inline fragments

   • It allows to show different fields depending on what the runtime type for the interface is

7. Union types, because why not

8. Input object types

   • Use objects for input

9. GraphQL check complexity

10. Apparently GraphQL does type coercion in its specs

11. GraphQL federation

12. Federated architecture

13. Dataloader

1. noyaml website

   • this is good

2. Yaml: Probably not so great after all

3. Valueable lessons in over engineering

4. Yaml test matrix

5. Yaml strips out underscore

6. Yaml anchors