Learn Programming With Go (Golang) One Game at a Time (2025)

Discover why Go is an in-demand, beginner-friendly programming language, with real-world uses in Docker, Kubernetes, and Ethereum, and bridge the gap by teaching fundamentals, not just syntax.

See how a programming language sits between human language and the computer language of binary digits, enabling developers to build programs that run on computers.

Install and configure a Windows development environment for Go, including Git Bash, Go, and the Visual Studio Code Go extension, enabling you to write your first Go program.

Set up a macOS development environment for Go by installing Homebrew, using the Terminal to install and verify it, then installing Visual Studio Code and the Go extension.

Initialize a new go project, create main.go, write a Hello World program with package main and import fmt, then run go to see the output.

Explore how a first Go program becomes executable by translating to binary via the compiler, using package and import declarations, defining the main function, and printing text to the screen.

Explore Visual Studio Code as an integrated development environment that enhances Go programming with syntax highlighting, code completion, bracket matching, and a file explorer, speeding up coding.

Build go programs into executables with go build, run them like any other program, and share binary files across Windows and macOS without exposing source code.

Develop programming as a craft through persistent practice and hands-on exercises. Persevere through stretch problems, learn to search effectively, and translate challenges into real-world Go coding skills.

Explore Go basics with practical exercises: print hello world, print your name and age, learn variables, for loops, and power calculations, and generate random numbers and current dates.

Explore data types and variables in Go, learn how to declare and assign string variables, use variables in functions, and see type inference and short variable declarations in action.

Learn Go's base data types: integers, real numbers, strings, characters, booleans, and phone numbers; declare and print them, and understand Go's strict type hierarchy that prevents mixing types.

Fix gopls workspace error in Visual Studio Code by simplifying your folders. Remove extraneous folders and keep only the folder with the Go source you want to work on.

Learn about variable usage, scope within blocks, and the dangers of redeclaring the same name in a single block. Emphasize descriptive names to improve readability and maintainability.

Explore how primitive data types like strings, integers, and booleans build into complex composite data types such as person and school. See how the time package introduces a time type.

Explore the integer data types in Go, including 8, 16, 32, and 64 bit variants, signed and unsigned forms, and aliases like int and byte.

Explore floating point numbers as data types that store real numbers and can encapsulate integers. Understand 32- and 64-bit precision, why integers are used for counting, and memory representation.

Explore booleans for conditions, and runes for characters, then strings for text; discover memory as numbers, ASCII and Unicode mappings, and how symbols and emojis render in code.

Explore how Go assigns zero values to uninitialized variables. Observe that strings default to an empty string, booleans to false, and numeric types including ints, floats, and characters to zero.

Explore basic arithmetic operations in Go, including addition, subtraction, multiplication, division, modulus, and increment and decrement on integer variables, with practical examples.

Explore how integer arithmetic works in Go, including addition, subtraction, multiplication, division, and modulus, and learn how overflow and integer division differ from floating point behavior.

explore floating point arithmetic, including addition, subtraction, multiplication, division, and why modulus doesn't apply to floats; note division by zero yields infinities and use a decimal type for money.

Explore operator precedence in Go arithmetic, where division outranks addition and subtraction. Learn to override precedence with brackets to simplify complex expressions and improve readability.

Explore how characters and strings differ in Go: characters behave like integers with arithmetic, while strings support concatenation but not subtraction or division, and strings can be appended to strings.

Learn how to escape special characters in Go strings, including new lines, quotes, and slashes, to ensure correct compilation and printing.

Master explicit type conversions in Go, moving values between int, int8, int16, int64, and floats. Note that larger-to-smaller conversions may lose data, and string-to-integer conversions are not allowed.

Explore Go type conversions: float to int loses decimals, string to int via P2i returning value and error, nil meaning no error, and int to string with Itoa.

Discover how to perform complex arithmetic in Go with the math package, using square roots, logarithms, absolute values, and powers through practical examples and type conversions.

Go variable names can include letters, digits, and underscores, with examples like firstName and lastName; follow camel case conventions in Go, avoiding spaces and symbols.

Explore composite data types in Go, such as the time type, which bundles primitive types and exposes their own operations; learn to access year, month, and day.

Explore constants in Go, declared with const, which hold values of primitive types only and never change. Compare with variables and use constants to clarify meaning in calculations like circumference.

Learn how shorthand operators in Go update variables in place, using plus equals, minus equals, and others as concise equivalents of the longer forms like x = x + y.

Resolve a Windows import issue caused by CRLF vs LF line endings. Set the end-of-line sequence in your editor to Linux style to ensure correct formatting and compilation.

Explore the building blocks of data—bits and bytes—and learn how numeral systems, including decimal and binary, represent numbers, manage overflow, and underlie computer arithmetic.

Explore how computers use binary and hexadecimal representations to encode numbers, text, and media, covering bits and bytes, capacity, and data sizes like kilobytes and megabytes.

Explore the terminal basics, learn what the terminal is and why developers prefer it to graphical interfaces, and discover its power for batch file edits and running Go projects.

Explore the terminal and shell basics in Visual Studio Code, comparing PowerShell and bash, understanding terminals, shells, and consoles, and learning to run Go commands from any path.

Explore terminal basics: the prompt, status line, and current directory, plus path notation and home directories. See how directory-related commands work and how Git branches relate to your work.

Master Bash as the default shell for Go development across Linux, Mac OS, and Windows, configure Visual Studio Code to use Bash, and compare commands like grep across shells.

Explore essential terminal commands to create directories and files, list items, and navigate with cd. Edit files with nano, save, and display contents using gap to reinforce terminal changes.

Learn how to move and copy files between directories using the copy and move commands, create directories like Dump and Junk, and verify outcomes in the file explorer.

Learn how to delete a single file by specifying its name and remove a folder using recursive and force options to delete the directory and its contents.

Learn essential Go command line utilities for file management, including sort, head, tail, unique, and grep. Understand how flags and redirection affect output and how to read manuals for usage.

Explore redirecting command output to files to save modified data, using echo, unique, and sort, and learn to overwrite, append, and back up files safely.

Combine simple commands with piping to get unique elements, sort them, and redirect output for files. Apply a single line across a directory to automate these tasks.

Discover how terminal commands map to installed executables, locate their paths, and use command line arguments and options; learn how to create your own commands in Go.

Explore how to use standard output and stdout, run programs in the terminal, and redirect or pipe output to files or other commands.

Learn how fmt.Println handles multiple arguments in Go, printing them on the same line with spaces in between and appending a newline to the standard output.

Explore how fmt.Print outputs text without spaces or a trailing newline, keeping output on the same line and showing when to use it to avoid moving the cursor.

Explore raw string literals in Go to print multiline text using backticks, contrasting with normal quoted strings that end lines and cause compile errors.

Learn to format Go outputs using a format string and placeholders, substituting values with a print-like function, and control types with verbs like %s, %d, %b, and %c.

Explore formatting output in Go by using placeholders to print floats and integers, control decimal places and width, align tables, and capture formatted results as strings.

Learn to read terminal input in Go using a reader for standard input, read lines, trim newlines, pipe input from a file, and convert strings to numbers, panicking on errors.

Learn how to read floating point numbers from the terminal in Go, specifying the bitesize (32 or 64), handling errors, and converting line input into numbers.

Learn to debug go in visual studio code by editing the global launch configuration and adding a terminal alias to run the long command with goldi book.

Master debugging Go programs by setting breakpoints, attaching to a debug session, and stepping through code line by line to inspect variables and understand execution flow.

Explore comparison operations in Go, using equality and inequality operators to yield boolean results. Compare numbers and strings, and use a strings package function to check text containment.

Learn how to use if statements in Go to execute code based on conditions, compare input strings, and print tailored greetings while exploring basic debugging and control flow.

Explore how else-if statements enable mutually exclusive conditions to control number-based output in Go. Read input, compare numbers, and use else-if to avoid multiple prints.

Understand how the else statement provides a final fallback in an if-else chain in Go, using animal type examples (mammal, amphibian, birds, fish) and an unknown input case.

Learn to use nested if statements to compare two or three numbers, check equality, and identify the greatest one using layered if and else blocks.

Explore the switch case in Go as a readable alternative to if statements, using day-of-week cases, a default, and optional fallthrough to control flow.

Learn how to combine multiple conditions with the logical and operator in Go to determine if a point lies inside a rectangle, replacing long nested if statements.

Explore how the or operator evaluates multiple conditions in Go, allowing output when any condition is true, and compare it with the and operator using sponsor, height, or strength.

Combine logical and or operators to form complex conditions, checking car type automatic and gears are zero, or car type manual and gears greater than zero, using if statements.

Use logical operators to check whether a point with x and y coordinates lies inside a rectangle defined by its top left and bottom right corners, not on any borders.

Apply the not operator to invert a boolean expression with an exclamation mark and brackets, turning true to false and clarifying when at least one condition doesn't match.

Learn how for loops in Go execute code repeatedly by checking a condition, printing numbers from one to ten, and incrementing each time until the condition fails.

Learn the advanced for loop in Go that combines initialization, condition, and increment on a single line, showing how the shorthand prints the counter until the condition fails.

Explore nested loops with outer and inner for loops to print numbers from zero to nine, understand loop control, and practice Go iteration concepts.

Learn how slices group multiple values in a single variable, initialize and extend them with new elements, and manage string data under Go's type constraints.

Access and change slice elements using zero-based indices, illustrate with a variable index, and note panics from out-of-range access and len usage.

Learn how to iterate and modify slice elements in Go using for loops and the range form, including index-based updates and pitfalls with copy semantics.

Learn how to add elements to a Go slice with the append function, which returns a new slice you must assign to update the original.

Combine two slices in Go by using the spread operator to expand a slice's elements as variadic arguments to a function, producing a merged result.

Explore slices and subslices in Go, using range notation with inclusive lower and exclusive upper bounds, and learn that slices are views sharing data across derivatives.

Remove elements from a Go slice by combining two sub-slices and append, illustrated with a zombie game example; avoid changing the original by copying to a new slice.

Explore arrays and slices in Go by showing fixed-size arrays, how to initialize and print them, and why slices are preferred for their ability to grow.

Learn how maps enable key-value associations in Go by using string keys like nicknames to store and retrieve player hit points, contrasting with slices and showing map syntax.

Access and modify map elements in Go using string keys, retrieve values, update hit points, and check existence with the second return value when a key is missing.

learn how to add elements to a map by assigning map[key] = value, and conditionally insert only when the key doesn't exist using an if statement with a semicolon.

Learn to remove map elements in Go with the delete function, and see that deleted keys yield zero and false on subsequent access, while deleting non-existent keys changes nothing.

Explore how to iterate maps in Go using for range, access keys and values, understand zero-value returns for missing keys, and note that map iteration order is not guaranteed.

Discover how void functions reduce copy-paste by extracting repeated print statements into a reusable function, and learn function calls, definitions, and basic debugging with step over and step into.

Explore how Go functions accept input through parameters and arguments, manage local scope, and print with multiple inputs, including string parameters and integer examples.

Learn to create functions that accept inputs and return a result, such as calculating the sum of digits, using the return keyword to pass data back, enabling reuse and modularity.

Explore returning multiple values in Go, including errors, by adding a second return value and using errors.New for messages, then handle errors with if err != nil.

Learn how to define variadic functions in Go that accept a variable number of string arguments using the ... syntax, how they translate to slices, and how to invoke them.

Explore how pointers reference values in Go, initialize them with addresses, and dereference with * to access values. See how updating via a pointer changes the original value without copying.

Learn how Go pointers create references to existing values, using ampersands to take addresses and asterisks to dereference, so assignments modify memory without copying values.

Demonstrate how pointers in functions mutate outside variables by passing addresses, contrast with value copies, and highlight potential unintended side effects from pointer use.

Maps behave like pointers in functions, mutating the original map, while slices pass by view: modify elements in place, but append returns a new slice that must be returned.

Define custom data types with structs, composing primitive fields to model objects, then instantiate with values using curly braces, and use pointers to mutate and explore copy vs reference semantics.

Learn to use third party libraries in Go by importing external packages, installing them with go get, and managing dependencies and versions to ensure consistent builds.

Learn how static variables create shared state accessible by all functions in a Go program. Compare static variables with constants and consider their use in game-like scenarios where persistence matters.

Plan, implement, and build a hangman game in Go by outlining tasks, handling user input, updating guessed letters, and printing the game state, with basic file usage.

derive a random word for hangman from a word dictionary stored as a slice in Go, using a random index and global initialization, and compare slice and map approaches.

Learn how to print the game state for hangman by tracking guessed letters with a map, displaying letters or underscores, handling spaces, and normalizing case.

Render the hangman state in a Go program by reading state files and returning a string for printing, while refining names and combining word progress with the drawing.

Read user input in a loop to update the hangman game state and validate single-letter inputs, trimming whitespace and reusing a single input reader.

Implement a Go hangman game by checking guesses, updating the guessed letters or the hangman state, using maps and default booleans, and organizing logic with concise functions.

Implement the final game over logic for a hangman game in Go, checking if the word is guessed or the hangman is complete to determine a win or loss.

Explore extra challenges that push you to implement reuse checks for previously guessed letters, add a hints command. Build cross-platform binaries and share your Hangman game with friends.

Design and implement a two-player arcade paddle game in Go, rendering a playing field, handling user input, ball movement, and collisions, with game over logic and a playable base version.

Render stuff on screen in Go using the Thistle library, compare with the bigger goal library, install via go get, and explore demos and a hello world example.

Visualize building a Go game UI: initialize and render a screen, display Hello world, handle resize and key events, and simplify unicode width handling to focus on core drawing logic.

Learn how to handle screen events and key presses in a Go game, converting a generic event into specific key or resize events to drive game logic.

Learn to render on screen using columns and rows, understand screen quadrants, start from zero, and draw rectangles of characters like asterix via nested loops.

Draw the paddles in the screen’s middle, compute their coordinates from screen width and height, and encapsulate paddle properties in a game state structure while replacing magic numbers with variables.

Learn to read user input for a Go game, move the game object with up and down keys, and use background go routines to avoid blocking the main loop.

Learn to capture key presses in Go, send them via channels to the game process, and use debug printing of event names in the main loop to drive input handling.

Learn how to handle user input in Go without blocking, using select on channels and a read inputs helper to keep the game running.

Implement paddle boundary checks to prevent off-screen movement when pressing w or s, validating top and bottom edges and refactoring the logic into a reusable function for future steps.

Draw a bowl symbol to represent the ball, refactor to use a slice of game objects, and manage initialization and pointers for dynamic objects on the screen.

Define velocity on the roll and column to drive the ball's movement across up, down, left, right, and diagonals, with a non-zero initial velocity.

Set the initial ball velocity for the row and column, update object positions in the update state, and draw the updated positions in the draw state to animate movement.

Enable ball-wall collisions by inverting the row velocity while the column velocity stays constant, reflecting off the wall through boundary checks against screen height and zero.

Learn to implement a reusable wall-collision function in the update state, invert the ball's velocity on collision, and generalize it for reuse with other objects.

Detect the ball and paddle collision using boundary checks and velocity comparisons, then bounce the ball by inverting its velocity and updating the ball velocity after the hit.

Explore ball and paddle collision detection in a Go game, implementing a collides with function, handling velocity direction, and debugging with logs to refine bounce behavior.

Explore ball and paddle collision in Go by refining collision checks, removing unnecessary velocity tests, and validating paddle hits to ensure smooth gameplay.

Implement game over logic by detecting off-screen ball positions and determining the winner, then display a centered 'game over' message with a delay and centralized winner handling.

Optimize rendering by drawing only necessary screen portions, implement color variations and frame boundaries, add randomness, scoring, bonuses, and dynamic ball direction to expand Go game development skills.

Begin building the classic snake game in Go, with a snake, an apple, and an explicit game frame, and learn how self-collision or leaving the screen ends the game.

Begin building a Go game by reviewing initial code, reusing Pong and Bonk foundations, and setting up a T-cell screen with an internal frame for score.

Develop a game plan for a snake game by outlining steps: initialize objects, print game frame, handle input, update the snake and apples, spawn apples, detect collisions, and optimize rendering.

Center the game frame on the screen and use its dimensions. Compute the top-left of the frame and the surrounding rectangle, then draw them and account for the snake boundary.

Draw the game frame by computing the surrounding rectangle, center it on screen, print an unfilled border, verify with an inner frame, and refine the border with symbols.

Define snake and apple data types, render them within a game frame by offsetting coordinates, and initialize snake parts to enable drawing and future movement in a Go-based snake game.

Handle user input to move the snake by updating the head position with velocity. Remove the tail and add a new head each frame, validating against opposite directions.

Demonstrates moving the snake and handling user input to control directions, validating turns to prevent illegal moves, and switching between w and arrow keys while updating velocity.

Learn to implement eating apples and regenerating in a snake game, generating a random apple position not inside the snake and growing the snake when eaten.

Detect the snake’s wall collision by checking the head against screen boundaries, trigger game over, and center a 'game over' message while updating the score when apples are eaten.

Optimize screen rendering for a snake game by clearing only changed game-frame points, translating game-frame coordinates to screen coordinates, and buffering clears to boost performance.

Explore extra challenges to enhance the Go snake game, including redefining the frame, validating screen size, displaying the score outside the frame, and adding color, new objects, and random events.