Learn Go in 3 Hours

Programmers new to Go won’t be familiar with the structure of a Go program.
This video shows a non-trivial Go program looks like, runs it, and then does a brief walkthrough of the code.

• Write a Go program and learn how VS Code works
• Run your Go program and interact with it
• Walk through the parts of a Go program

Go provides multiple ways to declare variables. 
This video walks through the three different styles of variable declaration in Go.

• Learn about the var keyword and type inference
• Learn about the := operator and when to use it
• Discuss about the zero value for variables and unused variables

Go provides a rich set of built-in numeric types that behave differently than numbers in other languages.
This video covers the primitive numeric types in Go, how to declare them, and how to convert between them.

• Explore the integer numeric types
• Learn about floating point types
• Discuss about Booleans, type conversions, int and byte

Go has built-in string and array value types, and a character type called a rune. These are different than the implementations in other languages.
This video covers how to work with strings and arrays, and the relationship between strings, bytes, and runes.

• Learn about the string type and string literals
• Iterate and slice the bytes in a string
• Learn about arrays in Go

The if/else statement is present in many languages, as is the for statement. Go provides a unique twist on both.
This video covers the if/else and for statements in Go, how they are both similar and different to the same statements in other languages.

• Learn about the if/else statement in Go
• Learn about the for statement in Go
• Learn about the for/range statement in Go

The switch statement in Go is far more powerful than the similar statement in Java or C.
This video covers all of the features of the switch statement in Go.

• Discuss the basics of the switch statement
• Learn about fallthrough, multiple case values, and empty cases.
• Look at the default values and empty switch statements

Functions are central to Go.
This video shows the user how to declare and use functions in Go.

• Write a function and invoke it
• Declare function input and output parameters
• Learn about call-by-value and how it works in Go

Beyond simple function declarations, there are many more things you can do with functions.
This video shows how functions are treated like values in Go, with functions declared inside of functions, closures, and passing them in and out of functions.

• Assign a function to a variable
• Learn how and why you pass a function to a function
• Discuss about closures and returning functions from functions

Go unabashedly embraces the pointers, while removing their most dangerous abilities.
This video walks through using pointers in Go, and how they can be used to simulate call-by-reference in other languages.

• Learn that pointers in Go exist, but aren’t that scary
• Declare pointers and learn how to use them
• Learn what passing pointers to functions allows you to do

Go uses packages to organize source code and import statements to declare access to code in other packages. 
This video covers how packages and import statements work and gives a quick walkthrough of the standard library.

• Learn about packages in Go
• Learn about the import statement in Go
• Discuss some of the standard library packages in Go

Packages aren’t just for the standard library. Well-structured Go programs also use package for organization. 
This video covers how to break up your program into different packages and how to import these packages.

• Make your own packages
• Learn about making variables, types, and functions public or private
• Discuss about common package errors like cycles and unused packages

Programmers can’t write all of the code by themselves. They also need to depend on code that’s written by other developers.
This video covers third-party packages in Go, how to use code created by other people, and how to make your code available to other people.

• Use a third-party package
• Manage dependencies
• Publish your own third-party package

Programs can’t only be built out of simple types like ints and strings. You also need types that can contain other types.
This video covers slices and maps, two built-in generic types in Go that contain other types.

• Learn about slices
• Learn about maps
• Learn about the behavior of reference types and nil slices and maps

In addition to slices and maps, you also need structures to build data types with multiple different values that are associated with each other.
This video covers structs, Go’s way to allow users to define types that contain multiple different types.

• Create structs
• Learn about struct embedding
• Learn about struct tags

One object-oriented programming concept that has been very useful is the method, which tightly couples data with the code that processes it.
This video covers Go’s support for methods and how it is both similar to and different from methods in other languages.

• Declare a method on a Struct
• Learn about the difference between value receivers and reference receivers
• Learn how and why to declare methods on other types in Go

Abstracting interface from implementation is another useful object-oriented concept. 
This video covers Go’s implementation of interfaces, which is very different from how interfaces work in most other languages.

• Learn what interfaces are in Go
• Implement an interface in Go
• Learn about type assertions and type switches

Error handling is a core part of any program and different languages encourage different patterns for handling error conditions.
This video covers Go’s implementation of errors, which uses interfaces and multiple return values.

• Learn what an error is in Go and how to handle them
• Create and process errors
• Avoid common error pitfalls

The rise of multi-core CPUs has made concurrency handling one of the most important parts of programming today.
This video provides an introduction to Go’s style of concurrency and covers the goroutine, a lightweight in-process concurrency abstraction.

• Learn about CSP, the theory behind Go concurrency
• Learn about Goroutines, how to launch them and wait for them
• Set up data in a Goroutine

Part of what makes Go’s concurrency model different is that it focuses on sending data between concurrent processes rather than trying to share data across them.
This video covers channels, Go’s method for sending data between Goroutines.

• Learn what a channel is and how to create them
• Send data between Goroutines
• Learn about nil and closed channels

Most concurrency patterns require you to work with more than a single channel. Select statements are the key to properly handling multiple channels.
This video covers select, Go’s method for handling requests across multiple channels.

• Learn what select is and how to use it
• Learn about the done channel pattern to prevent leaking Goroutines
• Use Goroutines, Select, and Channels to implement backpressure