Checkpoint: Go Basics

Reviewed & published by Brayan K

You've learned data types, control flow, loops, arrays, slices, maps and pointers — let's combine them. This checkpoint has no new syntax. Instead you'll prove the pieces fit together by building one realistic program that reads a slice of structs, tallies with a map, and loops with range — then test yourself with a short quiz.

Part of the free Go course at LearnCodingFast — hands-on lessons with worked examples and the output they print, plus practice exercises and a quick quiz.

What You've Learned So Far

Everything in this checkpoint draws on the seven lessons before it. Here's the toolkit you're now carrying:

🛠️ Build Challenge: Order Summary

One small program ties together a struct, a slice, a map, a range loop, integer-to-float conversion, and key sorting. Start from the scaffold below. The data and the Item struct are given — your job is the loop in the middle and the printing at the end.

Your starting point

Fill in the loop and the output. Work through the four numbered steps in the comments — attempt it before peeking.

package main

import (
    "fmt"
    "sort"
)

// 🎯 BUILD CHALLENGE: Order summary
// A small shop has these line items. Your job, step by step:
//   1. Define an Item struct with Name (string), Price (int, in pence)
//      and Qty (int).
//   2. Put several Items in a SLICE.
//   3. RANGE over the slice to:
//        - add each line's (Price * Qty) to a running grandTotal
//        - TALLY how many units of each Name into a map[string]int
//   4. Print the grand total in pounds, then each product's unit
//      count in ALPHABETICAL order (sort the keys!).
//
// Expected output:
//   Grand total: £5.49
//   apple x4
//   bread x1
//   milk x2

type Item struct {
    Name  string
    Price int // pence
    Qty   int
}

func main() {
    items := []Item{
        {Name: "apple", Price: 50, Qty: 4},  // 200p
        {Name: "milk", Price: 99, Qty: 2},    // 198p
        {Name: "bread", Price: 151, Qty: 1},  // 151p
    }

    grandTotal := 0
    counts := map[string]int{}

    // your code here:
    //  - loop with range over items
    //  - grandTotal += it.Price * it.Qty
    //  - counts[it.Name] += it.Qty

    // then print the total in pounds and the sorted counts
    _ = sort.Strings // hint: you'll need sort.Strings on the keys
    _ = grandTotal
    _ = counts
    fmt.Println("replace me")
}

Stuck? Reveal the worked solution

The whole thing fits in one pass over the slice. Notice three deliberate choices: a single range loop does both the money total and the tally; float64(grandTotal)/100 avoids integer division so the pounds print correctly; and the map keys are copied into a slice and sort.Strings'd because map order is random.

package main

import (
    "fmt"
    "sort"
)

type Item struct {
    Name  string
    Price int // pence
    Qty   int
}

func main() {
    items := []Item{
        {Name: "apple", Price: 50, Qty: 4},
        {Name: "milk", Price: 99, Qty: 2},
        {Name: "bread", Price: 151, Qty: 1},
    }

    grandTotal := 0
    counts := map[string]int{}

    // Step 3: one pass over the slice does BOTH jobs.
    for _, it := range items {
        grandTotal += it.Price * it.Qty // running money total (pence)
        counts[it.Name] += it.Qty       // tally units per product name
    }

    // Step 4a: grand total in pounds. float64() avoids integer division.
    fmt.Printf("Grand total: £%.2f\n", float64(grandTotal)/100)

    // Step 4b: maps iterate in RANDOM order, so sort the keys first.
    names := make([]string, 0, len(counts))
    for name := range counts {
        names = append(names, name)
    }
    sort.Strings(names)

    for _, name := range names {
        fmt.Printf("%s x%d\n", name, counts[name])
    }
}

• • Struct + slice: []Item holds the line items by value.
• • One range pass: accumulates grandTotal and fills counts together.
• • Conversion: float64(grandTotal)/100 turns 549 pence into £5.49.
• • Deterministic output: sorting the keys makes the lines print in a stable, alphabetical order.

📝 Checkpoint Quiz

Answer each in your head, then reveal it. Aim for at least 5 out of 6 before moving on.

1. What does counts[k]++ do when k isn't yet in the map?

It reads the missing key as the zero value 0, adds 1, and stores 1. No need to check for the key first — this is the standard tally idiom.

2. Why is 7 / 2 equal to 3 in Go, and how do you get 3.5?

Both operands are int, so Go does integer division and truncates. Convert first: float64(7) / 2 gives 3.5.

3. After b := a; b[0] = 9, when does a[0] change — for an array vs a slice?

For an array, a is unchanged (arrays are copied). For a slice, a[0] becomes 9 too, because both slices share the same backing array.

4. Why must you write s = append(s, x) and not just append(s, x)?

append may allocate a new backing array and returns the resulting slice. If you drop the assignment, your new element can be lost.

5. How do you make a function change the caller's variable?

Take a pointer parameter (func f(n *int)), call it with the address (f(&x)), and write through it (*n = ...). Passing a plain value only edits a copy.

6. Why might two runs of a program print map entries in a different order?

Go deliberately randomizes map iteration order so code never relies on it. For stable output, collect the keys into a slice and sort them first.

Frequently Asked Questions

Q: I couldn't finish the build challenge — should I move on?

Revisit the specific lesson the sticking point came from (slices, maps, or pointers) and try again. Checkpoints are diagnostic: a gap here is exactly what they're meant to surface before it compounds.

Q: Do I need to memorise sort.Strings?

No — just remember the pattern: collect keys into a slice, sort the slice, then range it. You can always look up the exact function name in the docs.

Q: What's next after this checkpoint?

Interfaces — Go's way of describing behaviour without inheritance. They build directly on the struct and method ideas you'll see in the very next lesson on methods.

🎉 Checkpoint Complete!

• ✅ Combined a struct, slice, map, range loop and conversion in one program
• ✅ Used the tally idiom counts[k]++ on real data
• ✅ Avoided integer division with float64(x)/100
• ✅ Produced deterministic output by sorting map keys
• ✅ Reviewed value vs reference semantics and pointer mutation in the quiz

Practice quiz

Continue this course

• Previous: Structs and Interfaces
• Next: Methods (value vs pointer receivers) — Attach behavior to types and choose the right receiver