Go - The Complete Guide

15h 23m 30s
English
Paid

Course description

Unleash Your Potential - with Go and this course! Welcome to "Go - The Complete Guide," the definitive online course meticulously designed for both newcomers and professionals eager to excel in the dynamic realm of Go programming. Why Go? In an era where efficiency and performance are paramount, Go stands out as a powerhouse. Designed by Google, it combines simplicity, robustness, and speed, making it the go-to language for modern backend development, cloud services, and high-performance applications.

Read more about the course

Course Overview

This course is your comprehensive journey through the world of Go. From basic syntax to advanced features, this course covers every aspect needed to master Go.

Here's what you'll learn:

  • Go Fundamentals: Dive deep into Go syntax, variables, types, and control structures.
  • Concurrent Programming: Unravel the power of Go's concurrency model with goroutines and channels.
  • Complex Data Structures: Master arrays, slices, maps, and struct types for efficient data manipulation.
  • Advanced Features: Explore interfaces, error handling, and package management.
  • Real-World Applications: Build practical, real-world applications to consolidate your learning.
  • Optimization Techniques: Learn best practices and optimization techniques for writing efficient Go code.

In this course, you'll learn about all those core Go concepts by building multiple demo projects - including a complete REST API with user authentication & SQL database access!

Who Should Enroll?

This course is tailored for:

  • Developers looking to add a powerful language to their toolkit.
  • Backend engineers aspiring to build scalable, high-performance applications.
  • Professionals seeking a deep, practical understanding of Go.

Why Choose This Course?

  • Expert Instruction: Learn from an experienced Go developer & bestselling online course instructor.
  • Flexible Learning: Access the course anytime, anywhere, at your pace.
  • Demo Projects: Apply your knowledge by building multiple demo projects - e.g., a complete REST API

Ready to Go?

Embark on your journey to mastering Go. Enroll now and transform your career with the power of Go programming.

Watch Online

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 191 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing

Watch Online Go - The Complete Guide

0:00
/
#1: Welcome To The Course!

All Course Lessons (191)

#Lesson TitleDurationAccess
1
Welcome To The Course! Demo
01:06
2
What Is Go? And Why Is It Awesome?
01:49
3
Installing Go (Alternative: Web-based Setup)
01:50
4
Local Code Editor Setup For Go Development
01:42
5
Writing a First Go Program
02:04
6
About The Course & Course Content
01:24
7
How To Get The Most Out Of This Course
03:24
8
Module Introduction
01:17
9
Working with Functions & Values
03:48
10
Organizing Code with Packages
03:54
11
The Important Of The Name "main"
01:54
12
Understanding Go Modules & Building Go Programs
04:34
13
The "main" Function Is Important!
03:54
14
Onwards To A New Project
02:23
15
Working with Variables, Values & Operators
05:36
16
Understanding Value Types
05:22
17
Outputting Values
03:14
18
Type Conversions & Explicit Type Assignment
04:22
19
Using Alternative Variable Declaration Styles
05:28
20
Making Sense of Constant Values ("Constants")
04:30
21
Understanding the Importance Of Variables
06:33
22
Improved User Input Fetching
05:23
23
Exercise: Building a Profit Calculator
01:19
24
Exercise Solution
08:14
25
Formatting Strings (Text) - Basics
07:30
26
Formatting Floats in Strings
02:42
27
Building Multiline Strings
02:27
28
Creating Formatted Strings
03:46
29
Understanding Functions
09:05
30
Functions: Return Values & Variable Scope
11:08
31
An Alternative Return Value Syntax
02:32
32
Exercise: Working with Functions
09:00
33
Onwards to Control Structures
05:29
34
Introducing "if" Statements & Booleans
05:52
35
Working with "else if"
04:22
36
Exercise: "if" Statements
02:05
37
Using "else"
02:03
38
Nested "if" Statements & Using "return" To Stop Function Execution
04:52
39
Repeating Code With "for" Loops
04:04
40
Infinite Loops, "break" & "continue"
05:00
41
Making Sense of "switch" Statements
05:19
42
Writing To Files
06:09
43
Reading From Files
06:48
44
Handling Errors
08:02
45
Time to Panic!
02:05
46
Section Exercise - The Task
01:45
47
Section Exercise - Solution
11:30
48
Module Summary
01:09
49
Module Introduction
00:54
50
Splitting Code Across Files In The Same Package
04:20
51
Why Would You Use More Than One Package?
01:33
52
Preparing Code For Multiple Packages
03:42
53
Splitting Code Across Multiple Packages
02:42
54
Importing Packages
01:38
55
Exporting & Importing Identifiers (Variables, Functions & More)
02:37
56
Using Third-Party Packages
05:37
57
Module Summary
01:01
58
Module Introduction
00:31
59
Understanding Pointers
06:05
60
Writing Code Without Pointers
03:18
61
Creating a Pointer
01:40
62
Pointers as Values
01:57
63
Using Pointers & Passing Pointers To Functions
03:29
64
Using Pointers For Data Mutation
04:09
65
Example: The Scan() Function Uses Pointers
01:00
66
Module Summary
00:35
67
The Starting Project
00:54
68
Module Introduction
01:08
69
Which Problem Do Structs Solve?
02:28
70
Defining A Struct Type
04:44
71
Instantiating Structs & Struct Literal Notation
03:29
72
More On Struct Literals
02:24
73
Alternative Struct Literal Notation & Struct Null Values
02:25
74
Passing Struct Values As Arguments
02:34
75
Structs & Pointers
03:22
76
Introducing Methods
04:29
77
Mutation Methods
06:03
78
Using Creation / Constructor Functions
04:57
79
Using Constructor Functions For Validation
04:53
80
Structs, Packages & Exports
05:21
81
Exposing Methods & A Different Constructor Function Name
05:39
82
Struct Embedding
07:57
83
Structs - A Summary
02:58
84
Creating Other Custom Types & Adding Methods
05:17
85
Practice Project: Getting User Input
07:36
86
Practice Project: Creating a Struct & Constructor Function
07:18
87
Practice Project: Adding a Method
03:35
88
Practice Project: Handling Long User Input Text
06:14
89
Practice Project: Preparing Save To File Functionality
04:15
90
Practice Project: Encoding JSON Content
05:16
91
Practice Project: Fixes
02:14
92
Understanding Struct Tags
04:18
93
Preparing An Interface Use-Case
03:37
94
Module Introduction
00:26
95
Finishing Interface Preparations
03:11
96
Creating a First Interface
05:17
97
Using The Interface
05:17
98
Embedded Interfaces
06:10
99
The Special "Any Value Allowed" Type
02:08
100
Working with Type Switches
03:37
101
Extracting Type Information From Values
05:14
102
Interfaces, Dynamic Types & Limitations
03:58
103
Introducing Generics
05:32
104
Introducing Arrays
08:03
105
Module Introduction
01:20
106
Working with Arrays
06:21
107
Selecting Parts of Arrays With Slices
03:26
108
More Ways Of Selecting Slices
04:30
109
Diving Deeper Into Slices
09:42
110
Building Dynamic Lists With Slices
09:24
111
Exercise - Problem
04:13
112
Exercise - Solution
20:00
113
Unpacking List Values
03:30
114
Introducing Maps
06:43
115
Mutating Maps
03:44
116
Maps vs Structs
04:00
117
Using The Special "make" Function
07:11
118
"make"ing Maps
03:09
119
Working with Type Aliases
02:34
120
For Loops with Arrays, Slices & Maps
05:25
121
Module Introduction
01:05
122
Functions as Values & Function Types
15:08
123
Returning Functions As Values
06:21
124
Introducing Anonymous Functions
06:35
125
Understanding Closures
06:45
126
Making Sense Of Recursion
11:23
127
Using Variadic Functions
06:50
128
Splitting Slices Into Parameter Values
03:05
129
Module Introduction
01:46
130
Building a First, Basic Version Of The Program
09:46
131
Setting Up A First Struct
03:41
132
Adding a Constructor Function
03:06
133
Adding a Method
07:09
134
Loading Data From A File
08:14
135
Working With The File Data
07:14
136
Outsourcing Sharable Logic Into A Package
05:28
137
Outsourcing File Access Into A Package
05:40
138
Storing JSON Data In Files
08:36
139
Adding a FileManager Struct
08:17
140
Adding & Using Struct Tags
02:47
141
Working on a Swappable Struct
07:56
142
Interfaces To The Rescue
04:29
143
Error Handling
02:54
144
Module Summary
01:14
145
Introducing Goroutines
01:44
146
Module Introduction
00:53
147
Running Functions As Goroutines
03:19
148
Understanding Goroutine Behavior
01:43
149
Introducing & Using Channels
04:29
150
Working with Multiple Channels & Goroutines
08:35
151
Goroutines & Channels in a Project
09:58
152
Setting Up An Error Channel
03:28
153
Managing Channels with the "select" Statement
05:47
154
Deferring Code Execution with "defer"
02:39
155
Module Introduction
01:28
156
Planning The API
04:10
157
Installing the Gin Framework
02:18
158
Setting Up A First Route & Handling a First Request
11:55
159
Setting Up An Event Model
04:06
160
Registering a POST Route
08:46
161
Testing Requests & Fixing the POST Request Handler
07:02
162
Adding a SQL Database
08:28
163
Creating A SQL Database Table
05:50
164
Storing Data in the Database (INSERT)
06:32
165
Getting Events From Database (SELECT)
08:32
166
Getting Single Event Data By ID
12:10
167
Refactoring Code & Outsourcing Routes
04:02
168
Registering an "Update Event" Route & Handler
04:47
169
Updating Events
08:01
170
Deleting Events
05:50
171
Adding a "Users" Table To The SQL Database
04:15
172
Adding User Signup
08:32
173
Don't Store Plain-text Passwords!
01:19
174
Hashing Passwords
05:02
175
Getting Started with Auth Tokens (JWT)
02:24
176
Getting Started with the Login Route
10:26
177
Finishing The Login Logic
05:13
178
Generating JWT
07:54
179
Finishing The JWT Logic
04:23
180
Adding Token Verification
14:33
181
Adding Route Protection
05:17
182
Retrieving & Storing User and Event IDs
08:00
183
Adding an Authentication Middleware
03:52
184
Enhancing & Using The Middleware
07:28
185
Adding Authorization To Restrict Users From Editing & Deleting
05:59
186
Adding a Registrations Table
03:03
187
Registering Users
07:40
188
Testing & Fixing the "Register" Route
02:50
189
Cancelling Registrations
05:20
190
Module Summary
01:02
191
Course Roundup
00:51

Unlock unlimited learning

Get instant access to all 190 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

Comments

0 comments

Want to join the conversation?

Sign in to comment

Similar courses

Golang + Lambda Masterclass [EARLY-ACCESS]

Golang + Lambda Masterclass [EARLY-ACCESS]

Sources: Gourav Kumar
This course teaches you everything you need to create production-ready Golang + Lambda Microservices, REST APIs, and Event-Driven serverless applications on AWS cloud like a pro...
1 hour 41 minutes 25 seconds
Introduction to Testing in Go (Golang)

Introduction to Testing in Go (Golang)

Sources: udemy
Writing unit tests and integration tests is one of the most-neglected aspects of software development. All too often, a developer will find him or herself say "but it works on m...
12 hours 17 minutes 47 seconds
Master Go

Master Go

Sources: appliedgo.com (Christoph Berger)
A few years ago, I discovered Go and immediately fell in love with this language. I loved how the incredibly clean design of the language, as well as the awesome toolchain, sudd...
6 hours 32 minutes 20 seconds
Angular and Golang: A Practical Guide

Angular and Golang: A Practical Guide

Sources: udemy
I'm a FullStack Developer with 10+ years of experience. I'm obsessed with clean code and I try my best that my courses have the cleanest code possible. My teaching style is very...
6 hours 35 minutes 27 seconds
Go Programming Bootcamp

Go Programming Bootcamp

Sources: udemy
Go is the #1 language in most demand by employers right now. Employers are willing to pay 33% more for those who are gifted Go programmers. The problem is that access to a high ...
15 hours 56 minutes 19 seconds