🐼 Learning Go 🤓

The Golang programming language is very similar to the C programming language, and its purpose is to reduce complexity in program development. This language is widely used to implement web servers, applications, and container management tools. Among the tools that have been developed with this language are:

• Kubernetes
• Docker
• NATS
• Prometheus

In the last few years, this language has opened its place in Iranian companies, and it is used for the development of backend services.

• History
• Variables and constants
• Calculation
• Conditions
• Loops
• Functions
• Strings
• Arrays and slices
• map
• struct
• interface
• Pointers
• Errors (including the generic errors.AsType[E] from Go 1.26)
• Concurrency and channels (sync.WaitGroup.Go, sync.OnceValue)
• select
• Generics (including self-referential type parameters from Go 1.26)
• go mod and using packages
• An overview of advanced features
• Introduction to HTTP protocol
• HTTP server implementation with net/http's pattern-based routing and structured logging via log/slog (slog.NewMultiHandler)
• Graceful shutdown with signal.NotifyContext cancel causes
• Settings management
• Metric, Log and Tracing
• Connection with the database using PostgreSQL and GORM
• Introduction to Docker and containerization

At the beginning of the course, an introduction to the Go language is made and students implement simple programs with it. Since the implementation of web servers is one of the important uses of the Go programming language, we will review the structure of the HTTP protocol and then implement a simple web server in Go. In this implementation, we try to familiarize ourselves with the structure of large programs created in Go and review details such as Configuration or Metrics, which are of great value in real systems. Finally, a MongoDB and PostgreSQL databases are added to this web server, the purpose of which is to familiarize students with database interfaces in the Go.

Using Go for design and implementing servers contains two major steps. First is about learning Go itself, and the second is writing an HTTP server. For the second step we stay on the standard library: this module has no external dependencies at all, and httpserver/ is built on net/http with the pattern-based routing added in Go 1.22. Learn that first — when you later reach for a framework, you will know exactly what it is doing for you. Reviewing these source codes are useful for learning Go but there aren't enough.

0. Hello World
1. Constants and Variables
2. Calculation
3. Conditions
4. Loops
5. Strings
6. Arrays
7. Slices
8. Arrays and Slices
9. Maps
10. Structs
11. Interfaces
12. Pointers
13. Structs with Pointers
14. strconv
15. Function with multiple-return
16. Errors
17. Concurrency
18. Function Type
19. Channels
20. Pipelines
21. Select
22. JSON
23. go.mod
24. Packages
25. defer
26. variadic
27. regex
28. sync.Once / sync.OnceValue
29. panic
30. UTF-8
31. The nil interface trap
32. Type aliases vs. type definitions
33. Self-referential generics (Go 1.26)

This repository has been refreshed to use Go 1.26 language and library features. The most notable ones — and where to find a runnable example for each — are:

The repository also benefits from earlier-but-still-modern features that are worth highlighting in class:

• sync.WaitGroup.Go(func) instead of Add / go / defer Done (see 17-concurrency/main.go and 20-pipeline/main.go)
• sync.OnceValue instead of sync.Once + sentinel field (see 28-once/main.go)
• for range N instead of the C-style for i := 0; i < N; i++ (see 09-map, 19-channels-1, 20-pipeline, 23-sharding)
• math/rand/v2 (see 21-select/main.go)
• net/http pattern-based routing — mux.HandleFunc("GET /hello/{username}", …) (see httpserver/main.go)
• mime.ParseMediaType for tolerant Content-Type checks (see httpserver/handler/hello.go)

Go 1.26 ships a much expanded go fix with a suite of modernizer analyzers that automatically rewrite older idioms (interface{} → any, for i := 0; i < n; i++ → for range n, WaitGroup.Add/Done → WaitGroup.Go, and many more). To run all of them across this module:

just modernize
# or, equivalently:
go fix ./...

Every directory is a runnable program. Run one with just run <directory>, for example just run 05-strings.

just              # list every recipe
just run 09-map   # run a single example
just check        # everything the ci runs: gofmt, vet, build, test
just modernize    # apply the go 1.26 modernizer fixers

You can visit Go101 which contains some more advance concepts of Golang.

One of the main steps in learning new language and its best practices is reviewing written projects:

• https://github.com/1995parham/koochooloo:

  • In the first step, you need to review the project structure and find out how modules are related
  • Then we continue with running the docker-compose to have the requirements
  • And in the final step, we lunch the application and trying it with curl based on its swagger
  • This project use zap as a logger and pass it into its modules also each module has its metrics based on otel.

• https://github.com/1995parham/fandogh:

  • This example containing the migration and how we store things on the MongoDB database.

• https://github.com/1995parham/saf:

  • This example shows tracing in action with NATS as a message queue.
  • Also, We can use profiler to see how replacing Echo with GoFiber increase the performance.
  • This project has Helm chart and after knowing Kubernetes basis we can lunch it on the cloud with its Helm.

• https://github.com/1995parham-teaching/k1s:

  • In the first step, we review the server structure. The server is stateless and only returns simple responses.
  • We it on the cloud with its manifests
  • using server and ingress to send requests and see how they distributed between instances
  • We also see how we can mount configuration on Kubernetes with configmap.