Go
Go is small enough to learn well, and big enough to build real things with. You start with variables. You finish with a working JSON API that has user accounts, a database, file uploads and tests. It uses only four outside packages. Everything else comes with Go. Interview path: if you are preparing for campus hiring, new-grad interviews or online assessments, do Getting started → Core language → Go for coding rounds → Interview preparation first, and come back for the rest.
Quick revision
The main points from all 98 topics on one page. Good for a quick reread.
Multiple choice tests
382 questions, one test per section plus a mixed final.
Read the sections in order. Each one builds on the ones before it. There is no timetable, so go as fast or as slow as you like. Every topic ends with something to build, plus a few short tasks to try in your own editor. Official docs: go.dev
Install it, run something, and meet the ideas that make Go different from what you already know.
01Setup, your first program, and the toolchainInstall Go, run one file, and meet the four commands you will use every day.
02Syntax, comments, and namingThe shape every Go file takes, and the naming rules the whole ecosystem follows.
03Printing and format verbsThe three printing functions, and the verbs you will use every day.
04Basic data typesEvery built-in type, why there are so many integer sizes, and what to actually use.
05Constants and iotaValues fixed at compile time, and how Go does enums without an enum keyword.
06OperatorsArithmetic, comparison, logical, and bitwise, plus what Go leaves out on purpose.
07Type conversionWhy Go refuses to turn an int into a float for you.
08if, for, and switchOne loop keyword, no ternary, and cases that do not fall through.
Functions, errors as values, the two data structures you use all day, your own types, and tests.
09Functions, multiple returns, and errorsThere are no exceptions. An error is a value you return, and that changes everything.
10deferCleanup you cannot forget, and the two traps that catch most people once.
11Arrays and slicesThe data structure you use all day, and the shared-memory trap inside it.
12MapsA hash table with two behaviours that surprise most people once.
13Strings, bytes, and runesWhy `len("héllo")` is 6, and the string operations you will use every day.
14PointersWhat `&` and `*` do, when you need them, and why Go pointers cannot hurt you the way C ones can.
15StructsHow you make your own types by grouping values under one name.
16Methods, receivers, and embeddingThe rule about receivers that most beginners trip on.
17InterfacesGo’s main abstraction, satisfied without ever being declared.
18Type assertions and type switchesGetting the concrete value back out of an interface, safely.
19Error values in depthSentinels, custom types, wrapping, and handling each error once.
20Packages and visibilityA folder is a package, and capitalisation is your access control.
21JSONTurning structs into JSON and back, and the field that disappears with no error.
22TestingPart of the toolchain, not a library you pick.
How to read judge input fast, then fifteen problems campus hiring tests and online assessments ask most (maps, slices, linked lists, trees, recursion, DP, graphs, sliding windows), each solved idiomatically in Go with the trap that costs marks.
23Fast input and output for online judgesHow to read the input HackerRank, CodeChef and company OAs send on stdin, and print the answer fast enough to pass the time limit.
24Two sum with a mapThe most-asked warm-up in any coding round, and the cleanest demonstration of why a map beats a nested loop.
25Reverse and rotate a slice in placeTwo pointers, the three-reversal trick, and the slice aliasing that makes "in place" mean what it says.
26Frequency count and top KCount with a map, rank with a sort or a heap, and never let map order leak into your answer.
27Valid parentheses with a slice as a stackGo has no stack type, because a slice already is one. Push with append, pop by re-slicing.
28Binary search, by hand and from the stdlibWrite it once without an off-by-one, then know when `slices.BinarySearch` and `sort.Search` do it for you.
29LRU cache with container/list and a mapThe design question disguised as a coding question: two structures, each covering what the other cannot.
30Reverse a linked listThree pointers and one saved link. The question that checks you can move pointers without losing the rest of the list.
31Detect a cycle with two pointersFloyd's tortoise and hare: find a loop in a linked list with no extra memory.
32Merge two sorted listsA dummy head node removes every special case, and the leftover tail is attached in one line.
33Binary tree depth and level orderRecursion for depth, a slice as a queue for level order. The two shapes every tree question uses.
34Subsets and permutations with backtrackingChoose, recurse, undo. And the one-line copy that stops every answer turning into the same slice.
35Dynamic programming: stairs, coins, LCSWrite the answer for a small case in terms of smaller ones, then fill a table from the bottom up.
36Number of islands: DFS on a gridA grid is a graph in disguise. Find unvisited land, flood it, count one.
37Merge overlapping intervalsSort by start, then one pass. The sort does the hard part.
38Longest substring without repeating charactersA window with two edges and a map of where each character was last seen. Rune-aware, so it counts characters, not bytes.
The part people come to Go for. Run things at the same time, safely, and stop them when you need to.
39GoroutinesStart ten thousand concurrent things with one keyword.
40Channels and selectPassing values between goroutines safely, and waiting on several at once.
41Mutexes and the race detectorSharing state between goroutines without corrupting it.
42ContextCancelling work that nobody is waiting for any more.
43Concurrency patternsRun once, wait for many, stop on the first error, cap the parallelism, and never leak a goroutine.
Write one function that works for many types, and learn which built-in packages you will use most.
Build an HTTP API with no framework, add middleware, shut it down cleanly, and lay the folders out well.
How Go finds your code, the third-party packages you will meet most, and the four commands to run before every push.
49Modules, dependencies, and the go commandHow Go finds your code and other people’s, and the commands worth memorising.
50The packages everyone actually usesThe well-known third-party libraries, what each is for, and when the standard library is still the better choice.
51What the famous packages look like in codeThe follow-up to Packages: how a real module splits into many packages, what `internal/` hides, why imports cannot go in a circle, and what the popular libraries look like in code.
Postgres through database/sql. No ORM, so you write and see every query that runs.
Build the same CRUD API three times, in three layouts, so the trade-offs are something you have felt rather than read.
54How to lay a Go project outWhat a package is, the three layouts you will meet, and what each common folder is for.
55Practice 1 — CRUD, the easy wayOne file, one package, no database. Get the four operations working before you add anything else.
56Practice 2 — CRUD, split into layersThe same task list, now in packages with a real database behind it.
57Practice 3 — CRUD, one folder per featureThe final layout, and the one the rest of this track is built on.
Optional — after you finish the basics. Built with a **layered** structure: a folder per kind of code. Validation, storage, a redirect, then Postgres and a container.
58Project 1 — URL shortener: what we are buildingThe plan, the endpoints, and the data before a single line of Go.
59Step 1 — Set up the projectThe module, the folders, and one route that proves it runs.
60Step 2 — The store, in memorySomewhere to keep links, so you can build the API before adding a database.
61Step 3 — Creating a short linkValidate the URL you are given, generate a code, and store it.
62Step 4 — The redirectThe one endpoint the whole product exists for.
63Step 5 — Swap memory for PostgresThe same API, now with data that survives a restart. The service and handlers do not change.
64Step 6 — List, delete, and finish the projectThe remaining endpoints, then shutdown, tests and a container.
Built **by feature**: one folder per concept. Accounts, passwords and login, taught inside the project that needs them.
65Project 2 — Expense tracker: what we are buildingA money app with accounts, which is why this is where login belongs.
66Step 1 — Setup, config, and the schemaFail at startup rather than at 3am, and let the database enforce what it can.
67Step 2 — Register: storing a password safelyWhat hashing is, why you can never read a password back, and how bcrypt works.
68Step 3 — Login and what a token isCheck a password without unhashing it, and hand back proof for the next request.
69Step 4 — Checking the token on every requestOne middleware, at the edge, so no handler ever has to remember.
70Step 5 — Expenses, locked to their ownerCRUD again, but now every query has to know whose data it is.
71Step 6 — Filtering, paging, and a monthly reportLet the database do the counting, and never return an unbounded list.
72Step 7 — Refresh tokens and logoutMake sessions endable, without a database lookup on every request.
73Step 8 — Test that the walls actually holdOne test here matters more than the rest: the one that proves users are kept apart.
Built with **ports and adapters** (hexagonal). Roles, file uploads, and money that must not be lost.
74Project 3 — Small shop: what we are buildingProducts, images, a cart and a checkout. This is where roles, files and transactions arrive.
75Step 1 — Setup and the schemaEvery command to get from an empty folder to a running server with tables.
76Step 2 — Products and the admin roleA second middleware, because knowing who somebody is does not tell you what they may do.
77Step 3 — Uploading a product imageThe endpoint with the most ways to go wrong, and the four defences that fix them.
78Step 4 — Serving images, and what io gives youSend the file back safely, and see why one-method interfaces make everything fit together.
79Step 5 — The cartPer-user rows again, plus one SQL trick that removes a whole branch of Go.
80Step 6 — Checkout, and what a transaction is forFive things must all happen, or none of them. This is what transactions exist for.
81Step 7 — Orders, and getting it ready to deployThe last endpoints, then logging, limits, a container and the hardening pass.
Optional — after you finish the basics. The difference between something that works and something you can put online and keep running.
82Error mapping and structured loggingOne place turns domain errors into HTTP statuses, and your logs become searchable.
83Rate limiting, CORS, and security headersStop somebody brute-forcing your login, and set the headers browsers rely on.
84Docker, Makefile, and running in a containerA 15MB image with no operating system in it, and the two runtime settings a container needs.
85Polish: docs, seeds, and the finishing touchesThe difference between "it works on my machine" and something another person can run.
86Harden it, and review your own codeRead what you wrote as if a stranger wrote it, hunting for eight things that commonly break.
87Profile it, ship it, and what comes nextMeasure before you optimise, push it, and pick the right next thing to build.
The "X vs Y" questions people search and interviewers ask: goroutines vs threads, mutex vs channel, arrays vs slices, buffered vs unbuffered channels, and Go vs Java vs Python for first-job interviews.
88Goroutines vs threads: 8 differences that matterWhy Go can run a hundred thousand goroutines when the same number of OS threads would sink your machine.
89Mutex vs channel in Go: when to use whichBoth make concurrent code safe. The Go team’s own advice is to use whichever is simpler.
90Arrays vs slices in Go: the differences, with examplesAn array is a fixed box of values. A slice is a window onto one. You will use slices 99% of the time.
91Buffered vs unbuffered channels in GoAn unbuffered channel is a handshake. A buffered channel is a small queue.
92Go vs Java vs Python for your first job interviews: which should you pick?An honest comparison for campus hiring, new-grad interviews and your first backend job.
Everything above, written the way interviewers ask it. Plus the live coding round and a last checklist.
93Golang interview questions and answers (2026)60 Go interview questions for freshers, new grads and 1–3 year developers, each with a short answer and the lesson that explains it.
94Interview: language fundamentalsThe questions that open almost every Go interview, and the answer that shows you have actually written Go.
95Interview: concurrencyThe half of the interview that usually decides it, and the code they will put in front of you.
96Interview: backend, databases, and designThe round where they ask how you would actually build and run the service you just described.
97Interview: the live coding roundWhat they score while you type, and the Go-specific things that lose marks.
98Interview: the final checklistThe last pass before the call — what to revise, what to say, and what to ask them.