CF

Go - The Complete Guide

15h 23m 30s
English
Paid

Go - The Complete Guide is a 191-lesson 15 hours 23 minutes self-paced course by Academind Pro (Maximilian Schwarzmüller). Unleash Your Potential - with Go and this course!

Course facts

Lessons
191
Duration
15 hours 23 minutes
Level
All levels
Language
English
Updated
Instructor
Academind Pro (Maximilian Schwarzmüller)
Price
Premium

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.

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.

Additional

https://github.com/mschwarzmueller/go-complete-guide-resources

Who teaches Go - The Complete Guide? Academind Pro (Maximilian Schwarzmüller)

Academind Pro (Maximilian Schwarzmüller) thumbnail

Academind is the teaching brand of Maximilian Schwarzmüller (Max) and Manuel Lorenz, two German developers whose Udemy catalog has become one of the largest single-instructor presences on that platform. Max in particular is widely cited as one of the clearest teachers of the JavaScript framework landscape — his Angular, React, Vue, and Node.js courses have collectively taught millions of students.

The Academind Pro platform extends beyond Udemy with deeper, more comprehensive courses aimed at developers building real applications rather than picking up syntax. Course material covers the full modern web stack: React (including Next.js), Vue, Angular, Node.js, NestJS, TypeScript, Docker, AWS, React Native, Flutter, and the broader full-stack JavaScript ecosystem.

The CourseFlix listing under this source carries over 25 Academind Pro courses spanning that range. Material is paid; Academind Pro runs on per-course pricing on the original platform. Courses are taught in Max's signature thorough, build-an-application-with-me style — long-form, deeply project-based, and continuously updated as the underlying frameworks evolve.

What lessons are included in Go - The Complete Guide?

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
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

What courses are similar to Go - The Complete Guide?

More courses by Academind Pro (Maximilian Schwarzmüller)

Frequently asked questions

What prerequisites are required for this course?
This course is designed for both newcomers and experienced developers. Basic programming knowledge is helpful but not required, as the course covers fundamental programming concepts such as variables, functions, and control structures. The course also provides guidance on setting up your development environment and writing your first Go program, ensuring that even beginners can start coding in Go.
What projects will I work on during the course?
One of the projects includes building a Profit Calculator, which allows you to apply concepts like variables, operators, and user input fetching. Exercises such as working with functions and control structures like 'if' statements and loops are also included. These projects and exercises are designed to reinforce your understanding of Go programming concepts in practical scenarios.
Who is the target audience for this course?
The course is suitable for anyone interested in learning Go, from beginners with no programming experience to professional developers seeking to add Go to their skill set. It is particularly beneficial for those interested in backend development, cloud services, and high-performance applications, where Go's efficiency and speed are advantageous.
How does this course compare to other Go programming courses?
This course offers a comprehensive introduction to Go programming, covering 191 lessons that include basic programming concepts, advanced topics like pointers, and practical projects. Unlike more specialized courses, this provides a broad overview suitable for both beginners and those seeking to deepen their understanding of Go's capabilities in modern application development.
What specific tools and platforms are covered in the course?
The course includes guidance on installing Go and setting up a local code editor for Go development. An alternative web-based setup is also discussed. Additionally, it covers the use of Go Modules for building programs and demonstrates how to work with third-party packages, ensuring you are equipped to develop and manage Go applications effectively.
What topics are not covered in this course?
While the course provides a solid foundation in Go programming, it does not cover advanced topics such as concurrent programming with goroutines and channels, or in-depth exploration of Go's standard library beyond basic file handling and error management. These topics may require additional study or specialized courses for those interested in mastering them.
How much time should I commit to complete the course?
The course consists of 191 lessons, and while the exact runtime is not specified, the extensive content suggests a significant time investment. Students should be prepared to dedicate several weeks to thoroughly work through the lessons, exercises, and projects, particularly if they are new to programming or Go. Regular practice and review are recommended to fully grasp the material.