Install Go on your computer, learn to run Go commands in the terminal, and set up Visual Studio Code to write Go code.

Install go, verify with the terminal, then learn key commands like go build, go install, go list, and go run to compile and run programs.

Use Visual Studio Code as the editor for Go programs, with the Go extension delivering full Go syntax support across Windows, macOS, and Linux.

Explore the Go program structure by identifying the main function and main package, use the printline function, and set up automatic formatting while learning built-in and external package usage.

Set up a go project structure, ensure the main package contains a main function, and run with go run, noting file naming flexibility.

Learn how to compile Go programs with go build and run the resulting executable, understanding main.go, the main package, and cross-platform executables.

Explore how go fmt and VS Code auto format go code on save, including spacing, empty lines, and how to manually format with go fmt while reviewing style guidelines.

Explore using external packages in Go by colorizing terminal output with github.com/fatih/color, install via go get, and manage dependencies with modules across a single module containing multiple packages.

Initialize a go module for the hello go project, import an external color package with go get, and manage dependencies with go.mod and go.sum while colorizing terminal output.

Learn how Go programs start with a main function in the main package and how main.go is used. Explore fmt usage, external packages, and Go mod for modules.

Explore Go's statically typed language by declaring variables, assigning and reassigning values, and reviewing basic types for variables in Go.

Set up Visual Studio Code, create a zero two variables subfolder with a main.go file, and begin the variables discussion by creating and assigning values.

Add another file zero_two_multiple_vars.go with var declarations, import fmt, and a main function, then discuss fixing the main function redeclared error caused by two main functions in the main package.

Resolve the compilation error by splitting files into separate folders, each with a single main function in its main package, and run them from their respective subfolders using go run.

Learn Go variable declarations: var with explicit types or type inference, and short declaration := inside functions; build strings from size, coffee name, and price using println or printf.

Learn to format strings in Go using fmt.Printf, inserting variables like coffee, name, size, and price with %s, %d, and %f, controlling precision with .2 and ensuring correct argument order.

Discover how Go determines variable types through short declarations inside functions. Print each variable’s type with fmt.Printf using the %T verb to reveal string, float64, bool, and int categories.

Explore reassignment of a string variable in Go by updating an order from latte to cappuccino. The example emphasizes static typing, assignment operator usage, and printing with println.

Declare several variables on one line in Go using one var keyword, with comma-separated names and values, as shown with coffee, milk, and sugar.

Explore how constants in Go are values assigned once and cannot be reassigned, and learn how this section introduces constants in Go.

Explore how to declare constants in Go, compare const with var, and why constants cannot be reassigned; learn naming conventions and when to use exported camel or Pascal case.

Go's strong typing lets untyped constants adapt to other types, while vars require explicit conversions. Learn the const versus var distinction with int and float64.

Group related variables and constants with multi-line var and const blocks in Go, improving readability, type clarity, and whether items are exported across packages.

Explore functions in Go by learning how to create and call functions with parameters, building on prior work with printf and println, and organizing projects in Visual Studio Code.

Master Go functions by building a main function, importing fmt, and calling println; create a separate greet function with no parameters and demonstrate multiple function calls and parameter usage.

Explore how function parameters and arguments control behavior in Go, pass values, and manage scope, while learning to avoid modifying parameters and refactor repetition.

Explore defining and calling a Go function with multiple string parameters to output a personalized drink info message, illustrating parameter order, placeholders, and repeated calls.

Explore returning multiple values from a Go function by implementing a process payment function that outputs total amount due and change based on order total, tip, and amount paid.

Explore named return values in Go, including how to declare and use named return variables and naked returns, illustrated by a coffee brew time example with int and string results.

Explore how Go treats functions as first-class citizens by assigning function literals to variables, creating named function literals, and using them in tax calculations and calls.

Explore closures in Go by building a temperature regulator with a function literal, returning an adjuster that mutates a base temperature across calls.

Explore Go functions, from basic function creation to parameters, arguments, and return values, and dive into closures and anonymous or named function literals with practical examples.

Explore how Go differs from other languages and dive into pointers, memory, and how to create and use pointers to modify values directly.

Explore pointers in Go by getting memory addresses with ampersand, print pointer values using fmt %p, and observe how strings copy by value while pointers reference distinct memory locations.

Explore how Go uses pointers to reference memory addresses and modify values in place. Understand the two-phase execution—compilation and runtime—and how dereferencing changes memory without changing the pointer itself.

Learn how to modify external variables in Go by using pointers in a function that applies a discount to coffee price, demonstrating pointer syntax and memory access.

This Go lecture revisits pointers, showing how copying a string creates values, how ampersand and star create and use pointers to modify memory, and how pointers drive 10% discount calculation.

Explore arrays and slices in Go, highlighting fixed-length arrays, dynamic slices, zero values, and index-based access.

Learn to declare Go arrays with array literals, initializing three strings espresso, latte, and cappuccino, and use len to get length and access the last element, noting fixed length arrays.

Explore how slices in Go relate to arrays, learn to create a slice from an array using start:end ranges, and understand why arrays have fixed length while slices are flexible.

Demonstrates how a slice created from an array remains connected to the original array, so changes to the slice modify the array; shows creating arrays, slicing, and using len.

Explore creating slices from literals and with the make function, assign and modify elements by index, inspect length with len, and distinguish slices from arrays by their type and output.

Learn how slicing an array in Go ties the slice to the array and how appends can modify the array until capacity is exceeded, then allocate a new array.

Iterate over arrays and slices in Go using the for range loop, accessing index and item to perform actions like printing each element.

Explore arrays and slices in Go, with zero-based indexes, comparing fixed-length arrays to slices that can grow, and learn how append and make manage length, capacity, and underlying arrays.

Combine multiple conditions into a single if statement in Go, using and operators to enforce happy hour, membership, and order amount for a 30% discount.

Explains how Go allows an initializer after if, using short variable declarations, function calls, or increments before the condition, with scope limited to the if block.

Explore infinite for loops in Go, the break to exit and continue to skip to the next iteration, and how to read terminal input with Scanln.

Master for range loop control in Go by applying break and continue to skip expired milk and stop at matcha, using a drinks slice and println statements.

Explore Go control flow with if, switch, and for statements, including conditionals, blocks, and nests, plus initializers and switch behavior. See for range, break, continue, and placeholders in loops.