This course is tailored to developers learning Go for the first time, or having less than one year of Go development experience. This workshop will cover practical, daily Go fundamentals. Starting with the language fundamentals, students will move into interfaces and how they lend to embedding and composition in Go. They will finish up with an overview of concurrency in Go.
Everyone will have a strong understanding language fundamentals, such as syntax and types, arrays/slices/maps, maps and pointers. From there, a deep dive into interfaces and embedding and composition. Finally, an overview of the how concurrency works in Go.
At least one year of production experience with another modern programming language. Beginners are highly encouraged to attend this training.
Tim Raymond is a full-stack developer with over six years of experience writing Go for companies such as USA Today, InfluxData, and Mattel. He's worked on everything from publishing pipelines, gRPC APIs, IoT backends, and interactive React frontends powered by Go backends. Prior to his involvement in the Go community, Tim served as an organizer for the Boston Ruby Group. His professional interests range across web applications, compilers, networking, performance, and cryptography.
This module covers general information about your instructor and course materials.
This chapter covers general environment setup and other resource related
information needed to complete the courses contained within.
In this chapter we will cover the basic keywords and syntax of the Go language.
You will learn the keywords, operators, and delimiters that make up the
language. You will then move into Syntax and Types, as well as learn how
strings are handled as well as UTF-8 text.
You will 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 chapter will cover both executable and library packages. You
will also learn how to create your own package and use it within another
Arrays in Go are useful when planning for detailed layout of memory. Using
arrays can sometimes help avoid allocation. However, their primary use is for
the building blocks of slices.
This chapter will cover the basics of creating, initializing, and indexing an
array. It will also cover basic loop constructs and loop control basics.
Slices wrap arrays in Go, and provide a more general, powerful, and convenient
interface to data sequences. In this chapter, 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 chapter 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 to the value of a variable. In many languages, pointers are a
source of pain and confusion. Go has made it easy to use and understand pointers. In this chapter you will
learn about the difference between pass by value and pass by reference. You will learn how to declare
pointers, and how to reference values as pointers. The chapter will discuss performance and security and
when to use pointers as well.
pass by value
pass by reference
Functions in Go are a primitive type. This chapter 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, and panics 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 chapter 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 chapter will cover the difference between
value and pointer receivers and how they affect the ability to satisfy an
something can do this, then it can be used here
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 chapter 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 a specific interface.
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 chapter will cover concurrency as it pertains to Go, what goroutines are, as well as a basic overview of the scheduler and terminology used.
This chapter covers where to get more support on Go, recommends books and
videos, and list the contact information for our instructors.
Go promotes sharing memory by communicating. This chapter covers goroutines and how to synchronize communication between them. Mechanics for synchronization such as WaitGroups and Mutexes are explored along with the corresponding patterns for each.
Channels are a conduit in Go used to communicate between goroutines. This chapter covers basic channel usage 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.