Daily Go: Fundamentals

By Gopher Guides

This course will walk you through installing Go, setting up your GOPATH, and
adding GOBIN to your path. It will also test to ensure the installation and
environment is properly set up. Finally, it will discuss several options for
code editors.

In this course we will cover the basic keywords and syntax of the Go language.
You'll learn the keywords, operators, and delimiters that make up the language.
You'll them move into Syntax and Types. Learn how strings are handled as well
as UTF-8 text.

You'll also learn about variables, constants, and iota. Then, using those
concepts, how to create structs and initialize them.

Packages are how Go organizes code. It is also how scope and visibility are
determined. This module will cover both executable and library packages. You
will also learn how to create your own package and use it within another
package.

Slices wrap arrays in Go, and provide a more general, powerful, and convenient
interface to data sequences. In this module, you will cover slice basics such
as creating, initializing, and iteration. You will also learn how to grow a
slice, work with subsets of slices, and slice tricks.

Maps are a powerful built-in data structure that associates keys and values. In this module you will
cover basic map creation, initialization, and iteration. You will discover how to determine if values
exist in maps and how to update and delete map values.

A pointer is a type that holds the address that points to a variables value. In many languages, pointers are the
source of pain and confusion. Go has made it easy to use and understand pointers. In this module you will
learn about the difference between pass by value and pass by reference. You will learn hot to declare
pointers, and how to reference values as pointers. The module will discuss performance and security and
when to use pointers as well.

Functions in Go are a primitive type. This module will cover how to declare
and call functions. You will cover how to send zero or many arguments, as well
as receive zero or many arguments. Variadic arguments, defers, panics, and
recovers will also be covered.

Interfaces in Go provide a way to specify the behavior of an object: if
something can do this, then it can be used here. This module will take a look
at how to use interfaces to abstract that behavior. Concepts such as the
Empty Interface, satisfying multiple interfaces, and asserting for behavior
will be covered. Additionally this module will cover the difference between
value and pointer receivers and how they affect the ability to satisfy an
interface.

Error handling in Go can feel a bit tedious at first. However, this module
will cover the benefits of how Go's error model results in more reliable code.
This module will cover how to handle basic errors, return errors as an
interface that satisfies the error type. Concepts such as custom error types,
panics, recovering from panics, and sentinel errors are also covered.

Concurrent programming in many environments is made difficult by the subtleties
required to implement correct access to shared variables. Go encourages a
different approach in which shared values are passed around on channels and, in
fact, never actively shared by separate threads of execution.

This module covers Go routines and how to synchronize communication between
them. Mechanics for synchronization such as WaitGroups, Mutexs, and Channels
are explored along with the corresponding patterns for each. Find out the
difference between a buffered and unbuffered channel, and when to use them.
Also discover how to use channels for signaling for concepts such as graceful
application shutdown.

Go ships with a powerful testing framework. Tests in Go are written in the Go
language, so there is no need to learn another syntax. This module will explore
basic tests, table driven tests, and sub-tests. Concepts such as race
conditions, code coverage, test automation. Understanding test options such as
parallel, short testing, timing out tests, and verbose are also covered.

Go does not provide the typical, type-driven notion of subclassing, but it does
have the ability to “borrow” pieces of an implementation by embedding types
within a struct or interface. This module will cover how promotion from embedding works
as well how collision and overriding are handled. You will also walk through how to embed types
to be able to satisfy an specific interface.

Package context defines the Context type, which carries deadlines, cancelation
signals, and other request-scoped values across API boundaries and between
processes. Context is used for controlling concurrent subsystems in your
application. This module will cover the different kinds of behavior with
contexts including canceling, timeouts, and values.

Go ships with a strong suite of built in tools. This module will go over the
most common tools and how to use them in your daily development workflow. In
addition to the tools that ship with Go there are a set of very important
lintes and vetters that can catch runtime bugs as well as significantly improve
code quality and performance. This module shows what those tools are and how
to use them.

Go has the ability to build and cross compile with ease. This chapter will
cover the different ways to build your binary and additionally covers concepts
for embedding build information such as version and GitHub SHA-1 hash. See how
build tags are used to conditionally include specific branches of code by
targeting specific platforms or simply using the tags provided.

SPECIAL PRICING - LIMITED TIME OFFER

If you are just starting Go, or want to hone in your fundamental core skills, this course is for you. This is a full blown 16 chapter course that will take you from start to finish in the provided topic areas. Each section contains hand on exercises with solutions to the exercise.