Go Notes

Huge Golang Guide

Useful Repos

1. golangci-lint

2. golangci-lint-config-examples

3. gci

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

4. gofumpt

5. mingo

Stack Overflow || Reddit

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.

Good Articles

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

Bites from the Golang Manual (aka. RTFM)

1. nil_error behaviors

2. Constants

3. Go 1.23 timer changes

4. Go subtests

5. Go slice tricks

Good Videos

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

Good Books

1. 100 Go Mistakes and How to Avoid Them

Notes

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

Others

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

GraphQL

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

Fuck Yaml Specifically

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