A Sweet Bootcamp on Golang - 8 hour bootcamp

install go on windows by downloading the installer from the official site, running the setup with default settings, and verifying the installation in the command prompt.

Learn how integrated development environments simplify Go programming, set up Visual Studio Code with the Go extension, and compare it with GoLand for easier debugging and coding.

This lecture guides Linux installation of Go, downloading and extracting the package, configuring GOROOT and GOPATH, setting up a Go workspace, and verifying the setup.

Create a Go project with a proper folder structure, define a main package, and implement func main that prints hello world to the console.

Learn how to create a portable Go executable by building with go build, which bundles dependencies into a single file you can run on another machine without installing Go.

Explore variables by type, including integers (32- or 64-bit, signed or unsigned) and floating-point, with architecture-dependent sizes, plus strings in double quotes, utf-encoded Unicode, booleans, and complex numbers.

learn how to define variables in Go, including global and block scope, using the core keyword; observe values such as 0 for int and empty strings, and assign custom values.

Demonstrates shorthand variable declarations in Go, using type inference, declaring multiple variables per line, and highlights compiler errors when variables are declared but unused.

Explore compounded variable declarations in Golang, including shorthand and single-line multi-variable assignments. The left-side rule requires one new variable; remove the colon to fix the error and print results.

Explore how to define complex variables in Go, use shorthand notation like 1+2i or complex() to create complex numbers, and work with their real and imaginary parts.

Discover arithmetic operations on complex numbers in Golang, including adding and multiplying complex numbers, and printing the results with new variables.

Learn how Go handles type conversions between int32 and int64, resolve mismatched types by casting, and perform safe arithmetic in Go.

Declare constants in Golang, print their values, and observe the error when attempting to reassign a constant.

Explore how global variables are accessible across functions in Go and how local variables defined in main are not accessible elsewhere. Understand scope and accessing undefined identifiers in printing.

In this lecture we focus on integer operations, placeholders, printing with printf, newline management, and how integer division truncates, contrasted with using float types for precise results.

Explore Go packages by explaining executable versus non-executable types, how to build and import library packages, and why the main function serves as the entry point for applications.

Build a geometry package in Go, define return types and the area function, then call it from a main executable to compute a rectangle's area.

Identify how to export variables in Go by naming them with a capital first letter and accessing them from other packages via import and a main function.

Explore conditionals and control flow in Golang, learning how if statements, for loops, and switch cases decide execution paths with default cases.

Explore if conditionals in Golang by comparing two numbers, using else and nested if blocks, and printing results to demonstrate true and false branches.

Learn how to initialize a variable, use an if condition, and check even numbers with modulo in Go, using 9 and 10 as examples and printing results.

Switch over an int option with cases 1 and 3 to trigger actions like go running, go jogging, or push ups, using a default and initialization for unmatched values.

Discover how conditional switches in Go use variables number one and number two, cases with logical operators, and a default path to handle unknown input values.

Explore loops in go, including for loops, while-like patterns, and infinite loops, with loop anatomy—initialization, condition, and post—plus break and continue control, and iterating over strings and arrays with range.

The lecture demonstrates the structure of a for loop in Golang, highlighting initialization, condition, and increment, and shows printing values from 1 to 9 with a continue to skip iterations.

See how a for loop prints values from zero to ten with a less-than-or-equal-to condition, and how break stops the loop when i reaches seven, printing 'loop is broken'.

Go implements the while loop as a for with initialization, condition, and post steps, and demonstrates accumulating a sum with sum += sum until it reaches 128.

Explore nested loops in Go using an outer i loop, and an inner j loop, printing with a format placeholder on one line and inserting a newline after each row.

Learn how to create an infinite loop by omitting initialization, condition, and post statements, and observe it run until interrupt. Use cases include waiting for user input or server connections.

Learn how to declare and manipulate arrays in Go, including fixed-size arrays, zero-valued elements, accessing by 0-based index, updating elements, and printing results.

Access elements by index in a fixed-size Golang array, print specific elements, handle out-of-bounds errors, and replace values to see how assignments update the array.

Master the shorthand array declaration in Go by listing values in braces and indexing from zero. Use ... to let the compiler count elements automatically.

Explore how in Go, the size of an array is part of its type, so arrays with different lengths have different types and cannot be added together.

Learn what value types are and why copying a variable and modifying the copy leaves the original unchanged, illustrated with an array example.

Learn how to pass an array to a function in Go, define inputs and outputs, and return a modified array while honoring the array size.

Learn how to use the range operator in Go to iterate over arrays and strings, access index and value, print them, and ignore the index with an underscore.

Learn to iterate over two-dimensional arrays in Go with nested loops, printing outer indices and inner content to traverse each entry.

Explore how slices in Go represent a subset of an array, with start inclusive and end exclusive, acting as references that modify the original array.

Learn how to write a function in Go, define input parameters, return a value, and compute and print the average of two numbers.

Learn how exportable and non-exportable packages work by importing a geometric package and using exportable functions like EDI, with capitalized names signaling exportability and demonstrating that non-exportables are not accessible.

Understand how to return two values from a function, assign them to sum and difference variables, and optionally ignore unused values.

Learn how to implement variadic functions in Go by defining a sum function that accepts any number of float inputs, iterates over them, and prints the total.

Discover how to create anonymous functions, assign them to variables, and invoke them with input such as a user name to produce inline, named-like behavior.

Discover how maps store key-value pairs in Go, create them with make for integer keys and string values, and understand that maps are unordered and initially empty.

Learn to create maps with string keys and integer values in Go, including inserting, updating, and accessing entries via hash lookups. Iterate with for loops; map order is not guaranteed.

This lecture shows how to add and remove entries in a Go map using make and delete, then print the map to compare counts before and after deletion.