Introduction to Go Training Workshop

Intro to Go (golang) is designed to get existing software teams with little to no Go experience ready to write production ready code. It focuses on the common mistakes that developers new to Go are likely to make, and ensures that they have practical knowledge to be productive in their day to day efforts.
Our classes are priced for small and large classes. We offer classes starting at only five students, up to 100 students. We recognize that each company has specific needs and budgets.
For pricing, fill out our contact us form and you'll receive an automated reply with our current rates.
2h30m · 2 Student Labs
In this chapter, we will explore the essential components of the Go programming language. You will learn how to use the keywords, operators, and delimiters that form the foundation of Go, along with the idiomatic ways to structure your code. We will also delve into data structures, including how Go handles default values (zero values) and the characteristics of structs. This chapter covers Go’s treatment of strings, UTF-8 encoding, and the different types of string literals. Finally, we will examine how to declare variables and constants, and introduce the use of the iota keyword for efficiently handling constant definitions. This chapter sets the stage for mastering Go by equipping you with the knowledge of its core language features.
Modern Go development requires more than just writing code. This chapter covers essential tools and practices for professional Go development including hot reload with air, goroutine leak detection with goleak, build tags, build info embedding, and IDE integration. These tools significantly improve development velocity and code quality.
30m · 1 Shared Lab, 1 Student Lab
This chapter provides an in-depth exploration of arrays and iteration in Go. You will learn the fundamentals of arrays, including their fixed size and type, how to create and initialize them, and how Go handles array indexing. The chapter also covers common loop constructs, including for loops, range loops, and control mechanisms like continue and break. You'll also gain hands-on experience with two-dimensional arrays, iteration patterns, and using Go’s range keyword to simplify array iteration. By the end, you'll have a solid foundation for working with arrays and iteration in Go, setting the stage for more advanced data structures.
45m · 2 Shared Labs, 1 Student Lab
This chapter takes an in-depth look at slices in Go, a powerful tool for working with dynamic data structures. You'll start by understanding the basics of slice creation, initialization, and iteration. Then, you'll explore advanced techniques for growing, shrinking, and manipulating slices without unnecessary memory allocation. Key topics include the append function, slice internals, and memory management techniques like copying and deleting from slices. Additionally, you will learn about Go's slices package, which provides enhanced tools for sorting, searching, and managing slices efficiently. You'll also explore the iterator functions introduced in Go 1.23, enabling powerful slice transformations and batch processing. By mastering slices, you'll be able to work more effectively with Go's dynamic data structures.
1h · 1 Shared Lab, 1 Student Lab
This chapter delves into Go’s powerful map data structure, a flexible key-value storage system essential for dynamic collections and efficient data retrieval. You’ll learn the fundamentals of map creation, initialization, and iteration, as well as techniques for updating, deleting, and checking the existence of values. With hands-on exercises, you’ll explore how to handle map errors, avoid common pitfalls, and manipulate complex data types stored in maps. By mastering Go maps, you will efficiently manage dynamic collections and improve your data access strategies.
45m · 1 Shared Lab, 1 Student Lab
This chapter introduces pointers in Go, demystifying their role in memory management and efficient data handling. You’ll learn the difference between passing by value and passing by reference, how to declare and use pointers, and when to leverage pointers for better performance and flexibility. The chapter will also explore the security implications of pointers, the basics of pointer dereferencing, and how Go’s memory management techniques avoid common pitfalls seen in other languages. Through practical examples and exercises, you will gain a deeper understanding of when and how to use pointers effectively in Go.
2h30m · 1 Shared Lab, 3 Student Labs
This chapter explores the fundamentals of functions in Go, guiding you through creating reusable functions with multiple arguments and return values. You will learn how to define variadic functions that can handle a dynamic number of arguments, utilize closures to capture external variables, and understand methods for attaching functions to types. Additionally, the chapter delves into advanced concepts like deferred function calls, error handling, function types, and the use of init functions to perform pre-execution setup. Through practical examples, you'll build the skills needed to create flexible, efficient Go functions.
1h30m · 1 Shared Lab, 3 Student Labs
id: overview-1 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 interface.
1h15m · 1 Shared Lab, 3 Student Labs
This chapter delves into Go's powerful embedding and composition mechanisms, which allow developers to build cleaner, modular, and reusable code without traditional inheritance. Instead of subclassing, Go enables embedding types within structs and interfaces, promoting fields an