Go Fundamentals Video Training

A thorough introduction to Golang, the Go programming language. Based on author Mark Bates's and Cory LaNou's pioneering Gopher Guides training curricula, these videos enable you to quickly understand and use Go syntax, core features, and idioms. Go Fundamentals LiveLessons prepares you to write robust, reliable, well-performing production code right from the outset.


4.5 Hours of Video Instruction


$239.99 USD

Buy Now!

Target Audience

  • You have little to no Go experience.
  • You have a current or upcoming project that will be written in Go.


  • Familiarity and comfort navigating and basic file manipulation at the command line.
  • Familiarity and comfort with a modern code editor, including creating and modifying files and projects.
  • You have at least 6 months of experience with other modern development languages such as Java, C#, Swift, JavaScript, Python, Rust, etc.
  • Familiarity with basic programming concepts and structures such as variables, loops, conditionals, etc.
  • Computers should be capable of modern software development, such as access to install and run binaries, install a code editor, etc. Full instructions referenced here: preparing your environment for Go development. It may be necessary for them to have root/admin access to their computer.

Recommended Preparation

  • Install and configure an editor for Go.
  • Sign up for a Github account if you don't already have one.

Learn How to:

  • Manage packages, modules, and dependencies
  • Apply Golang basics, such as variable declaration, types, and control flow
  • Work effectively with collection types, iteration, functions, structs, and pointers
  • Understand Go Slices and use them properly
  • Write idiomatic Go, using principles such as embedding and composition
  • Expertly use concurrency to improve code performance
  • Create proper tests to quickly identify and fix problems
  • Write simpler, better code with generics and interfaces
  • Take advantage of channels, context, sync primitives, and other advanced features

Course Details

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.
Subscribe to our newsletter