Golang Developer Course in 2024

Begin the Go course by creating a hello world program, then initialize a go.mod file to manage dependencies and ensure reproducible builds with explicit module versioning.

Learn how to initialize a go.mod file, create a hello.go program, and print hello world by importing fmt and using the main function.

Run your go program from the terminal with go run to print the Hello World string, and use go help to list available commands.

Master the fundamentals of Go by exploring packages, variables, functions, data structures, struct slices and maps, flow control, methods, and interfaces to answer interview questions and advance your programming career.

Explain how Go programs are built from packages, start with the main package and main function, import fmt and rand, and generate random numbers.

Compare import styles for Go packages to understand how import fmt and import math work, and learn why reducing imports can be acceptable.

Learn the basics of functions in Go by creating a simple add function with two integer parameters. The type comes after the variable name, and the return value is specified.

Explore a Go function parameter optimization by omitting repeated types when consecutive parameters share a type, and verify with an example that sums six values to 21.

Discover how Go functions return multiple results, demonstrated by a swap function that outputs swapped strings and prints the computed a, b, c values.

explains named return values and naked returns in Go, showing how naming x and y lets the function auto-return without explicit return statements, with caveats about readability in longer functions.

Explore how the var statement in Go declares single or multiple variables, with types after names, inside package or function scopes, and see examples using booleans and integers.

Learn how to initialize variables in Go using initializers, infer types from the initializer, and declare one variable per initializer with booleans, strings, and integers.

Discover the colon equals operator for short variable declarations in Go, enabling implicit typing inside a function, replacing var, and excluding package-level use with practical examples.

Learn how format specifiers %t and %v print a variable's type and value, with string and int examples shown in the print f format for Go development.

Variables without an explicit initial value receive their zero value. Zero value means 0 for numeric types, false for booleans, and an empty string for strings.

Learn how to declare constants in Go using the const keyword, covering numeric, string, and boolean values, and note they cannot use the colon equals syntax with pi and world.

Review the core building blocks of Go, including packages, imports, exported names, functions, variables, and constants, with emphasis on zero types, basic types, and type inference.

Explore flow control statements, including for loops, if else statements, switch statements, and deferring stacking, as a core part of the fundamentals.

Master the Go for loop in this deep dive, exploring its three components—initial statement, condition, and post statement—while building sums, printing results with fmt, and distinguishing for from while loops.

Learn how if else statements evaluate conditions in go, using a square root function with fmt and math to handle nonnegative inputs and imaginary results for negatives.

Learn how short statements precede if statements in Go, declaring scoped variables inside the block and returning either the computed value or a limit in a power function example.

Explore Go switch statements as a concise alternative to if-else, with automatic breaks and non-integer case values. See an OS variable switch on Darwin, Linux, and a default Windows example.

Learn how switch statements without a condition (switch true) act like a clean, less verbose alternative to long if-else chains, demonstrated with time-based cases for morning, afternoon, and evening.

Explain how the defer statement defers a function's execution until the surrounding function returns, with arguments evaluated immediately, as shown by printing hello before world.

Explore how deferred function calls form a stack and execute in last-in, first-out order, illustrated by pushing 0–9 and printing in reverse.

Master Go flow control by covering for loops with init, condition, and post; if and else with short statements; switch with and without conditions; and stacked defer statements.

Explore the fundamentals of Go data structures, focusing on structs, slices, maps and pointers, and cover race alongside data manipulation and algorithms powering Go programs.

Explore Go arrays as fixed-length types, where length is part of the type, and see how to declare, initialize, and loop 1d and 2d arrays with i and j.

Explore slice literals in Go by creating slices directly without a count, and compare them to arrays. Build slices of booleans, integers, and structs and print them.

Learn how slice boundaries work in Go: omit low or high bounds to default to zero and length, enabling whole-slice or partial-slice creation.

Explore how Go slices expose length and capacity, where length is the number of elements in the slice and capacity counts the underlying array, demonstrated through a print slice example.

Discover that the zero value of a Go slice is nil, with length and capacity zero and no underlying array.

Learn how the Go make function pre-allocates slices by specifying length and capacity. Create slices with differing length and capacity to control the underlying array.

Explore multi-dimensional slices in Go by creating a 2d board with slices of slices. Learn to index, update, and print the grid to simulate a tic tac toe game.

Learn how to append elements to a Go slice using the append function, observe changes in length and capacity, and add single or multiple values.

Discover how range loops iterate over slices (and maps) in Go, returning index and value, enabling you to loop without known length and simplify code.

Explore for range loops over slices and maps, showing three ways to access index or value, using underscores to skip values, and noting you cannot use underscore as value.

Explore the map data structure in go, learning how keys map to values for fast constant-time lookups, why maps start nil, and how to initialize with make.

Create and work with maps that map strings to custom structs, using a vertex struct with lat and long, initializing with make, and printing map entries.

Learn why map literals require explicit keys when using vertex structs, and how to print maps. Compare map literals to struct literals and remember keys are always required and vary.

Learn how to omit the top-level type name in map literals when the type name is the same as the element type, and how this affects key usage.

Learn to create and manipulate maps in Go by inserting or updating elements, deleting keys, retrieving values, and testing key presence, while understanding zero values for missing keys.

Learn to test map key presence in Go with the two-value assignment (value, ok), returning the element and a boolean that signals presence, and note the zero value when absent.

Explore pointers, structs, arrays, slices, and maps in Go, learning how to read the value pointed to by a pointer, create slices with make, and mutate maps via range.

Explore closures in this Golang developer course section, where the instructor presents closures as a complex topic and guides you toward understanding by the end of this section.

Learn how functions are values in Go by passing and returning functions, using a compute helper with hypotenuse and power examples to prepare for closures.

Explains closures as function values that capture and modify variables outside their body. Demonstrates with an adder that returns a closure binding to a captured sum, showing separate instances.

Explore closures in Go by implementing a Fibonacci function that returns a closure delivering successive numbers 0, 1, 1, 2, 3, 5 and how a function value references external variables.

Explore how fibonacci numbers arise from summing the previous two values, starting at zero and one, and implement a Golang function that returns a closure producing the sequence.

In this video we implement a fibonacci function with closures in Go, returning a function that yields fibonacci numbers by updating a, b, and a temporary c, then printing.

Explore closures in Go by building fibonacci generators that return functions, create independent f and g sequences, and observe alternating execution producing the 0011112233 pattern.

Rewrite a function to return a closure and demonstrate passing that function as an argument, printing values and their pointer addresses to illustrate closures in Go.

Demonstrate closure capturing in Go by placing functions in a slice; all closures reference the loop variable and print four, highlighting a common issue to fix in the next video.

Rewrite the absolute method as a function without changing functionality. Remove the receiver argument and access x and y from vertex v, then call the new function.

Declare methods on non-struct types by defining custom types like my float64 and attaching receiver methods such as absolute. Illustrates converting negative values to positive using the absolute method.

Explore pointer receivers for methods in Go, using a vertex struct and a scale method. Compare with value receivers and learn why pointers enable mutation.

Rewrite the absolute and scale methods as functions to compare pointer receivers with value receivers, using a pointer to v, and show that only a pointer argument mutates the value.

Explore pointer receivers in Go and how Go automatically handles pointers in methods. Compare with functions that require a pointer argument, demonstrated by scaling a vertex.

Explains how value and pointer receivers differ in methods, shows that methods can accept values or pointers, while functions must receive a value, illustrated with absolute method and function.

Learn how interfaces in Go are defined as a set of method signatures, and how any type implementing them—like dog and cat—becomes an interface value.

Explore how interfaces in go define method signatures, implement them with dog and cat types, and use a slice of animals to print speed and jumping behavior.

Discover how Go interfaces are values paired with a concrete type, see their under-the-hood behavior, and watch methods like speak run on dog and cat types.

explains how interface values hold a concrete type and value, and how nil concrete values are handled with a nil receiver, using a t struct and M method.

Explore how nil interface values hold neither value, nor concrete type, causing runtime errors when invoking methods without a concrete type, and contrast with concrete types from the last video.

Explore the empty interface, a zero-method interface that can hold any type. See how it enables code handling unknown values with fmt.Println and a describe function.

Explore type assertions for empty interfaces to access the underlying value in Go. Use the two-value form (value, ok) to test types safely and avoid panics.

Learn how type switches extend type assertions in Go, using a do function to handle int, string, boolean, and default cases via an interface.

Learn to implement the fmt stringer interface in Go by defining a String() method on a type (value or pointer receiver), enabling custom, formatted string output when printing.

Create a four-byte IP address type, implement its string method to satisfy the stringer interface for dot-decimal formatting, map hosts to IP addresses, and print them using range.

Explore implementing the error interface in go by building a custom error type with time-stamped messages, using a pointer receiver, and returning it to print descriptive errors.

Implement a custom error type for a Go square root function, returning zero and a tailored error for negative inputs, and reinforce how the error interface and string method work.

Learn the io reader interface and its read method, using strings.NewReader to fill a byte slice, track n and err, and handle io.EOF when end of the stream is reached.

Implement a custom reader type that satisfies the reader interface by defining a read method. Expose my reader type by emitting an infinite stream of the ascii character a.

Explore Go interfaces through a dog example, comparing value and pointer receivers, and nil underlying values. Learn type assertions, type switches, and implementing stringers for IP addresses.

Build a modular Go project by creating a library package and a caller program that calls the library's functions, showcasing how separate packages interact.

Initialize the project by creating a greetings library package with go mod init, using an existing or fresh directory, and confirming module path example.com/greetings and go version 1.16.

Create a go program by initializing go.mod, importing fmt and the greetings package, and implementing main to call greetings.hello with 'Gladys'.

Spot the missing print logic by printing the message with a print line, then plan to add the required module next video to enable the greetings package hello function.

Enable the greetings package with a command, apply a replace directive to link to the local greetings directory, then import and use the package's functions.

Run go mod tidy to synchronize the example.com hello module dependencies, updating go.mod with a pseudo version number and a required directive for example.com/greetings in the greetings directory.

Fix syntax errors in a multi-module Go program by declaring a function, importing fmt, and using fmt.Sprintf and fmt.Println to print a greeting from greetings package via the hello function.

Extend the Golang course multi module section by adding error handling to the greetings function, importing an error package, and returning an error message when the name is missing.

Import the errors package and use errors.new to signal an empty name, returning a string and an error; when a name is provided, return the message with nil error.

Learn to log errors in go by setting a greetings: prefix, disabling time stamps, and using log.Fatal for errors returned from greetings.go, with updated error handling in hello.go.

Learn how to build a random format function that returns a different greeting by using a random module and a time module, selecting from a slice of greetings.

Learn how the Go program seeds the math/rand package with time.Now in an init function, using a nano time format to enable randomness at startup.

Seed the random package and create a random format function that returns a greeting from a formats slice using intn, then connect it to the hello function.

Hook the hello function to the random format function, using a seeded random number to choose one of three formats and replace %V with the name via Sprintf.

Modify the logo to show the name Gladys, run the program in the terminal, and generate random greetings each time the function is called.

Create a hellos function as a parent that calls and reuses the hello function to return a map of names and greetings for inputs, producing different greetings for each name.

Implement hellos in Go, taking names as a slice and returning a map and error. Initialize a messages map with make and prepare to use the hello function.

Expand the hellos function to loop over the names slice with range, call hello for each name, populate a messages map, and handle errors by returning nil and the error.

Learn to call the halos function using a names slice in the logo file, print results to the console, and handle errors when switching from hello to hellos.

Run the program after creating it using the hello function to verify output, observe a map being produced, and confirm the function is working.

Explore go testing, learn to write tests with the built-in testing package, and run them using go test and go test -v.

Create a greetings_test.go for the greetings package, importing testing and regexp, and implement two tests validating a valid name and an empty name error.

Write Go tests by creating two functions that start with the word test, accept a *testing.T, and validate greetings using a Gladys name with regular expressions.

Navigate to the hello directory, build with go build, and run the executable with ./hello or hello.exe; this section shows creating hello.go in the main package and printing greetings.

Build a Go web service with the Gin framework to manage albums using a slice data store and structs, with get and post endpoints.

Create folders and files for a Gin web service, initialize a Go module with go mod init, and set the module path and Go version (1.20+).

Set up a Go web API with a main package, router, and an albums data structure, run the server, and fetch the seeded albums data via curl on /albums.

Learn how to implement a post request to add a new album to the albums slice using Gin, bind JSON data, and return the created album with status 201.

Learn to test the post albums service with Postman by sending a post to localhost:8080/albums and then a get to verify results, including a JSON body and response statuses.

Implement get album by ID endpoint in Go using Gin, matching the ID path parameter to return the album or a 404 not found.

Connect the router to an albums by id route by adding a /albums/:id path, destructuring the id, and invoking get album by id to return the album or not found.

Test the full service by running go run ., stop with Ctrl+C, and use Postman to create and fetch albums while monitoring requests in the terminal.

Wrap up by reviewing how we built a full albums web service in Go, using a slice, a router, and get and post endpoints to access and create albums.