Skip to content

Monthly Review — Month 1: Go Fundamentals

Journal index · Roadmap › this month · Release notes

🎬 Headline

I can read and write idiomatic Go end-to-end — from syntax and composite types through methods, interfaces, the error toolkit, and generics — and I shipped a tested, dependency-free CLI (taskcli) as proof.

🛠️ Skills Acquired

Skill Confidence (1-5) Evidence (link)
Syntax, variables, constants, iota 4 Day 002
Control flow & functions (multi-return, defer, closures) 4 Week 1 review
Composite types: slices (aliasing/append), maps, sets 4 examples/.../slice-internals
Strings, runes & UTF-8 4 examples/.../strings-runes
Structs, tags & JSON (un)marshaling 4 Day 025
Methods & value/pointer receivers 4 examples/.../methods
Interfaces, implicit satisfaction, type switches 4 examples/.../interfaces
Errors: %w wrapping, Is/As/Join, panic/recover 4 Week 3 review
Embedding & composition 3 Day 022
Generics: type params, constraints, generic containers 3 examples/.../generics
Table-driven testing (testing, t.TempDir, subtests) 4 Day 027
CLI building with stdlib flag 3 examples/.../cli-flags

📦 Projects Completed

  • taskcli — a stdlib-only task manager: Task model, atomic JSON file store, flag-based subcommands (add/list/done/rm), and table-driven tests — repo path · key learning: keep main thin over run() error, treat a missing data file as empty, and save atomically with temp-file + os.Rename.

💡 Lessons Learned

  • Go optimizes for reading code: explicit errors, small interfaces, no inheritance, gofmt-enforced style. Boring is a feature.
  • Zero values and "make the zero value useful" shape API design (nil-safe reads, no constructors needed for simple types).
  • The big footguns are concrete and learnable: slice append aliasing, the nil-interface trap, nil-map writes, and == vs errors.Is on wrapped errors.
  • Composition over inheritance plus implicit interfaces keep coupling low; generics remove interface{} boxing where the algorithm is type-agnostic.
  • Testing is cheap and idiomatic in Go: table-driven subtests + t.TempDir() make even file I/O easy to cover.

📉 Areas for Improvement

  • Faster constraint selection (comparable vs cmp.Ordered) and remembering ~ for named types.
  • Spotting the nil-interface trap under time pressure.
  • Haven't touched concurrency yet — the whole point of Month 2.

🔁 Concepts to Keep Reviewing (carry into spaced repetition)

  • Slice backing-array aliasing & three-index slicing.
  • Method sets of T vs *T and how embedding promotes them.
  • errors.Is/As/Join reflexes over ==/string compares.
  • Generics vs interfaces decision; union constraints with ~.

🧑‍💼 Interview Readiness

Area Ready? Notes
Language fundamentals ✅ Confident on types, methods, interfaces, errors, generics; can whiteboard slice/map internals.
Concurrency ⬜ Not started — Month 2 focus (goroutines, channels, select, context).
Web/DB ⬜ Built a CLI + JSON files; no HTTP server or SQL yet (later months).

🎒 Portfolio Updates

  • Updated project README + usage examples for taskcli
  • New résumé bullet: "Built a tested, zero-dependency Go CLI (atomic JSON storage, stdlib flag subcommands, table-driven tests)."
  • Pinned/featured: go-from-zero learning journal (28 daily notes, examples, exercises)
  • Tagged release v0.1.0 + wrote release notes

📊 Metrics

Total hours Days completed Exercises Projects Books/articles Avg confidence
38 28/28 12 1 6 3.8/5

⏭️ Next Month Preview

Month 2 is Concurrency & the runtime: goroutines, channels and their axioms, select, the sync package, context for cancellation/deadlines, and the race detector. Prep: re-read the channel/goroutine chapters before Day 029 and keep the run() error + table-driven (-race) testing habits from this month.

Suggested commit: docs(journal): month 1 review then git tag -a v0.1.0 -m "Month 1 complete"