/Go Engineering/Phase 2

Phase 2Days 6-10

Collections, Memory & Functional Building Blocks

Arrays, slices, maps, pointers, strings, closures, and recursion

Phase Goal

Model and transform real data while understanding what is copied, shared, or allocated.

Progress

Notes

Open the written lectures for this course before checking off the phase topics.

Projects

Field Sensor Stream Summarizer

Day 6: Arrays & Slices — Backing Arrays

Define Arrays as fixed-size values in plain language and explain the problem it solvesTrace what the Go compiler or runtime does when Arrays as fixed-size values is usedWrite a tiny example, then apply it to a realistic backend taskDiagnose the beginner failure mode for Arrays as fixed-size values and fix it deliberately

Define Slice header: pointer, length, and capacity in plain language and explain the problem it solvesTrace what the Go compiler or runtime does when Slice header: pointer, length, and capacity is usedWrite a tiny example, then apply it to a realistic backend taskDiagnose the beginner failure mode for Slice header: pointer, length, and capacity and fix it deliberately

Define append growth, aliasing, and copy in plain language and explain the problem it solvesTrace what the Go compiler or runtime does when append growth, aliasing, and copy is usedWrite a tiny example, then apply it to a realistic backend taskDiagnose the beginner failure mode for append growth, aliasing, and copy and fix it deliberately

Define Nil versus empty slices and API semantics in plain language and explain the problem it solvesTrace what the Go compiler or runtime does when Nil versus empty slices and API semantics is usedWrite a tiny example, then apply it to a realistic backend taskDiagnose the beginner failure mode for Nil versus empty slices and API semantics and fix it deliberately

Day 7: Maps, Sets & Deterministic Output

Define Map creation, lookup, comma-ok, and deletion in plain language and explain the problem it solvesTrace what the Go compiler or runtime does when Map creation, lookup, comma-ok, and deletion is usedWrite a tiny example, then apply it to a realistic backend taskDiagnose the beginner failure mode for Map creation, lookup, comma-ok, and deletion and fix it deliberately

Define Zero values, nil maps, and mutation rules in plain language and explain the problem it solvesTrace what the Go compiler or runtime does when Zero values, nil maps, and mutation rules is usedWrite a tiny example, then apply it to a realistic backend taskDiagnose the beginner failure mode for Zero values, nil maps, and mutation rules and fix it deliberately

Define Set patterns with map[T]struct{} in plain language and explain the problem it solvesTrace what the Go compiler or runtime does when Set patterns with map[T]struct{} is usedWrite a tiny example, then apply it to a realistic backend taskDiagnose the beginner failure mode for Set patterns with map[T]struct{} and fix it deliberately

Define Random iteration order and sorted output in plain language and explain the problem it solvesTrace what the Go compiler or runtime does when Random iteration order and sorted output is usedWrite a tiny example, then apply it to a realistic backend taskDiagnose the beginner failure mode for Random iteration order and sorted output and fix it deliberately

Day 8: Strings, Bytes, Runes & Unicode

Define UTF-8 strings and byte length versus character count in plain language and explain the problem it solvesTrace what the Go compiler or runtime does when UTF-8 strings and byte length versus character count is usedWrite a tiny example, then apply it to a realistic backend taskDiagnose the beginner failure mode for UTF-8 strings and byte length versus character count and fix it deliberately

Define range decoding and rune indexes in plain language and explain the problem it solvesTrace what the Go compiler or runtime does when range decoding and rune indexes is usedWrite a tiny example, then apply it to a realistic backend taskDiagnose the beginner failure mode for range decoding and rune indexes and fix it deliberately

Define strings.Builder and efficient assembly in plain language and explain the problem it solvesTrace what the Go compiler or runtime does when strings.Builder and efficient assembly is usedWrite a tiny example, then apply it to a realistic backend taskDiagnose the beginner failure mode for strings.Builder and efficient assembly and fix it deliberately

Define Unicode-safe slicing, normalization awareness, and traps in plain language and explain the problem it solvesTrace what the Go compiler or runtime does when Unicode-safe slicing, normalization awareness, and traps is usedWrite a tiny example, then apply it to a realistic backend taskDiagnose the beginner failure mode for Unicode-safe slicing, normalization awareness, and traps and fix it deliberately

Day 9: Pointers, Values & Escape Intuition

Define Address, dereference, and nil pointers in plain language and explain the problem it solvesTrace what the Go compiler or runtime does when Address, dereference, and nil pointers is usedWrite a tiny example, then apply it to a realistic backend taskDiagnose the beginner failure mode for Address, dereference, and nil pointers and fix it deliberately

Define Value versus pointer receivers preview in plain language and explain the problem it solvesTrace what the Go compiler or runtime does when Value versus pointer receivers preview is usedWrite a tiny example, then apply it to a realistic backend taskDiagnose the beginner failure mode for Value versus pointer receivers preview and fix it deliberately

Define Passing slices, maps, structs, and pointers in plain language and explain the problem it solvesTrace what the Go compiler or runtime does when Passing slices, maps, structs, and pointers is usedWrite a tiny example, then apply it to a realistic backend taskDiagnose the beginner failure mode for Passing slices, maps, structs, and pointers and fix it deliberately

Define Stack/heap intuition without manual memory management in plain language and explain the problem it solvesTrace what the Go compiler or runtime does when Stack/heap intuition without manual memory management is usedWrite a tiny example, then apply it to a realistic backend taskDiagnose the beginner failure mode for Stack/heap intuition without manual memory management and fix it deliberately

Day 10: Mini Project — Field Sensor Stream Summarizer

Define Parse valid and malformed sensor observations in plain language and explain the problem it solvesTrace what the Go compiler or runtime does when Parse valid and malformed sensor observations is usedWrite a tiny example, then apply it to a realistic backend taskDiagnose the beginner failure mode for Parse valid and malformed sensor observations and fix it deliberately

Define Aggregate station statistics with maps and slices in plain language and explain the problem it solvesTrace what the Go compiler or runtime does when Aggregate station statistics with maps and slices is usedWrite a tiny example, then apply it to a realistic backend taskDiagnose the beginner failure mode for Aggregate station statistics with maps and slices and fix it deliberately

Define Stable anomaly ranking and Unicode-safe station labels in plain language and explain the problem it solvesTrace what the Go compiler or runtime does when Stable anomaly ranking and Unicode-safe station labels is usedWrite a tiny example, then apply it to a realistic backend taskDiagnose the beginner failure mode for Stable anomaly ranking and Unicode-safe station labels and fix it deliberately

Define Project requirements, benchmarks, and rejection report in plain language and explain the problem it solvesTrace what the Go compiler or runtime does when Project requirements, benchmarks, and rejection report is usedWrite a tiny example, then apply it to a realistic backend taskDiagnose the beginner failure mode for Project requirements, benchmarks, and rejection report and fix it deliberately

Capstone

Field Sensor Stream Summarizer

Read a large newline-delimited field-sensor export and produce deterministic station coverage, range, dropout, and malformed-record reports for a conservation team.

Bounded-memory streaming
Stable anomaly and dropout ranking
Rejected-record report with tests and benchmarks

Phase Complete!

After this phase, you'll be able to:

Arrays as fixed-size values
Slice header: pointer, length, and capacity
append growth, aliasing, and copy
Nil versus empty slices and API semantics
Map creation, lookup, comma-ok, and deletion
Zero values, nil maps, and mutation rules
Set patterns with map[T]struct{}
Random iteration order and sorted output

You can apply Phase 2 skills in a finished, explainable Go project.

Back to all phases

Phase Goal

Day 6: Arrays & Slices — Backing Arrays

Arrays as fixed-size values

Slice header: pointer, length, and capacity

append growth, aliasing, and copy

Nil versus empty slices and API semantics

Day 7: Maps, Sets & Deterministic Output

Map creation, lookup, comma-ok, and deletion

Zero values, nil maps, and mutation rules

Set patterns with map[T]struct{}

Random iteration order and sorted output

Day 8: Strings, Bytes, Runes & Unicode

UTF-8 strings and byte length versus character count

range decoding and rune indexes

strings.Builder and efficient assembly

Unicode-safe slicing, normalization awareness, and traps

Day 9: Pointers, Values & Escape Intuition

Address, dereference, and nil pointers

Value versus pointer receivers preview

Passing slices, maps, structs, and pointers

Stack/heap intuition without manual memory management

Day 10: Mini Project — Field Sensor Stream Summarizer

Parse valid and malformed sensor observations

Aggregate station statistics with maps and slices

Stable anomaly ranking and Unicode-safe station labels

Project requirements, constraints & review

Field Sensor Stream Summarizer

Phase Complete!