Go – The Complete Guide

Getting Started
1 Welcome To The Course!
2 What Is Go And Why Is It Awesome
3 Installing Go (Alternative Web-based Setup)
4 Local Code Editor Setup For Go Development
5 Writing a First Go Program
6 About The Course & Course Content
7 How To Get The Most Out Of This Course
8 Join Our Learning Community

Go Essentials
9 Module Introduction
10 Working with Functions & Values
11 Organizing Code with Packages
12 The Important Of The Name main
13 Understanding Go Modules & Building Go Programs
14 The main Function Is Important!
15 Onwards To A New Project
16 Working with Variables, Values & Operators
17 Understanding Value Types
18 Go Types & Null Values
19 Outputting Values
20 Type Conversions & Explicit Type Assignment
21 Using Alternative Variable Declaration Styles
22 Making Sense of Constant Values (Constants)
23 Understanding the Importance Of Variables
24 Improved User Input Fetching
25 fmt.Scan() Limitations
26 Exercise Building a Profit Calculator
27 Exercise Solution
28 Formatting Strings (Text) – Basics
29 Formatting Floats in Strings
30 Building Multiline Strings
31 Creating Formatted Strings
32 Understanding Functions
33 Functions Return Values & Variable Scope
34 An Alternative Return Value Syntax
35 Exercise Working with Functions
36 Onwards to Control Structures
37 Introducing if Statements & Booleans
38 Working with else if
39 Exercise if Statements
40 Using else
41 Nested if Statements & Using return To Stop Function Execution
42 Repeating Code With for Loops
43 Infinite Loops, break & continue
44 Conditional For Loops
45 Making Sense of switch Statements
46 Writing To Files
47 Reading From Files
48 Handling Errors
49 Time to Panic!
50 Section Exercise – The Task
51 Section Exercise – Solution
52 Module Summary

Working with Packages
53 Module Introduction
54 Splitting Code Across Files In The Same Package
55 Why Would You Use More Than One Package
56 Preparing Code For Multiple Packages
57 Splitting Code Across Multiple Packages
58 Importing Packages
59 Exporting & Importing Identifiers (Variables, Functions & More)
60 Using Third-Party Packages
61 Module Summary

Understanding Pointers
62 Module Introduction
63 Understanding Pointers
64 Writing Code Without Pointers
65 Creating a Pointer
66 Pointers as Values
67 A Pointer’s Null Value
68 Using Pointers & Passing Pointers To Functions
69 Using Pointers For Data Mutation
70 Example The Scan() Function Uses Pointers
71 Module Summary

Structs & Custom Types
72 Module Introduction
73 The Starting Project
74 Which Problem Do Structs Solve
75 Defining A Struct Type
76 Instantiating Structs & Struct Literal Notation
77 More On Struct Literals
78 Alternative Struct Literal Notation & Struct Null Values
79 Passing Struct Values As Arguments
80 Structs & Pointers
81 Introducing Methods
82 Mutation Methods
83 Using Creation Constructor Functions
84 Using Constructor Functions For Validation
85 Structs, Packages & Exports
86 Exposing Methods & A Different Constructor Function Name
87 Struct Embedding
88 Structs – A Summary
89 Creating Other Custom Types & Adding Methods
90 Practice Project Getting User Input
91 Practice Project Creating a Struct & Constructor Function
92 Practice Project Adding a Method
93 Practice Project Handling Long User Input Text
94 Practice Project Preparing Save To File Functionality
95 Practice Project Encoding JSON Content
96 Practice Project Fixes
97 Understanding Struct Tags

Interfaces & Generic Code
98 Module Introduction
99 Preparing An Interface Use-Case
100 Finishing Interface Preparations
101 Creating a First Interface
102 Using The Interface
103 Embedded Interfaces
104 The Special Any Value Allowed Type
105 Working with Type Switches
106 Extracting Type Information From Values
107 Interfaces, Dynamic Types & Limitations
108 Introducing Generics

Managing Related Data with Arrays, Slices & Maps
109 Module Introduction
110 Introducing Arrays
111 Working with Arrays
112 Selecting Parts of Arrays With Slices
113 More Ways Of Selecting Slices
114 Diving Deeper Into Slices
115 Building Dynamic Lists With Slices
116 Exercise – Problem
117 Exercise – Solution
118 Unpacking List Values
119 Introducing Maps
120 Mutating Maps
121 Maps vs Structs
122 Using The Special make Function
123 makeing Maps
124 Working with Type Aliases
125 For Loops with Arrays, Slices & Maps

Functions Deep Dive
126 Module Introduction
127 Functions as Values & Function Types
128 Returning Functions As Values
129 Introducing Anonymous Functions
130 Understanding Closures
131 Making Sense Of Recursion
132 Using Variadic Functions
133 Splitting Slices Into Parameter Values

Practice Project Price Calculator
134 Module Introduction
135 Building a First, Basic Version Of The Program
136 Setting Up A First Struct
137 Adding a Constructor Function
138 Adding a Method
139 Loading Data From A File
140 Working With The File Data
141 Outsourcing Sharable Logic Into A Package
142 Outsourcing File Access Into A Package
143 Storing JSON Data In Files
144 Adding a FileManager Struct
145 Adding & Using Struct Tags
146 Working on a Swappable Struct
147 Interfaces To The Rescue
148 Error Handling
149 Module Summary

Concurrency – Running Tasks In Parallel
150 Module Introduction
151 Introducing Goroutines
152 Running Functions As Goroutines
153 Understanding Goroutine Behavior
154 Introducing & Using Channels
155 Working with Multiple Channels & Goroutines
156 Goroutines & Channels in a Project
157 Setting Up An Error Channel
158 Managing Channels with the select Statement
159 Deferring Code Execution with defer

Course Project Build a REST API (incl. Authentication & SQL Database)
160 Module Introduction
161 Planning The API
162 Installing the Gin Framework
163 Setting Up A First Route & Handling a First Request
164 Setting Up An Event Model
165 Registering a POST Route
166 Testing Requests & Fixing the POST Request Handler
167 Adding a SQL Database
168 Creating A SQL Database Table
169 Storing Data in the Database (INSERT)
170 Getting Events From Database (SELECT)
171 Preparing Statements vs Directly Executing Queries (Prepare() vs Exec()Query())
172 Getting Single Event Data By ID
173 Refactoring Code & Outsourcing Routes
174 Registering an Update Event Route & Handler
175 Updating Events
176 Deleting Events
177 Adding a Users Table To The SQL Database
178 Adding User Signup
179 Don’t Store Plain-text Passwords!
180 Hashing Passwords
181 Getting Started with Auth Tokens (JWT)
182 Getting Started with the Login Route
183 Finishing The Login Logic
184 Generating JWT
185 Finishing The JWT Logic
186 Adding Token Verification
187 Adding Route Protection
188 Retrieving & Storing User and Event IDs
189 Adding an Authentication Middleware
190 Enhancing & Using The Middleware
191 Adding Authorization To Restrict Users From Editing & Deleting
192 Adding a Registrations Table
193 Registering Users
194 Testing & Fixing the Register Route
195 Cancelling Registrations
196 Module Summary

Course Roundup
197 Course Roundup
198 Bonus Lecture