Golang Developer Course in 2024

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

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.

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 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.

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.

Discover that the zero value of a Go slice is nil, with length and capacity zero and no 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.

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 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 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.

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 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.

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.

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 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 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.

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.

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

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.

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.

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.

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

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.

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.

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.