Go Fundamentals LiveLessons: Presented by Gopher Guides (Video Training)
- By Mark Bates, Cory LaNou
- Published Jun 7, 2023 by Addison-Wesley Professional.
Online Video
- Your Price: $239.99
- List Price: $299.99
- About this video
Video accessible from your Account page after purchase.
Register your product to gain access to bonus material or receive a coupon.
Description
- Copyright 2023
- Edition: 1st
- Online Video
- ISBN-10: 0-13-822185-5
- ISBN-13: 978-0-13-822185-0
4.5 Hours of Video Instruction
A thorough introduction to Golang, the Go programming language.
Based on author Mark Bates's and Cory LaNou's pioneering Gopher Guides training curricula, these videos enable you to quickly understand and use Go syntax, core features, and idioms. Go Fundamentals LiveLessons prepares you to write robust, reliable, well-performing production code right from the outset.
Skill Level:
- Beginner
- Intermediate
Learn How To:
- Manage packages, modules, and dependencies
- Apply Golang basics, such as variable declaration, types, and control flow
- Work effectively with collection types, iteration, functions, structs, and pointers
- Understand Go Slices and use them properly
- Write idiomatic Go, using principles such as embedding and composition
- Expertly use concurrency to improve code performance
- Create proper tests to quickly identify and fix problems
- Write simpler, better code with generics and interfaces
- Take advantage of channels, context, sync primitives, and other advanced features
Who Should Take This Course:
- Those learning their first programming language
- Experienced programmers who want to take advantage of the power of GO
Course Requirements:
- There are no prerequisites, but experience with other programming languages is helpful
Lesson Descriptions:
Lesson 1: Packages, Modules, Dependencies
Lesson 1 discusses packages, modules, and dependencies. The lesson begins with Go modules and then digs into Go packages. Next comes how Go files and folders are named and organized. You then learn how to import third-party packages and modules into Go projects. Finally, you learn how to manage those third-party packages.
Lesson 2: Go Language Basics
Lesson 2 explores the basics of the Go language. You learn topics such as variable declaration, the type system, built in data types, and printing and formatting of values. While some of this material might be familiar to you already, proper understanding of these basics is necessary to get the most out of the Go language.
Lesson 3: Arrays, Slices, Iterations
Lesson 3 covers arrays, slices, and iterations. First, you learn about the built-in list types, arrays, and slices. Then the lesson turns to how slices work. Finally, you learn how to iterate over collection types such as arrays and slices.
Lesson 4: Maps and Control Structures
Lesson 4 presents maps in Go. You learn how to declare, initialize, and use maps. You learn that maps need to be initialized before they can be used, and you learn how to check for key existence, how to delete a key, and how to iterate over a map. Finally, after you have learned about maps, the lesson turns to built-in control structures, such as if else and switch statements. With this and the previous videos you have now covered the most basic data types, operators, keywords, functions, and control structures in Go. With this knowledge, you can now begin to delve into more interesting and fun topics. If at any point you start to feel lost, the answers are most likely in this or the first three lessons.
Lesson 5: Functions
In Lesson 5 you are presented with a core part of any language: functions. Go functions are first class citizen and can be used in many ways. First, you learn how to create functions using the func keyword. Then you learn how to handle inbound arguments and return values. Finally, you are exposed to advanced function topics such as variadic arguments, deferring functions, and the init function.
Lesson 6: Structs, Methods, and Pointers
Lesson 6 delves into structs, methods, and pointers in Go. It covers definition, initialization, and usage of structs. It also covers struct tags and their use for operations such as encoding and decoding JSON. Next, you learn adding methods to types. Finally, the lessons finish with pointers and how they can be used to avoid copying data as well as how they enable us to allow others to mutate data.
Lesson 7: Testing
Testing in Go, as in any language, is a subject worthy of its own set of videos. Covering all the various topics such as benchmarking, example tests, and design patterns is, unfortunately, outside the scope of this lesson. In this lesson, you get the fundamentals of testing and Go, including writing, running and debugging tests. The lesson also covers table-driven tests, test helpers, and code coverage.
Lesson 8: Interfaces
Interfaces in Go provide a way to specify the behavior of an object. If somebody can do this, then it can be used here. In this video, you learn how to use interfaces to abstract behavior. Concepts such as the empty interface, satisfying multiple interfaces, and asserting behavior are also covered.
Lesson 9: Errors
Lesson 9 covers the benefits of how goals error model results in more reliable code. It presents how to handle basic errors and return errors as an interface that satisfies the error type. Additionally, concepts such as custom error types, panics, recovering from panics, and wrapping and unwrapping errors are also covered.
Lesson 10: Generics
In Lesson 10 you learn about generics in Go. You learn what generics are and about type constraints and how to define them. You learn how to deal with underlying type constraints, and then finally, you learn how to make generic types.
Lesson 11: Channels
Lesson 11 starts to explore concurrency in Go with channels. You learn the differences between parallelism and concurrency, and you learn how to use Go routines and channels to achieve concurrency. You learn about channels and how they can be used to communicate between and control Go routines. You learn the differences between buffered and unbuffered channels and when each one will block and unblock. Finally, you learn how you can use channels to listen for system signals so you can gracefully shut down your applications.
Lesson 12: Context
In Lesson 12 you learn about contexts and Go. You learn about context values, how context can be used for cancellation propagation. You also learn how to deal with errors that result from your cancellation of contexts.
Lesson 13: Synchronization
Lesson 13 presents just a few of the synchronization types and functions in Go. First, the lesson explores how to use a wait group to wait for a number of Go routines to finish. Then you learn how to use an error group to wait for a number of Go routines to finish and return an error if any of them failed. Next, you learn how to use a mutex and a read-write mutex to synchronize access to a shared resource. Finally, you learn how to use sync once to ensure a function is only executed one time.
Lesson 14: Working with Files
Working with files is a very common task in computer programming. We work with log files, HTML files and a whole host of other file types in our programs. In this lesson, you learn how to read and write files, walk directories, and use the FS package. Finally, you learn how to embed files into our Go binaries, creating a truly self-contained application.
About Pearson Video Training
Pearson publishes expert-led video tutorials covering a wide selection of technology topics designed to teach you the skills you need to succeed. These professional and personal technology videos feature world-leading author instructors published by your trusted technology brands: Addison-Wesley, Cisco Press, Pearson IT Certification, Prentice Hall, Sams, and Que. Topics include IT Certification, Network Security, Cisco Technology, Programming, Web Development, Mobile Development, and more. Learn more about Pearson Video training at http://www.informit.com/video.
Sample Content
Table of Contents
Introduction
Lesson 1: Packages, Modules, Dependencies
1.1 Understanding Go Modules
1.2 Packages
1.3 File, Folders, and Organization
1.4 Dependency Management
Lesson 2: Go Language Basics
2.1 Language Overview
2.2 Numbers
2.3 Strings and UTF-8
2.4 Variables
2.5 Constants
2.6 Naming Identifiers
2.7 Printing and Formatting
Lesson 3: Arrays, Slices, Iterations
3.1 Arrays and Slices
3.2 How Slices Work
3.3 Iteration
Lesson 4: Maps and Control Structures
4.1 Maps
4.2 If Statements
4.3 Switch Statements
Lesson 5: Functions
5.1 Arguments and Return Values
5.2 First Class Functions
5.3 Variadic Arguments
5.4 Deferring Function Calls
5.5 The init Function
Lesson 6: Structs, Methods, and Pointers
6.1 Structs
6.2 Methods
6.3 Pointers
Lesson 7: Testing
7.1 Testing Basics
7.2 Running Tests
7.3 Code Coverage
7.4 Table Driven Testing
7.5 Test Helpers
Lesson 8: Interfaces
8.1 What Are Interfaces?
8.2 The Empty Interface
8.3 Using Interfaces
8.4 Type Assertion
Lesson 9: Errors
9.1 Errors
9.2 Panics
9.3 Custom Errors
9.4 Wrapping/Unwrapping Errors
9.5 Using errors.As and errors.Is
Lesson 10: Generics
10.1 What Are Generics?
10.2 Type Constraints
10.3 Defining Constraints
10.4 Underlying Type Constraints
10.5 Generic Types
Lesson 11: Channels
11.1 Concurrency
11.2 Channels
11.3 Iteration and Select Statements
11.4 Closed Channels
11.5 Buffered Channels
11.6 System Signals
Lesson 12: Context
12.1 Contexts
12.2 Context Values
12.3 Cancellation Propagation
12.4 Context Errors
Lesson 13: Synchronization
13.1 Wait Groups
13.2 Error Groups
13.3 Data Races
13.4 Locking with a Mutex
13.5 Performing Tasks Only Once
Lesson 14: Working with Files
14.1 Directories
14.2 File Path Helpers
14.3 Files
14.4 Using File System Interfaces
14.5 Embedding FilesSummary