Explore section 2 language fundamentals, including writing the first Go program, program types, keywords, primitive data types, lexical elements, operators, and variables; review Unicode UTF-8, printing verbs, and scope.

Write your first Go program in Visual Studio Code, using package main and fmt to print hello world. Run with go run or go build, and note executables versus libraries.

Explore Go's basic data types, including unsigned integers, rune, floats, complex numbers, bools, and strings; learn camel case naming, declarations vs assignments, and zero values.

Explore Go's variable declarations—explicit var, short form, and default zero values—plus multi-variable assignments and value swaps. Learn constants, literals, tokens, and basic operators alongside printf-style verbs for practical Go programming.

Explore new variable types in Go, including an unsigned int 8 and the default float64, learn printing with %f, and compare integer versus floating point division and simple increment operations.

Explore Go string handling, including the length function, zero-based indexing, and retrieving the fifth character with ASCII representations. Practice substring operations, plus operator concatenation, and the immutability implications.

Explore bitwise operators in Go, formatting unsigned integers in octal and hexadecimal with flags, and explain why negating unsigned values requires signed casting.

Explore utf-8 encoding in go by examining a four-byte Chinese character, iterating bytes, and printing them in decimal, octal, and hex, plus using escape sequences to reconstruct the character.

Explore utf8 part 6 by building a rune slice from a string with a for range loop and append, then use explicit conversion and print the runes to illustrate slices.

Explore Go arrays and slices: static, homogeneous arrays with fixed length and zero-based indexing; use ... to create dynamic slices, while maps remain dynamic and future sections cover structs.

Explore arrays in go by comparing array values to regular integers, observing zero values, using len to measure length, and iterating with range and for loops.

Explore Go slices and arrays through practical examples, including creating arrays and slices, slicing strings, appending with ellipses, and understanding capacity and underlying arrays.

Apply advanced slice techniques in Go: create slices with make, inspect length and capacity, copy and append elements, and flatten a slice of slices into a single slice.

Explore comprehensive slice operations in Go, including appending, copying, and slicing to merge and rearrange data. The examples demonstrate practical techniques for manipulating int slices in Go.

Learn hash tables and maps in Go by using the make function to create maps, add and remove elements, and search maps, including practical examples with Unicode code points.

Explore hash tables by turning three-character strings into unique keys using ascii codes and a weighted sum. See a non-optimized example and a prompt to generalize beyond three characters.

Explore how maps in Go manage key-value pairs, including insertion, lookup, deletion, and overwriting, while noting that keys are unique and the map order can vary between runs.

Explore practical go maps and slices by removing duplicate words from a slice using a string-to-bool map, and by mapping languages to extensions and time zones with lookups.

Count distinct unicode code points by converting a string to a rune slice, build a map[rune]int, and compare string length with rune count to reveal multibyte characters.

Explore how functions in Golang map inputs to outputs, declare with func, define parameters and return values, and call simple functions from a main program.

Explore functions and stacks in Go by examining local versus global variables, how values are passed by copy, and how scope and lifetimes affect access across f1, f2, and f3.

Explore variadic functions in Go by summing numbers, using ellipses to accept a variable number of int parameters, and comparing variadic calls with slice spreads.

Explore pointers and slices in Go, inspect addresses, dereference pointers to access slice elements, and understand sub-slices and memory layout.

Explore Go function literals and closures, showing how an inline function captures outer variables and returns an int, and how a function can return another function (functions as return types).

Explains closures in Go as functions declared inside another function that capture and preserve the surrounding state. Demonstrates add-by and multiply-by closures using evolving internal state.

Create a player struct with name and age, explore pointers to that struct, dereference with * to read and modify fields, and print pointer versus value forms across examples.

Explore how Go has no classes, uses structs and receivers to define methods, and attach functions as methods to struct types.

Export structs and fields in Go, attach methods with receivers, and organize code into packages. Build a library with a Player type and import it into an executable.

Explore interfaces in Go, covering fundamental concepts, the MT interface, and type assertions. Practice conversion typecasting, narrowing and widening, and using sort and strings functions like reverse ints in code.