What you’ll learn
- Predict the output of tricky Go programs involving slices, maps, closures, defer and goroutines.
- Explain slice aliasing, append growth and full slice expressions, and avoid the bugs they cause.
- Use interfaces, method sets and type assertions correctly, including the nil interface trap.
- Wrap errors with %w and inspect them with the errors package (Is, As, AsType), and use panic and recover safely.
- Reason about channels, select, deadlocks, data races, sync primitives and context cancellation.
- Recognise what changed in modern Go: loop variables, range over functions, generics and new(expr).
This course includes
- On-demand video
- Mobile, tablet & desktop
- Full lifetime access
- Certificate of completion
About this course
Test How Well You Really Know Go
Go looks simple, and that is exactly why interviews and code reviews love its corner cases. Why does appending to one slice change another? Why is an error that holds a nil pointer not equal to nil? What does a deferred closure see after the function returns? These practice tests check how deeply you understand Go, one short program at a time.
What this practice test course offers:
- 200 original multiple-choice questions in 4 practice tests of 50, grouped by topic
- Short programs you must trace by hand: predict the output, the panic or the compile error
- An explanation for every answer option, plus an overall explanation of the rule behind it
- Every program compiled and run with Go 1.27, so every answer matches what the real toolchain does
- Current Go: per-iteration loop variables, range over integers and functions, min, max and clear, new(expr), AsType in the errors package and generic methods
Topics covered:
- Variables, constants, iota, conversions, strings, bytes and runes
- Control flow, defer, closures, named results and variadic functions
- Arrays, slices, append and aliasing, maps and structs, embedding
- Methods, method sets, interfaces, type assertions and the nil interface trap
- Errors and wrapping, panic and recover, generics and constraints
- Goroutines, channels, select, deadlocks, sync, atomic, context and package initialisation
Who should take this course?
- Developers preparing for Go (Golang) interviews and coding tests
- Backend engineers who write Go every day and want to find the gaps before a bug does
- Programmers moving to Go from Java, Python, C or JavaScript
If you have never written Go, start with a Go fundamentals course and come back here to test yourself.
How to use the tests: take one test at a time, then read every explanation, including the ones for questions you answered correctly. Retake a test a few days later to check that the rules have stuck.
This course is independent and is not affiliated with or endorsed by Google or the Go project.
Who this course is for
- Go developers preparing for technical interviews or coding assessments.
- Backend engineers who want to deepen their understanding of Go's rules and edge cases.
- Programmers coming to Go from Java, Python, C or JavaScript.
- Students who have finished a Go course and want challenging practice questions.
How to get it for free
- Press Get this course free — Udemy opens with the coupon applied.
- Sign in to (or create) your free Udemy account.
- Check the price shows Free, then enroll. The course stays in your account.
Coupons end on a set date or when their redemptions run out, sometimes without notice. If the price isn’t Free at checkout, the offer has ended — try another course.