Go - The Complete Guide

Name: Go - The Complete Guide
Price: 9 USD
Availability: InStock

15h 23m 30s

English

Paid

March 6, 2024

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.

Watch Online

Watch Online Go - The Complete Guide

0:00

#1: Welcome To The Course!

All Course Lessons (191)

#	Lesson Title	Duration
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?

Similar courses

Full Time Go Dev

Sources: fulltimegodev

Rocket Fuel you GO career with the Full Time Go Dev Mastery. These secret techniques will make everyone say "WOW" while you destroy any GO task with the speed of light.

42 hours 44 minutes 36 seconds

Getting Started With Golang

Sources: Academind Pro

Learn all the key fundamentals of Go - one of the most in-demand and popular programming languages you can learn these days! Go (or Golang) is a very modern, performant and popu...

15 hours 19 minutes 14 seconds

Ultimate Go

Sources: ardanlabs.com

Advanced course Ultimate Go developed for those, who want to concentrate on deep learning of language and to understand things that have sense and semanthic.

16 hours 8 minutes 46 seconds

Go (Golang) Programming The Complete Go Bootcamp 2023

Sources: udemy

Fully updated for 2021. This Go Programming course covers every major topic, including Pointers, Methods, and Interfaces (Go OOP), Concurrency In-Depth (Goroutines, Channels, Mu...

17 hours 49 minutes 29 seconds