Master Go Programming (Golang): Complete Bootcamp

Explore the Go playground, a web service on Google servers that lets you write, compile, and run Go code in a sandbox, with automatic imports and formatting via gofmt.

Install Go on Windows, set up Git for Windows and Visual Studio Code with the Go extension, then configure Bash and install Go tools.

Discover how to organize Go code using a workspace and Go path, while embracing modules. Create a Master Go Programming workspace with src, pkg, and bin, and learn go env.

Explore the structure of a go application, including package main, the main function, imports, and typical declarations, then run the program from the terminal or vscode.

Learn how to compile and run go programs with go run and go build, using GOOS and GOARCH for other operating systems, and using -o and go install.

Format go source code with gofmt to create an idiomatic, readable style. Run it from the command line or in editors like VSCode, using -w and -l flags.

Explore variables in Go, learn how to declare with var or the short := operator, understand type inference, and how unused variables and the blank identifier affect compilation.

Learn to declare multiple variables with short declarations and the var keyword, handle redeclaration errors, mute errors with _, perform swaps, and use expressions in short declarations.

Explore Go's statically typed system, including type inferring, compile time type checking, and safe conversions between int and float, plus the zero values for numeric types, bool, string, and pointers.

Learn to write clear Go comments that document code, using // for line comments and /* */ for block comments. Comments do not execute, and help developers read intent.

Learn Go naming conventions to improve readability and maintainability, including idiomatic camel case, avoiding underscores, using exported identifiers, and proper acronym capitalization.

Explore the go fmt package using Println and Printf to format strings, numbers, and booleans with verbs like %d, %f, %s, and %T, plus escaping and base conversions.

Explore how constants in Go represent fixed values, declared with const, evaluated at compile time, preventing runtime errors; learn grouped constants and behavior in expressions.

Discover how Go constants cannot be reassigned or runtime-initialized, and why only built-in or literal arguments like len can initialize constants at compile time.

Learn the differences between typed and untyped constants in Go, including compile-time constant expressions and type inference, and see how untyped constants enable operations with mixed types.

Explore how Go's iota creates successive constants starting at zero, demonstrates automatic increments, stepping by two, and skipping values with the blank identifier using practical examples.

Explore Go data types, from predeclared and composite types such as array, slice, map, struct, pointer, function, interface, and channel, to int8–int64, uint variants, rune, byte, bool, string, and floats.

Master Go composite types by exploring arrays, slices, maps, and structs, and learn about pointers, function types, and memory addressing in Go. Interfaces and channels are introduced for future study.

Explore Go operators across arithmetic, assignment, and string concatenation. Note increment and decrement are statements, not operators, and observe operator precedence.

Explore Go's comparison operators—equal, not equal, less, less or equal, greater, greater or equal—using a and b = 5 and 10, boolean results and short-circuit evaluation of and, or, not.

Learn how Go handles integer overflow and underflow, including wraparound at runtime and compile-time constant overflow, and show float32 overflow to infinity; consider the big package for arbitrary precision numbers.

Master converting numeric values in Go using explicit conversions, handling int and float64, and learning how type inference and mismatched types require deliberate conversions.

Learn how to convert numbers to strings and strings to numbers in Go using fmt.Sprintf. Explore ParseFloat, ParseInt, Itoa, and Atoi for string to number and number to string conversions.

Explore defined (named) types in Go, where a new type has its own name and an underlying type, not an alias, with conversions allowed between common underlying types.

Define named types with the type keyword to gain type safety and readability and to attach methods. Convert between defined types like speed, km, and mile using explicit casts.

Learn alias declarations in Go, using type T1=T2, contrast with defined types, and see how byte with uint8 and rune with int32 behave without type conversions.

Master how if, else if, and else statements in Go enable decision making by evaluating boolean conditions and executing the appropriate code blocks.

Learn to read command line arguments in Go using the os package and os.Args, access arguments by index, and convert string arguments to float with strconv.ParseFloat.

Explore simple statements and short if statements in go. Learn practical error handling with strconv.Atoi and process command line arguments via os.Args, including type conversion and printing.

Master Go programming's for loop by understanding its three parts—initialization, condition, and post statement—and see how i := 0, i < 10, and i++ print 0 through 9 with fmt.Println(i).

Go lacks a while keyword, but a for loop can act as a while by omitting init and post statements. See an infinite loop example and a VSCode warning.

Explore how the continue statement in Go skips the rest of the for loop iteration and returns to the top of the loop, demonstrated by printing even numbers under 10.

Discover how the break statement terminates the innermost for or switch in Go, shown via a loop that prints numbers divisible by 13 until ten numbers are found.

Learn how label statements in Go target outer loops with break, continue, and goto, illustrated by arrays, range iteration, and printing.

Explore how Go to statements transfer control to labeled points within the same function, enabling loops, while noting restrictions on jumping past new variable declarations and the discouraged usage.

Explore how the go switch statement compares to if statements, how cases and default work, auto breaks, and how switch true forms create readable, condition-based code with practical examples.

Explore Go scopes to understand visibility and variable lifetime across file, package, and block levels, including import aliases, shadowing, and the blank identifier.

Explore go arrays and slices, comparing fixed-length arrays to dynamic-length slices stored contiguously. Understand how the type and length define an array, with [3]int and [4]int examples and zero initialization.

Learn to declare arrays in Go with literals, explicit lengths, partial initializations, and the ellipsis operator, plus using len to report array size.

Modify a fixed-length array by indexing, preventing out-of-bounds access, and practice iteration with range and for loops. Explore multi-dimensional arrays and how copy semantics differ for arrays and slices.

Explore arrays with keyed elements in Go, using composite literals to assign specific indices and letting unkeyed elements auto-increment. See how zero values fill skipped positions and print results.

Discover how go slices differ from arrays, with dynamic length and a nil zero value for uninitialized slices, while both store elements in a composite type.

Learn how to declare and manipulate slices in Go, including nil slices, slice literals, the make function, indexing, iterating, and common errors like index out of range.

Learn to compare slices in Go by iterating elements with a for loop, using eq, and checking lengths with len(a) != len(b), since slices can only compare to nil.

Learn to append to a slice with the built-in append function, which returns a new slice, and copy slices with copy, which copies up to the smaller length.

Master slice expressions in Go by slicing arrays, slices, and strings to create new views without modifying originals, including defaults for missing bounds and append usage.

Explore how Go slices reference a hidden backing array through a slice header with address, length, and capacity, and see how slicing shares that backing array and propagates changes.

Learn how Go slices share a backing array, how the slice header governs them, and how append creates independent slices. Explore length, capacity, and memory size with examples.

Explore how Go slices grow with append, tracking length and capacity as the backing array expands. See nil slices with zero length and capacity, and use slice expressions.