Go Essentials Study Guide: 49 Flashcards on Goroutines, Slices, Interfaces and Defer
Learn Go (Golang) with 49 flashcards: syntax, slices vs arrays, make vs new, interfaces, defer, goroutines, channels and the scheduler, plus a one-week drill plan.
Studying. But it's also a video game. 🎮
Flashcards, quizzes and games that make you actually remember.
Posted by
FLIP IT TeamRelated reading
Kotlin Essentials Flashcards: Null Safety, Scope Functions and the Cards to Add
Study Kotlin with 42 flashcards: val vs var, final-by-default classes, Elvis and safe-call operators, scope functions, plus the coroutine cards the deck misses.
Master Swift Optionals, Structs and Actors: 48 Flashcards for iOS Developers
Learn Swift with 48 flashcards: optionals and guard let, struct vs class, protocol extensions, weak vs unowned, async/await and actors, plus 4 cards to fix.
Memorize Rust Ownership and Borrowing: 48 Flashcards from the Three Rules to Arc and Mutex
Learn Rust with 48 real flashcards: ownership rules, borrowing, String vs str, Option, Result, the question-mark operator, Box, Rc, Arc, traits and unsafe.
Go is small enough to fit in your head, which is why it rewards memorization: once the core ideas are automatic, the rest is the standard library. Deck AQ9100 — Go Essentials on Flip It packs them into 49 flashcards, most with real, runnable code on the back. Here is what is inside and how to drill it in a week.
Study this deck: Go Essentials
1 / 10Go and who created it
Tap the card for the answer · swipe right if you knew it, left if not
What the 49 cards cover
The deck follows a sensible progression, from syntax to runtime internals:
- Basics: who created Go (Griesemer, Pike, Thompson at Google), Hello World,
varvs:=, basic types (int8 to complex128, byte, rune), functions, named return values, variadic functions, the blank identifier_,init() - Data structures: array vs slice,
makevsnew, maps,range, structs, methods, pointer vs value receivers, type embedding, Go's no-inheritance composition model - Interfaces & errors: implicit interface satisfaction, the empty interface /
any, type assertion and type switch, error as last return value, custom error types,defer,panicandrecover - Concurrency: goroutines, channels, buffered vs unbuffered,
select,sync.WaitGroup,sync.Mutex,context, goroutine leaks, the race detector, the M:N scheduler andGOMAXPROCS - Tooling: Go modules,
go fmt,go vet,go generate, build tags, generics (Go 1.18+), the CLI (go build,go run,go test,go get), reading and writing files, memory management (concurrent mark-and-sweep GC, escape analysis)
Sample cards from the deck
| Front | Back (abridged) |
|---|---|
| Goroutine | Lightweight thread managed by the Go runtime, started with the go keyword; thousands can run with minimal overhead |
| buffered vs unbuffered channels | Unbuffered make(chan int) blocks on send until a receive; buffered make(chan int, 10) blocks only when full |
| Defer in Go | Delays execution until the surrounding function returns; multiple defers run in LIFO order; used for cleanup |
| pointer vs value receivers | func (p Person) gets a copy and cannot modify; func (p *Person) can modify and avoids copying large structs |
| array vs slice | Array: fixed size, value type ([5]int); slice: dynamic, references an array, grows with append |
| make vs new | make initializes slices, maps, channels; new allocates and returns a pointer to a zero value |
| Type assertion | s := i.(string) panics if wrong; s, ok := i.(string) is safe; switch v := i.(type) handles several |
| Goroutine leaks | A goroutine blocked forever on <-ch; fix with select on ctx.Done() or a timeout |
| Go scheduler | M:N scheduler mapping goroutines to OS threads, work-stealing, GOMAXPROCS defaults to CPU count |
How to drill code cards (not just definitions)
Half of these cards have code on the back, so flipping and nodding is not enough.
Day 1-2 — type it before you flip. For every card whose front starts with a verb (Declare variables, Define a function, Create and use a map, Read and write files), write the code in a scratch file, then flip and diff. Run go vet on it: the deck has a card for that tool, and it catches exactly the mistakes beginners make.
Day 3-4 — the concurrency block as one unit. Goroutine, channel, buffered vs unbuffered, select, WaitGroup, Mutex, context, goroutine leaks and the race detector are nine cards describing one mental model. Study them back to back, then write a 20-line program that uses all of them and run it with go run -race.
Day 5-7 — comparisons only. Filter to the X vs Y cards (array vs slice, make vs new, pointer vs value receivers, buffered vs unbuffered, Go vs other languages). These are the ones interviewers ask, and the ones that decay fastest.
Two Go-specific memory hooks
- Defer is a stack. The card's example prints
Hello Worldbecausedefer fmt.Println("World")runs afterfmt.Println("Hello"). Picture defers pushed onto a stack and popped at return, and the LIFO rule never slips. maketakes exactly three types. Slices, maps and channels are the only thingsmakeaccepts; everything else getsnewor a literal. Remember slice-map-chan and the make/new card is solved.
Get the deck
Sign in at flip-it.app and look up deck code AQ9100 (Go Essentials) in the library. Forty-nine cards, one week, and goroutines stop looking like magic.
Ready to learn faster? 🚀
Join FLIP IT for free and turn studying into a game.