Go Fundamentals Video Training

Lesson 1: Packages, Modules, Dependencies

Lesson 1 discusses packages, modules, and dependencies. The lesson begins with Go modules and then digs into Go packages. Next comes how Go files and folders are named and organized. You then learn how to import third-party packages and modules into Go projects. Finally, you learn how to manage those third-party packages.

Lesson 2: Go Language Basics

Lesson 2 explores the basics of the Go language. You learn topics such as variable declaration, the type system, built in data types, and printing and formatting of values. While some of this material might be familiar to you already, proper understanding of these basics is necessary to get the most out of the Go language.

Lesson 3: Arrays, Slices, Iterations

Lesson 3 covers arrays, slices, and iterations. First, you learn about the built-in list types, arrays, and slices. Then the lesson turns to how slices work. Finally, you learn how to iterate over collection types such as arrays and slices.

Lesson 4: Maps and Control Structures

Lesson 4 presents maps in Go. You learn how to declare, initialize, and use maps. You learn that maps need to be initialized before they can be used, and you learn how to check for key existence, how to delete a key, and how to iterate over a map. Finally, after you have learned about maps, the lesson turns to built-in control structures, such as if else and switch statements. With this and the previous videos you have now covered the most basic data types, operators, keywords, functions, and control structures in Go. With this knowledge, you can now begin to delve into more interesting and fun topics. If at any point you start to feel lost, the answers are most likely in this or the first three lessons.

Lesson 5: Functions

In Lesson 5 you are presented with a core part of any language: functions. Go functions are first class citizen and can be used in many ways. First, you learn how to create functions using the func keyword. Then you learn how to handle inbound arguments and return values. Finally, you are exposed to advanced function topics such as variadic arguments, deferring functions, and the init function.

Lesson 6: Structs, Methods, and Pointers

Lesson 6 delves into structs, methods, and pointers in Go. It covers definition, initialization, and usage of structs. It also covers struct tags and their use for operations such as encoding and decoding JSON. Next, you learn adding methods to types. Finally, the lessons finish with pointers and how they can be used to avoid copying data as well as how they enable us to allow others to mutate data.

Lesson 7: Testing

Testing in Go, as in any language, is a subject worthy of its own set of videos. Covering all the various topics such as benchmarking, example tests, and design patterns is, unfortunately, outside the scope of this lesson. In this lesson, you get the fundamentals of testing and Go, including writing, running and debugging tests. The lesson also covers table-driven tests, test helpers, and code coverage.

Lesson 8: Interfaces

Interfaces in Go provide a way to specify the behavior of an object. If somebody can do this, then it can be used here. In this video, you learn how to use interfaces to abstract behavior. Concepts such as the empty interface, satisfying multiple interfaces, and asserting behavior are also covered.

Lesson 9: Errors

Lesson 9 covers the benefits of how goals error model results in more reliable code. It presents how to handle basic errors and return errors as an interface that satisfies the error type. Additionally, concepts such as custom error types, panics, recovering from panics, and wrapping and unwrapping errors are also covered.

Lesson 10: Generics

In Lesson 10 you learn about generics in Go. You learn what generics are and about type constraints and how to define them. You learn how to deal with underlying type constraints, and then finally, you learn how to make generic types.

Lesson 11: Channels

Lesson 11 starts to explore concurrency in Go with channels. You learn the differences between parallelism and concurrency, and you learn how to use Go routines and channels to achieve concurrency. You learn about channels and how they can be used to communicate between and control Go routines. You learn the differences between buffered and unbuffered channels and when each one will block and unblock. Finally, you learn how you can use channels to listen for system signals so you can gracefully shut down your applications.

Lesson 12: Context

In Lesson 12 you learn about contexts and Go. You learn about context values, how context can be used for cancellation propagation. You also learn how to deal with errors that result from your cancellation of contexts.

Lesson 13: Synchronization

Lesson 13 presents just a few of the synchronization types and functions in Go. First, the lesson explores how to use a wait group to wait for a number of Go routines to finish. Then you learn how to use an error group to wait for a number of Go routines to finish and return an error if any of them failed. Next, you learn how to use a mutex and a read-write mutex to synchronize access to a shared resource. Finally, you learn how to use sync once to ensure a function is only executed one time.

Lesson 14: Working with Files

Working with files is a very common task in computer programming. We work with log files, HTML files and a whole host of other file types in our programs. In this lesson, you learn how to read and write files, walk directories, and use the FS package. Finally, you learn how to embed files into our Go binaries, creating a truly self-contained application.