Learn Go: Golang Backend Code
Learn Go: Golang Backend Code — A Golang tutorial with a compiler, a race detector and daily katas on your phone
Learn Go: Golang Backend Code is a free iOS and Android Golang tutorial for beginners and working developers, with a Go compiler and editor that runs your code on a real Go toolchain (an internet connection is needed). Check it with gofmt, go vet and the race detector, and work through 51 courses from your first fmt.Println to goroutines, REST APIs and gRPC, with an AI Mentor for the parts that do not click.
- Price
- Free, Pro upgrade
- Platforms
- iOS and Android
- Languages
- 22
- Age rating
- 4+
- Requires
- iOS 15.1 or later
Delete the go keyword and watch the same work take three times as long.
That is the first thing the app has you do with Go: run three jobs of 120 ms each, see the total come in well under 360 ms, then remove the single keyword that made it concurrent. The language's whole pitch is that one word, and the app lets you feel it before explaining it.
What it is
Learn Go: Golang Backend Code is a free iOS and Android app for learning Go, the compiled language behind much of today's cloud and server software. It has 51 courses and 203 lessons graded from beginner to advanced, a code editor that runs programs on a real Go toolchain, a daily kata, a Concurrency Lab with a real race detector, and a guided track where you build your own HTTP core. An AI Mentor answers questions about any lesson.
Inside the app
What it looks like
The course
What the Go course covers
51 courses and 203 lessons from the app's own course list, graded A1 to C1 and running from the first program to profiling and the garbage collector.
Welcome to Go and the Basics
What Go is and why Google created it, then variables, types and zero values, constants, and control flow with if, for and switch.
Functions, Slices and Maps
Functions with multiple return values, defer and variadic parameters, arrays, slices and maps, plus strings, fmt formatting and the time package.
Structs, Pointers and Interfaces
Structs and methods, value versus pointer receivers, pointers, implicit interfaces and duck typing, and embedding for composition.
Errors, Packages and the Standard Library
Explicit error handling with errors.Is and errors.As, packages and modules, file I/O and JSON, regular expressions, sorting and buffered I/O.
Goroutines, Channels and Sync
Goroutine and channel fundamentals, select and channel patterns, mutexes and the sync package, context for cancellation, and worker pools and pipelines.
HTTP, REST and Databases
HTTP servers and clients with net/http, REST APIs with Gin, middleware patterns, database/sql with sqlx and pgx, GORM and WebSockets.
Testing, Tooling and Deployment
Table-driven tests and subtests, command-line apps with Cobra, configuration with Viper, structured logging with slog and multi-stage Docker builds.
Advanced Go
Generics with type parameters and constraints, benchmarking and pprof profiling, gRPC with Protocol Buffers, reflection, and the memory model.
How it works
How a session works
Each lesson is a short read followed by code you run, so the idea and the practice happen in the same sitting.
Read one short lesson
Open a course and take a single lesson of a few minutes, with the theory in plain language and a small example, such as the package main and fmt.Println program of the very first lesson.
Run it on a real Go toolchain
The editor sends your program to a Go runner and shows the output. gofmt, go vet and the race detector run the same way, so the app needs a connection when you press run, and a program that crashes shows a plain-language explanation of the error.
Practise it from another angle
After a topic, take the quiz, solve the daily kata, step through a concurrency puzzle or ask the AI Mentor to quiz you. Each one looks at the same idea differently, which is what makes it stay.
What's inside
What comes with the app
51
Courses, A1 to C1
203 lessons across 51 courses, from Go basics, slices and maps through interfaces, error handling, goroutines, net/http, Gin, database access, Docker deployment, gRPC and the garbage collector.
-race
Concurrency Lab with the race detector
Six runnable puzzles cover two goroutines on one channel, an unbuffered handshake, a WaitGroup fan-out, a counter that loses updates, a map with two writers and a deadlock. You can also run your own code under the race detector, free and without a daily limit.
Daily
A new kata every day
A Go exercise checked against a table of cases, including hidden ones, with a reference explanation afterwards. The daily kata is free for everyone; Pro opens the full library, the reference solutions and the explanations.
Doctor
Go Doctor
Check whether gofmt would rewrite your file and apply it, run go vet for findings, and, with Pro, ask the compiler's escape analysis why a value allocates. Formatting is unlimited, and go vet is limited to three runs a day on the free plan.
7 steps
Build your own HTTP core
A guided track where you write the request, the response, handlers as functions, routing, path parameters, middleware, and JSON with wrapped errors yourself, one checked step at a time.
AI
AI Mentor and mock interview
Ask the AI Mentor to explain a concept, give you a roadmap or quiz you. A mock interview asks five Go questions at junior, mid or senior level and scores your answers, with one scored interview a week free.
Recall
Go Recall and Go by Example
Short "what does this print?" cards on the classic gotchas, such as defer order, nil maps and append sharing memory, plus runnable standard-library snippets you can run and edit.
Background
Why learn Go for backend work, and what makes it different?
Go is a statically typed, compiled language created at Google, and it is widely used for web services, command-line tools and cloud infrastructure. Its appeal for backend work is that a lot is built in: concurrency is part of the language, the standard library covers most of what a small service needs, and a program compiles to a single binary with nothing to install beside it. The language is deliberately small, which makes it quick to read but gives beginners a handful of unfamiliar habits to learn early.
Goroutines and channelsconcurrency without threads to manage
A goroutine is a function started with the go keyword, and a channel is the pipe goroutines use to pass values. Together they replace most hand-written thread handling, which is why concurrency is taught early instead of being left as an advanced topic.
Errors are valuesno exceptions
A Go function that can fail returns an error as an ordinary second value, and the caller checks it right there. It is more typing than a try block, and it means every failure path is visible in the code you are reading.
Implicit interfacesduck typing, checked at compile time
A type satisfies an interface just by having the right methods; nothing is declared. This keeps packages loosely coupled, and it is also where a classic Go surprise lives: an interface holding a nil pointer is not itself nil.
One binary and a large standard librarywhy deployment is simple
Compiled Go produces a single executable, and packages such as net/http, encoding/json and database/sql ship with the language. A small service often needs no third-party framework, which is one reason Docker images for Go programs can be small.
Fit
Who it's for — and who it isn't
A good fit if you
- Want a Golang course you can work through in short sessions on a phone
- Already write another language and want to see goroutines and channels actually run
- Are aiming at backend or cloud roles and want Go interview questions with scored feedback
- Learn better from small exercises and gotcha cards than from long videos
- Want to check formatting, vet findings and data races on code you wrote yourself
Not the right tool if you
- Need to run programs that import net/http or use generics in the in-app runner, which is a Go 1.13 sandbox
- Want to run code with no connection, because the runner is online
- Expect everything free: the first course, the daily kata and a daily AI Mentor allowance are free, and Pro unlocks the rest
- Need to build and ship a large multi-package service, which still calls for a laptop and the full toolchain
Questions
Frequently asked questions
What is the best way to learn Golang on a phone?
Short lessons plus code you actually run beat reading alone, and Go rewards running things because its best features, goroutines and the race detector, are behavioural. Learn Go: Golang Backend Code pairs lessons of a few minutes with an editor, a daily kata and a Concurrency Lab. It is free to start on iOS and Android, with 51 courses ordered from beginner to advanced.
Can you compile and run Go code on your phone?
Yes, with a connection. Learn Go: Golang Backend Code sends your program to a Go runner and shows the output, and the same runner provides gofmt, go vet and the race detector. The code is not executed on the phone itself, so you need to be online when you press run, and the runner has limits such as a small memory allowance and a maximum binary size.
Does the in-app runner support generics?
Not today. The runner in Learn Go: Golang Backend Code is Go 1.13, and generics arrived in Go 1.18, so a program using type parameters or the any keyword will not compile there. The app says so in plain language when it happens and suggests the older form. The generics course itself is still readable as a lesson.
What is the Go race detector and how does the app use it?
The race detector reports when two goroutines touch the same memory without a lock between them, a bug that only shows up some of the time. In Learn Go: Golang Backend Code, the Concurrency Lab runs puzzles such as a counter updated by 200 goroutines under the detector and lets you add a mutex and run again. You can also paste your own goroutine code and run it under the detector.
What is a Go kata?
A kata is a small, focused exercise you solve in code, such as reversing a string correctly for non-ASCII text or wrapping an error so errors.Is still finds it. Learn Go: Golang Backend Code gives a new daily kata, checks your function against a table of cases that includes hidden ones, and explains the idiom afterwards. The daily kata is free for everyone.
Do I need programming experience to start?
No. Learn Go: Golang Backend Code starts with what Go is and why it exists, then variables, types and control flow, and every concept is explained in plain language before it is practised. Experience in another language helps you move faster through the early courses, but the first course is written for someone starting from zero.
Is Learn Go free?
The app is free to download. The first course is free, along with the daily kata, a daily AI Mentor allowance, unlimited gofmt checks, unlimited runs under the race detector and a few go vet runs a day. Pro unlocks every course, removes ads, gives unlimited AI Mentor and opens the kata library and escape analysis.
Is there a certificate at the end?
Yes. Passing the final exam gives you a certificate of completion for the course. It shows the work you did and sits well beside a small project you can talk through in an interview, but it is not an accredited academic qualification.
Does Learn Go help with Golang interview preparation?
It does. The mock interview asks five questions at junior, mid or senior level, from slices versus arrays to what an interface value holds at run time, and scores your answers with feedback. Go Recall cards drill the usual gotchas, and weak topics from an interview are added to your recall deck. One scored interview a week is free.
Which platforms and languages does it support?
Learn Go: Golang Backend Code runs on iOS through the App Store and on Android through Google Play, and the interface is available in 22 languages. It is rated 4+, so nothing in the material is age-restricted.
Get started
Write your first goroutine today
Free to start on iOS and Android, in 22 languages.
More from CoddyKit
Available on iOS and Android.