Go for Grit Developers

package main

import "fmt"

func main() {
    fmt.Println("Hello, Grit!")
}

package main

// One import here; several are grouped in parentheses.
import "fmt"

/*
   A block comment. Handy for a paragraph, though most
   Go code uses // for everything.
*/

func main() {
    // Print writes exactly what you give it: no spaces, no newline
    fmt.Print("Starting")
    fmt.Print("...")
    fmt.Println("ready")

    // Println puts a space between arguments and ends the line
    fmt.Println("Grit", "API", 2026)

    // Strings are joined with +
    fmt.Println("Hello, " + "Grit" + "!")

    // A raw string literal keeps line breaks exactly as typed
    fmt.Println(`usage:
  go run .`)
}

package main

import "fmt"

const AppName = "my-saas"

func main() {
    // Explicit declaration
    var name string = "Grit"
    var port int = 8080

    // Short assignment (type inferred)
    host := "localhost"
    debug := true
    price := 29.99

    // Multiple assignment
    width, height := 1920, 1080

    fmt.Println(name, host, port, debug, price, width, height)
    fmt.Println("App:", AppName)
}

package main

import (
    "fmt"
    "strconv"
)

func main() {
    // Zero values — declared but not assigned
    var count int    // 0
    var name string  // "" (empty, not nil)
    var active bool  // false
    var user *string // nil
    fmt.Printf("%d %q %t %v
", count, name, active, user)

    // Numeric conversion is always explicit
    total := 10   // int
    price := 2.5  // float64
    // fmt.Println(total * price)        // compile error: mismatched types
    fmt.Println(float64(total) * price)  // 25

    // Integer division truncates — convert BEFORE dividing
    fmt.Println(7 / 2)                   // 3
    fmt.Println(float64(7) / float64(2)) // 3.5

    // Strings are not numbers: strconv returns a value AND an error
    port, err := strconv.Atoi("8080")
    if err != nil {
        fmt.Println("bad port:", err)
        return
    }
    fmt.Println("port + 1 =", port+1)

    // The other direction
    fmt.Println("as string: " + strconv.Itoa(port))
    fmt.Println("as float:  " + strconv.FormatFloat(price, 'f', 2, 64))

    // Something that is not a number gives you an error, not a panic
    if _, err := strconv.Atoi("not-a-port"); err != nil {
        fmt.Println("expected failure:", err)
    }
}

package main

import "fmt"

func main() {
    // if — no parentheses, braces always required
    port := 8080
    if port < 1024 {
        fmt.Println("privileged port")
    } else if port > 49151 {
        fmt.Println("ephemeral port")
    } else {
        fmt.Println("user port")
    }

    // for — the classic three-part form
    for i := 1; i <= 3; i++ {
        fmt.Println("attempt", i)
    }

    // for as a while loop: one condition, nothing else
    n := 1
    for n < 10 {
        n *= 2
    }
    fmt.Println("n:", n)

    // switch on a value
    env := "staging"
    switch env {
    case "production":
        fmt.Println("be careful")
    case "staging", "qa":
        fmt.Println("safe to experiment")
    default:
        fmt.Println("unknown environment")
    }

    // switch with no value tests conditions instead — often clearer
    // than a chain of else-ifs
    status := 404
    switch {
    case status >= 500:
        fmt.Println("server error")
    case status >= 400:
        fmt.Println("client error")
    default:
        fmt.Println("ok")
    }
}

package main

import "fmt"

func main() {
    // continue skips the rest of this iteration
    for i := 1; i <= 6; i++ {
        if i%2 != 0 {
            continue // odd numbers are skipped
        }
        fmt.Print(i, " ")
    }
    fmt.Println()

    // break leaves the loop
    total := 0
    for i := 1; ; i++ { // no condition: loops until something breaks it
        total += i
        if total > 20 {
            fmt.Println("stopped at i =", i, "total =", total)
            break
        }
    }

    // A short statement inside if: remainder exists only in these branches
    if remainder := 17 % 5; remainder == 0 {
        fmt.Println("divides evenly")
    } else {
        fmt.Println("remainder is", remainder)
    }

    // Nested loops, and a label to break out of both at once
outer:
    for row := 1; row <= 3; row++ {
        for col := 1; col <= 3; col++ {
            if row*col > 4 {
                fmt.Println("stopping at", row, col)
                break outer
            }
            fmt.Print(row*col, " ")
        }
    }
    fmt.Println()
}

package main

import (
    "errors"
    "fmt"
)

// Functions return (result, error)
func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("cannot divide by zero")
    }
    return a / b, nil
}

func calculateDiscount(price, percent float64) (float64, error) {
    result, err := divide(price * percent, 100)
    if err != nil {
        // Wrap the error with context
        return 0, fmt.Errorf("calculating discount: %w", err)
    }
    return result, nil
}

func main() {
    discount, err := calculateDiscount(100.0, 20.0)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println("Discount:", discount) // 20.0
}

package main

import (
    "errors"
    "fmt"
)

// Sentinels: single values, compared by identity rather than by message
var (
    ErrNotFound  = errors.New("record not found")
    ErrForbidden = errors.New("not allowed")
)

func findUser(id int) error {
    if id != 1 {
        // Wrapped, so the caller still finds ErrNotFound underneath
        return fmt.Errorf("findUser %d: %w", id, ErrNotFound)
    }
    return nil
}

func deletePost(role string) error {
    if role != "ADMIN" {
        return fmt.Errorf("deletePost as %s: %w", role, ErrForbidden)
    }
    return nil
}

func main() {
    // errors.Is matches through the wrapping, however deep it goes
    err := findUser(99)
    fmt.Println("error:", err)
    if errors.Is(err, ErrNotFound) {
        fmt.Println("-> respond 404")
    }

    err = deletePost("USER")
    fmt.Println("error:", err)
    if errors.Is(err, ErrForbidden) {
        fmt.Println("-> respond 403")
    }

    // One sentinel never matches another
    fmt.Println("forbidden is not-found?", errors.Is(err, ErrNotFound))

    // The happy path
    fmt.Println("as admin:", deletePost("ADMIN"))
}

package models

import (
    "time"
    "gorm.io/gorm"
)

type User struct {
    ID        uint           `gorm:"primarykey" json:"id"`
    Name      string         `gorm:"size:255;not null" json:"name" binding:"required"`
    Email     string         `gorm:"size:255;uniqueIndex;not null" json:"email" binding:"required,email"`
    Password  string         `gorm:"size:255;not null" json:"-"`
    Role      string         `gorm:"size:20;default:USER" json:"role"`
    Active    bool           `gorm:"default:true" json:"active"`
    CreatedAt time.Time      `json:"created_at"`
    UpdatedAt time.Time      `json:"updated_at"`
    DeletedAt gorm.DeletedAt `gorm:"index" json:"-"`
}

package main

import (
    "encoding/json"
    "fmt"
)

// Embedded into every model — the common fields, declared once
type Base struct {
    ID        uint   `json:"id"`
    CreatedAt string `json:"created_at"`
}

type User struct {
    Base            // embedded: User gets ID and CreatedAt for free
    Name     string `json:"name"`
    Email    string `json:"email"`
    Password string `json:"-"`                    // never serialised
    Nickname string `json:"nickname,omitempty"`   // dropped when empty
}

func main() {
    u := User{
        Base:     Base{ID: 1, CreatedAt: "2026-01-15"},
        Name:     "Ada Lovelace",
        Email:    "ada@example.com",
        Password: "super-secret",
    }

    // Promoted fields are read as if they were declared on User itself
    fmt.Println("id:", u.ID, "created:", u.CreatedAt)

    out, _ := json.MarshalIndent(u, "", "  ")
    fmt.Println(string(out))
    // No "password" key, and no "nickname" because it is empty
}

package main

import "fmt"

func main() {
    // Slices
    names := []string{"Alice", "Bob", "Charlie"}
    names = append(names, "Diana")

    for i, name := range names {
        fmt.Printf("%d: %s\n", i, name)
    }

    // Maps — every value has the same type here; mixed-type maps need
    // "any", which arrives with interfaces
    user := map[string]string{
        "name":  "Alice",
        "email": "alice@example.com",
    }

    for key, value := range user {
        fmt.Printf("%s = %v\n", key, value)
    }

    // Access a single value
    fmt.Println("Name:", user["name"])
}

package main

import (
    "fmt"
    "sort"
)

func main() {
    // len is what is there; cap is how much room before a reallocation
    s := make([]int, 0, 4)
    fmt.Println(len(s), cap(s)) // 0 4

    // Sub-slicing shares the SAME underlying array
    nums := []int{1, 2, 3, 4, 5}
    view := nums[1:3] // [2 3]
    view[0] = 99
    fmt.Println(nums) // [1 99 3 4 5] — nums changed too

    // copy() when you want an independent slice
    safe := make([]int, len(view))
    copy(safe, view)
    safe[0] = 0
    fmt.Println(view, safe) // [99 3] [0 3] — separate now

    // Comma-ok tells "missing" apart from "present but zero"
    stock := map[string]int{"apples": 0}
    n, ok := stock["apples"]
    fmt.Println(n, ok) // 0 true  — present, and genuinely zero
    n, ok = stock["pears"]
    fmt.Println(n, ok) // 0 false — absent

    delete(stock, "apples")
    fmt.Println("size:", len(stock))

    // Map iteration order is random — sort the keys for stable output
    scores := map[string]int{"carol": 9, "alice": 7, "bob": 8}
    keys := make([]string, 0, len(scores))
    for k := range scores {
        keys = append(keys, k)
    }
    sort.Strings(keys)
    for _, k := range keys {
        fmt.Printf("%s=%d ", k, scores[k])
    }
    fmt.Println()
}

package main

import "fmt"

func doubleValue(n int) {
    n = n * 2 // Modifies the COPY, not the original
}

func doublePointer(n *int) {
    *n = *n * 2 // Modifies the ORIGINAL via pointer
}

func main() {
    x := 10

    doubleValue(x)
    fmt.Println(x) // Still 10 — the copy was doubled

    doublePointer(&x)
    fmt.Println(x) // Now 20 — modified through pointer

    // Nil pointer: indicates "no value"
    var name *string = nil
    if name == nil {
        fmt.Println("Name is not set")
    }
}

package main

import "fmt"

type Product struct {
    Name  string
    Price float64
}

// Takes a copy: this discount goes nowhere
func discountBroken(p Product, pct float64) {
    p.Price = p.Price * (1 - pct/100)
}

// Takes a pointer: changes the original
func discount(p *Product, pct float64) {
    p.Price = p.Price * (1 - pct/100)
}

func main() {
    items := []Product{
        {Name: "Laptop", Price: 1000},
        {Name: "Mouse", Price: 50},
    }

    // WRONG: item is a copy of the element
    for _, item := range items {
        item.Price = 0
    }
    fmt.Println("after range-copy:", items) // unchanged

    // RIGHT: address the element through its index
    for i := range items {
        discount(&items[i], 10)
    }
    fmt.Println("after discount:  ", items)

    // Passing a copy silently does nothing
    discountBroken(items[0], 50)
    fmt.Println("after broken:    ", items)

    // Pointers also let you say "no value" — but check before dereferencing
    var missing *Product
    fmt.Println("missing == nil?", missing == nil)
    if missing != nil {
        fmt.Println(missing.Name) // would panic if reached with nil
    }

    // A pointer into the slice: one element, shared
    first := &items[0]
    first.Price = 1.23
    fmt.Println("via pointer:     ", items)
}

package main

import "fmt"

type User struct {
    FirstName string
    LastName  string
    Email     string
}

// A regular function — takes User as an argument
func getFullName(u User) string {
    return u.FirstName + " " + u.LastName
}

// A method — attached to User with a value receiver
// Use value receiver when you only READ the struct
func (u User) FullName() string {
    return u.FirstName + " " + u.LastName
}

// A method with a pointer receiver
// Use pointer receiver when you MODIFY the struct
func (u *User) SetEmail(email string) {
    u.Email = email // Modifies the original, not a copy
}

func main() {
    user := User{FirstName: "John", LastName: "Doe"}

    // Calling a function — pass the struct as argument
    fmt.Println(getFullName(user)) // "John Doe"

    // Calling a method — use dot notation on the struct
    fmt.Println(user.FullName()) // "John Doe"

    // Pointer receiver method modifies the original
    user.SetEmail("john@example.com")
    fmt.Println(user.Email) // "john@example.com"
}

package main

import (
    "fmt"
    "strings"
)

// A named type built on string — now it can carry behaviour
type Role string

const (
    RoleAdmin  Role = "ADMIN"
    RoleEditor Role = "EDITOR"
    RoleUser   Role = "USER"
)

// Methods on a named string type
func (r Role) CanPublish() bool {
    return r == RoleAdmin || r == RoleEditor
}

func (r Role) Label() string {
    lower := strings.ToLower(string(r))
    return strings.ToUpper(lower[:1]) + lower[1:]
}

// A named slice type, with a method that reads it
type Cart []float64

func (c Cart) Total() float64 {
    sum := 0.0
    for _, price := range c {
        sum += price
    }
    return sum
}

// Pointer receiver, because this one replaces the slice
func (c *Cart) Add(price float64) {
    *c = append(*c, price)
}

type Money struct {
    Cents int
}

// String() satisfies fmt.Stringer — fmt calls it for you
func (m Money) String() string {
    return fmt.Sprintf("$%d.%02d", m.Cents/100, m.Cents%100)
}

func main() {
    fmt.Println(RoleEditor.CanPublish(), RoleUser.CanPublish()) // true false
    fmt.Println(RoleAdmin.Label())                              // Admin

    cart := Cart{19.99, 5.00}
    cart.Add(3.50)
    fmt.Printf("%d items, total %.2f\n", len(cart), cart.Total())

    // No .String() call anywhere — fmt finds it
    fmt.Println("price:", Money{Cents: 2599})
}

package main

import "fmt"

// ---- THE JOB POSTING (Interface) ----
// This is like a job ad that says:
// "We need someone who can Drive() and Refuel()"
type TruckDriver interface {
    Drive() string
    Refuel() string
}

// ---- CANDIDATE 1: John (Struct) ----
// John never said "I am a TruckDriver"
// He just happens to know how to Drive() and Refuel()
type John struct {
    Name string
    Age  int
}

func (j John) Drive() string {
    return j.Name + " is driving the truck!"
}

func (j John) Refuel() string {
    return j.Name + " is refueling the truck!"
}

// ---- CANDIDATE 2: Robot (Struct) ----
// Robot also never said "I am a TruckDriver"
// But it also knows how to Drive() and Refuel()
type Robot struct {
    Model string
}

func (r Robot) Drive() string {
    return "Robot " + r.Model + " is driving the truck!"
}

func (r Robot) Refuel() string {
    return "Robot " + r.Model + " is refueling the truck!"
}

// ---- THE COMPANY (Function that accepts the interface) ----
// The company doesn't care WHO you are.
// It only cares: "Can you Drive() and Refuel()?"
func HireDriver(d TruckDriver) {
    fmt.Println("Hired!")
    fmt.Println("  ", d.Drive())
    fmt.Println("  ", d.Refuel())
    fmt.Println()
}

func main() {
    // John applies — he can Drive() and Refuel() -> HIRED
    john := John{Name: "John", Age: 35}
    fmt.Println("John applies for the job:")
    HireDriver(john)

    // Robot applies — it can Drive() and Refuel() -> HIRED
    robot := Robot{Model: "TX-500"}
    fmt.Println("Robot applies for the job:")
    HireDriver(robot)
}

package main

import "fmt"

// Notifier — any type that can send a notification
type Notifier interface {
    Send(to string, message string) error
}

// EmailNotifier implements Notifier (implicitly)
type EmailNotifier struct {
    From string
}

func (e *EmailNotifier) Send(to string, message string) error {
    fmt.Printf("Email from %s to %s: %s\n", e.From, to, message)
    return nil
}

// SlackNotifier also implements Notifier
type SlackNotifier struct {
    Channel string
}

func (s *SlackNotifier) Send(to string, message string) error {
    fmt.Printf("Slack #%s -> %s: %s\n", s.Channel, to, message)
    return nil
}

// Works with ANY Notifier — email, slack, SMS, webhook...
func alert(n Notifier, user string) {
    n.Send(user, "Your report is ready")
}

func main() {
    email := &EmailNotifier{From: "noreply@app.com"}
    slack := &SlackNotifier{Channel: "alerts"}

    alert(email, "alice@example.com") // Email from noreply@app.com to alice@example.com: Your report is ready
    alert(slack, "alice")             // Slack #alerts -> alice: Your report is ready
}

package main

import (
    "bytes"
    "fmt"
    "io"
    "os"
)

// SaveData works with ANY io.Writer — files, buffers, HTTP responses, etc.
func SaveData(w io.Writer, data []byte) error {
    _, err := w.Write(data)
    return err
}

func main() {
    data := []byte("Hello, Grit!")

    // Write to a file
    file, _ := os.Create("output.txt")
    SaveData(file, data)
    file.Close()

    // Write to an in-memory buffer (same function!)
    var buf bytes.Buffer
    SaveData(&buf, data)
    fmt.Println(buf.String()) // Hello, Grit!

    // Write to stdout (same function!)
    SaveData(os.Stdout, data) // Hello, Grit!
}

package main

import "fmt"

func printAnything(v any) {
    fmt.Printf("Value: %v (type: %T)\n", v, v)
}

func main() {
    printAnything(42)          // Value: 42 (type: int)
    printAnything("hello")     // Value: hello (type: string)
    printAnything(true)        // Value: true (type: bool)
    printAnything(3.14)        // Value: 3.14 (type: float64)

    // Common in JSON-like data structures
    person := map[string]any{
        "name":  "Alice",
        "age":   30,
        "admin": true,
    }
    fmt.Println(person) // map[admin:true age:30 name:Alice]
}

package main

import "fmt"

func describe(v any) {
    // Two-return form — safe, won't panic
    if str, ok := v.(string); ok {
        fmt.Printf("String of length %d: %q\n", len(str), str)
        return
    }

    if num, ok := v.(int); ok {
        fmt.Printf("Integer: %d (doubled: %d)\n", num, num*2)
        return
    }

    fmt.Printf("Unknown type: %T\n", v)
}

func main() {
    describe("hello")  // String of length 5: "hello"
    describe(42)        // Integer: 42 (doubled: 84)
    describe(true)      // Unknown type: bool

    // DANGER: single-return form panics on mismatch!
    // s := someValue.(string) // panics if someValue isn't a string
}

package main

import "fmt"

func process(v any) string {
    switch val := v.(type) {
    case string:
        return fmt.Sprintf("string: %q", val)
    case int:
        return fmt.Sprintf("int: %d", val)
    case bool:
        if val {
            return "bool: yes"
        }
        return "bool: no"
    case []string:
        return fmt.Sprintf("string slice with %d items", len(val))
    default:
        return fmt.Sprintf("unhandled type: %T", val)
    }
}

func main() {
    fmt.Println(process("Go"))              // string: "Go"
    fmt.Println(process(2024))              // int: 2024
    fmt.Println(process(true))              // bool: yes
    fmt.Println(process([]string{"a","b"})) // string slice with 2 items
    fmt.Println(process(3.14))              // unhandled type: float64
}

package main

import "fmt"

// Implementing fmt.Stringer — controls how your type prints
type User struct {
    Name string
    Role string
}

func (u User) String() string {
    return fmt.Sprintf("%s (%s)", u.Name, u.Role)
}

// Implementing the error interface — custom error types
type ValidationError struct {
    Field   string
    Message string
}

func (e *ValidationError) Error() string {
    return fmt.Sprintf("validation failed on %s: %s", e.Field, e.Message)
}

func validateEmail(email string) error {
    if email == "" {
        return &ValidationError{Field: "email", Message: "cannot be empty"}
    }
    return nil
}

func main() {
    user := User{Name: "Alice", Role: "ADMIN"}
    fmt.Println(user) // Alice (ADMIN) — fmt.Stringer in action

    if err := validateEmail(""); err != nil {
        fmt.Println(err) // validation failed on email: cannot be empty
    }
}

package main

import "fmt"

// Small, focused interfaces
type Reader interface {
    Read(id string) ([]byte, error)
}

type Writer interface {
    Write(id string, data []byte) error
}

type Deleter interface {
    Delete(id string) error
}

// Compose them into a full storage interface
type Storage interface {
    Reader
    Writer
    Deleter
}

// A function that only needs to read — accepts the smallest interface
func loadConfig(r Reader) ([]byte, error) {
    return r.Read("config.json")
}

// MemoryStore implements all three — so it satisfies Storage
type MemoryStore struct {
    data map[string][]byte
}

func (m *MemoryStore) Read(id string) ([]byte, error) {
    d, ok := m.data[id]
    if !ok {
        return nil, fmt.Errorf("not found: %s", id)
    }
    return d, nil
}

func (m *MemoryStore) Write(id string, data []byte) error {
    m.data[id] = data
    return nil
}

func (m *MemoryStore) Delete(id string) error {
    delete(m.data, id)
    return nil
}

func main() {
    store := &MemoryStore{data: make(map[string][]byte)}
    store.Write("config.json", []byte("port=8080"))

    // Pass the full Storage where only Reader is needed — works fine
    config, _ := loadConfig(store)
    fmt.Println(string(config)) // port=8080
}

package main

import (
    "fmt"
    "time"
)

func sayHello(name string) {
    fmt.Printf("Hello, %s!\n", name)
}

func main() {
    // Synchronous — runs and completes before moving on
    sayHello("direct call")

    // Asynchronous — starts a new goroutine
    go sayHello("goroutine")

    // Anonymous goroutine — common pattern
    go func(msg string) {
        fmt.Println(msg)
    }("anonymous goroutine")

    // Without this sleep, main() would exit before
    // the goroutines have a chance to run!
    time.Sleep(100 * time.Millisecond)
    fmt.Println("main done")
}

package main

import (
    "fmt"
    "sync"
    "time"
)

func fetchData(source string, wg *sync.WaitGroup) {
    defer wg.Done() // Signal completion when function returns
    time.Sleep(100 * time.Millisecond) // Simulate work
    fmt.Println("Fetched from:", source)
}

func main() {
    var wg sync.WaitGroup

    sources := []string{"database", "cache", "api"}

    for _, src := range sources {
        wg.Add(1)           // Increment counter
        go fetchData(src, &wg) // Run concurrently
    }

    wg.Wait() // Block until all goroutines call Done()
    fmt.Println("All data fetched!")
    // All 3 goroutines run at the same time (~100ms total, not 300ms)
}

Time 0ms:
  main:       wg.Add(1), go fetchData("database")  → counter = 1
              wg.Add(1), go fetchData("cache")     → counter = 2
              wg.Add(1), go fetchData("api")       → counter = 3
              wg.Wait()  ← main is now BLOCKED

Time 0-100ms:
  goroutine1: sleeping... (database)
  goroutine2: sleeping... (cache)
  goroutine3: sleeping... (api)

Time ~100ms:
  goroutine1: wg.Done() → counter = 2
  goroutine2: wg.Done() → counter = 1
  goroutine3: wg.Done() → counter = 0  ← Wait() unblocks!

  main:       prints "All data fetched!"

Goroutine A  ── sends data ──→  [channel]  ──→  receives data ── Goroutine B

package main

import "fmt"

func main() {
    // Create an unbuffered channel of strings
    messages := make(chan string)

    // Launch a goroutine that sends a value
    go func() {
        messages <- "ping" // Send blocks until someone receives
    }()

    // Receive blocks until someone sends
    msg := <-messages
    fmt.Println(msg) // "ping"

    // --- Channel for returning results ---
    results := make(chan int)

    go func() {
        sum := 0
        for i := 1; i <= 100; i++ {
            sum += i
        }
        results <- sum // Send the computed result back
    }()

    total := <-results
    fmt.Println("Sum 1..100 =", total) // 5050
}

Time 0:
  main:       creates channel "messages"
              launches goroutine
              hits  msg := <-messages  ← BLOCKED (nothing sent yet)

  goroutine:  hits  messages <- "ping" ← finds main is waiting!

  ── handoff happens ──

  main:       msg now equals "ping", prints it
  goroutine:  finishes and exits

main:       creates channel "results"
              launches goroutine
              hits  total := <-results  ← BLOCKED (waiting for answer)

  goroutine:  calculates sum (1+2+...+100 = 5050)
              hits  results <- 5050     ← delivers the answer

  ── handoff happens ──

  main:       total now equals 5050, prints it