Go - The Complete Guide

15h 23m 30s
English
Paid
March 6, 2024

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.

More

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 Go - The Complete Guide

Join premium to watch
Go to premium
# Title Duration
1 Welcome To The Course! 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

Similar courses to Go - The Complete Guide

Angular and Golang: A Rapid Guide - Advanced

Angular and Golang: A Rapid Guide - Advancedudemy

Duration 9 hours 40 minutes 39 seconds
Ultimate Service 3.0

Ultimate Service 3.0ardanlabs.com

Duration 13 hours 33 minutes 5 seconds
Advanced Branching and Looping in GO

Advanced Branching and Looping in GOpluralsight

Duration 1 hour 14 minutes 40 seconds
Full Time Go Dev

Full Time Go Devfulltimegodev

Duration 42 hours 44 minutes 36 seconds
Ultimate Go

Ultimate Goardanlabs.com

Duration 16 hours 8 minutes 46 seconds
Writing An Interpreter In Go
Web Authentication, Encryption, JWT, HMAC, & OAuth With Go
Ultimate Go: Advanced Engineering

Ultimate Go: Advanced Engineeringardanlabs.com

Duration 16 hours 20 minutes 42 seconds