In this second installment of Go Fundamentals, you will learn the powerful concept of Interfaces, Embedding and Composition. From there, take a tour around Go's elegant implementation of concurrency. Learn the idiomatic way to write go and common mistakes and pitfalls that developers new to the language should know.
Each attendee will receive a link 24 hours prior to the start of the workshop with links to all class material. Additionally, each attendee will receive a link after the workshop to the recording of the workshop as well.
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.
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
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 Go routines and how to synchronize communication between them. Mechanics for synchronization such as WaitGroups and Mutexes are explored along with the corresponding patterns for each.
This chapter covers Go routines and how to synchronize communication between them. 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.
This chapter covers where to get more support on Go, recommends books and
videos, and list contact information for our instructors.