What the famous packages look like in code

1// Before: order imported store for Save, and store imported order for
2// the Order type: a cycle. After: the shared type lives in the lower
3// package, store imports nothing of ours, and order imports store.
4package store
5
6type Order struct{ ID, Total int }
7
8func Save(o Order) error { return nil }
9
10// in package order: store.Save(store.Order{Total: 500})

1mux := http.NewServeMux()
2
3mux.HandleFunc("GET /users/{id}", func(w http.ResponseWriter, r *http.Request) {
4	id := r.PathValue("id")
5	w.Header().Set("Content-Type", "application/json")
6	json.NewEncoder(w).Encode(map[string]string{"id": id})
7})
8
9// for real use, an http.Server with timeouts: see "Middleware and graceful shutdown"
10http.ListenAndServe(":8080", mux)

1r := chi.NewRouter()
2r.Use(middleware.Logger)                     // chi ships common middleware
3
4r.Route("/users", func(r chi.Router) {       // route groups
5	r.Get("/{id}", func(w http.ResponseWriter, r *http.Request) {
6		id := chi.URLParam(r, "id")
7		render.JSON(w, r, map[string]string{"id": id})
8	})
9})
10
11http.ListenAndServe(":8080", r)   // hardened version: see "Middleware and graceful shutdown"

1r := gin.Default()                           // logger + recovery included
2
3r.GET("/users/:id", func(c *gin.Context) {   // its OWN context type
4	id := c.Param("id")
5	c.JSON(http.StatusOK, gin.H{"id": id})   // gin.H is map[string]any
6})
7
8r.Run(":8080")

1e := echo.New()
2
3e.GET("/users/:id", func(c echo.Context) error {   // handlers RETURN an error
4	return c.JSON(http.StatusOK, map[string]string{"id": c.Param("id")})
5})
6
7e.Start(":8080")

1app := fiber.New()
2
3app.Get("/users/:id", func(c *fiber.Ctx) error {
4	return c.JSON(fiber.Map{"id": c.Params("id")})
5})
6
7app.Listen(":8080")

1var u User
2err := db.QueryRowContext(ctx,
3	`SELECT id, name, email FROM users WHERE id = $1`, id,
4).Scan(&u.ID, &u.Name, &u.Email)
5
6if errors.Is(err, sql.ErrNoRows) {
7	return nil, ErrNotFound
8}

1var u User      // struct tags: `db:"email"`
2
3err := db.GetContext(ctx, &u,
4	`SELECT id, name, email FROM users WHERE id = $1`, id)
5
6var users []User
7err = db.SelectContext(ctx, &users, `SELECT id, name FROM users LIMIT $1`, 20)

1-- query.sql
2-- name: GetUser :one
3SELECT id, name, email FROM users WHERE id = $1;
4
5// then run: sqlc generate
6// and call the generated, fully typed method:
7u, err := q.GetUser(ctx, id)     // returns (User, error) — no reflection, no tags

1var u User
2db.First(&u, id)                                  // SELECT ... WHERE id = ? LIMIT 1
3
4db.Where("age > ?", 18).Order("name").Find(&users)
5
6db.Model(&u).Update("name", "new")
7
8// associations, hooks and auto-migration come with it:
9db.AutoMigrate(&User{}, &Order{})
10db.Preload("Orders").Find(&users)                 // loads the related rows

1got, err := Add(2, 3)
2if err != nil {
3	t.Fatalf("unexpected error: %v", err)
4}
5if got != 5 {
6	t.Errorf("Add(2, 3) = %d, want 5", got)
7}

1require.NoError(t, err)              // require: stops the test on failure
2assert.Equal(t, 5, got)             // assert:  records it and carries on
3
4assert.Len(t, users, 3)
5assert.Contains(t, body, "not found")
6assert.ErrorIs(t, err, ErrNotFound)

1var rootCmd = &cobra.Command{
2	Use:   "app",
3	Short: "does the thing",
4}
5
6var serveCmd = &cobra.Command{
7	Use:   "serve",
8	Short: "start the HTTP server",
9	RunE: func(cmd *cobra.Command, args []string) error {
10		port, _ := cmd.Flags().GetString("port")
11		return run(port)
12	},
13}
14
15func init() {
16	serveCmd.Flags().String("port", "8080", "port to listen on")
17	rootCmd.AddCommand(serveCmd)     // app serve --port 9000
18}

1// log/slog — standard library, Go 1.21+
2slog.Info("request completed",
3	"method", r.Method, "path", r.URL.Path, "status", 200, "ms", 14)
4
5// zap — faster, more ceremony, typed fields
6logger.Info("request completed",
7	zap.String("method", r.Method),
8	zap.String("path", r.URL.Path),
9	zap.Int("status", 200),
10	zap.Int("ms", 14))