Autoplay
Autocomplete
Previous Lesson
Complete and Continue
Go - The Complete Guide
Getting Started
Welcome To The Course! (1:05)
What Is Go? And Why Is It Awesome? (1:48)
Installing Go (Alternative: Web-based Setup) (1:49)
Local Code Editor Setup For Go Development (1:41)
Writing a First Go Program (2:03)
About The Course & Course Content (1:23)
How To Get The Most Out Of This Course (3:23)
Join Our Learning Community
Go Essentials
Module Introduction (1:16)
Working with Functions & Values (3:47)
Organizing Code with Packages (3:53)
The Important Of The Name "main" (1:53)
Understanding Go Modules & Building Go Programs (4:33)
The "main" Function Is Important! (3:53)
Onwards To A New Project (2:22)
Working with Variables, Values & Operators (5:35)
Understanding Value Types (5:21)
Go Types & Null Values
Outputting Values (3:13)
Type Conversions & Explicit Type Assignment (4:21)
Using Alternative Variable Declaration Styles (5:27)
Making Sense of Constant Values ("Constants") (4:29)
Understanding the Importance Of Variables (6:32)
Improved User Input Fetching (5:22)
fmt.Scan() Limitations
Exercise: Building a Profit Calculator (1:18)
Exercise Solution (8:13)
Formatting Strings (Text) - Basics (7:29)
Formatting Floats in Strings (2:41)
Creating Formatted Strings (3:45)
Building Multiline Strings (2:26)
Understanding Functions (9:04)
Functions: Return Values & Variable Scope (11:07)
An Alternative Return Value Syntax (2:31)
Exercise: Working with Functions (8:59)
Onwards to Control Structures (5:28)
Introducing "if" Statements & Booleans (5:51)
Working with "else if" (4:21)
Exercise: "if" Statements (2:04)
Using "else" (2:02)
Nested "if" Statements & Using "return" To Stop Function Execution (4:51)
Repeating Code With "for" Loops (4:03)
Infinite Loops, "break" & "continue" (4:59)
Conditional For Loops
Making Sense of "switch" Statements (5:18)
Writing To Files (6:08)
Reading From Files (6:47)
Handling Errors (8:01)
Time to Panic! (2:04)
Section Exercise - The Task (1:44)
Section Exercise - Solution (11:29)
Module Summary (1:08)
Working with Packages
Module Introduction (0:54)
Splitting Code Across Files In The Same Package (4:19)
Why Would You Use More Than One Package? (1:32)
Preparing Code For Multiple Packages (3:41)
Splitting Code Across Multiple Packages (2:41)
Importing Packages (1:37)
Exporting & Importing Identifiers (Variables, Functions & More) (2:36)
Using Third-Party Packages (5:36)
Module Summary (1:00)
Understanding Pointers
Module Introduction (0:30)
Understanding Pointers (6:04)
Writing Code Without Pointers (3:17)
Creating a Pointer (1:39)
Pointers as Values (1:56)
A Pointer's Null Value
Using Pointers & Passing Pointers To Functions (3:28)
Using Pointers For Data Mutation (4:08)
Example: The Scan() Function Uses Pointers (0:59)
Module Summary (0:34)
Structs & Custom Types
Module Introduction (1:07)
The Starting Project (0:53)
Which Problem Do Structs Solve? (2:27)
Defining A Struct Type (4:43)
Instantiating Structs & Struct Literal Notation (3:28)
Alternative Struct Literal Notation & Struct Null Values (2:24)
Passing Struct Values As Arguments (2:33)
Structs & Pointers (3:21)
Introducing Methods (4:28)
Mutation Methods (6:02)
Using Creation / Constructor Functions (4:56)
Using Constructor Functions For Validation (4:52)
Structs, Packages & Exports (5:20)
Exposing Methods & A Different Constructor Function Name (5:38)
Struct Embedding (7:56)
Structs - A Summary (2:57)
Creating Other Custom Types & Adding Methods (5:16)
Practice Project: Getting User Input (7:35)
Practice Project: Creating a Struct & Constructor Function (7:17)
Practice Project: Adding a Method (3:34)
Practice Project: Handling Long User Input Text (6:13)
Practice Project: Preparing Save To File Functionality (4:14)
Practice Project: Encoding JSON Content (5:15)
Practice Project: Fixes (2:13)
Understanding Struct Tags (4:17)
Interfaces & Generic Code
Module Introduction (0:25)
Preparing An Interface Use-Case (3:36)
Finishing Interface Preparations (3:10)
Creating a First Interface (5:16)
Using The Interface (5:16)
Embedded Interfaces (6:09)
The Special "Any Value Allowed" Type (2:07)
Working with Type Switches (3:36)
Extracting Type Information From Values (5:13)
Interfaces, Dynamic Types & Limitations (3:57)
Introducing Generics (5:31)
Managing Related Data with Arrays, Slices & Maps
Introducing Arrays (8:02)
Module Introduction (1:19)
Working with Arrays (6:20)
Selecting Parts of Arrays With Slices (3:25)
More Ways Of Selecting Slices (4:29)
Diving Deeper Into Slices (9:41)
Building Dynamic Lists With Slices (9:23)
Exercise - Problem (4:12)
Exercise - Solution (19:59)
Unpacking List Values (3:29)
Introducing Maps (6:42)
Mutating Maps (3:43)
Maps vs Structs (3:59)
Using The Special "make" Function (7:10)
"make"ing Maps (3:08)
Working with Type Aliases (2:33)
For Loops with Arrays, Slices & Maps (5:24)
Functions: Deep Dive
Module Introduction (1:04)
Functions as Values & Function Types (15:07)
Returning Functions As Values (6:20)
Introducing Anonymous Functions (6:34)
Understanding Closures (6:44)
Making Sense Of Recursion (11:22)
Using Variadic Functions (6:49)
Splitting Slices Into Parameter Values (3:04)
Practice Project: Price Calculator
Module Introduction (1:45)
Building a First, Basic Version Of The Program (9:45)
Setting Up A First Struct (3:40)
Adding a Constructor Function (3:05)
Adding a Method (7:08)
Loading Data From A File (8:13)
Working With The File Data (7:13)
Outsourcing Sharable Logic Into A Package (5:27)
Outsourcing File Access Into A Package (5:39)
Storing JSON Data In Files (8:35)
Adding a FileManager Struct (8:16)
Adding & Using Struct Tags (2:46)
Working on a Swappable Struct (7:55)
Interfaces To The Rescue (4:28)
Error Handling (2:53)
Module Summary (1:13)
Concurrency - Running Tasks In Parallel
Introducing Goroutines (1:43)
Module Introduction (0:52)
Running Functions As Goroutines (3:18)
Understanding Goroutine Behavior (1:42)
Introducing & Using Channels (4:28)
Working with Multiple Channels & Goroutines (8:34)
Goroutines & Channels in a Project (9:57)
Setting Up An Error Channel (3:27)
Managing Channels with the "select" Statement (5:46)
Deferring Code Execution with "defer" (2:38)
Course Project: Build a REST API (incl. Authentication & SQL Database)
Module Introduction (1:27)
Planning The API (4:09)
Installing the Gin Framework (2:17)
Setting Up A First Route & Handling a First Request (11:54)
Setting Up An Event Model (4:05)
Registering a POST Route (8:45)
Testing Requests & Fixing the POST Request Handler (7:01)
Adding a SQL Database (8:27)
Creating A SQL Database Table (5:49)
Storing Data in the Database (INSERT) (6:32)
Getting Events From Database (SELECT) (8:31)
Preparing Statements vs Directly Executing Queries (Prepare() vs Exec()/Query())
Getting Single Event Data By ID (12:09)
Refactoring Code & Outsourcing Routes (4:01)
Registering an "Update Event" Route & Handler (4:46)
Updating Events (8:00)
Deleting Events (5:49)
Adding a "Users" Table To The SQL Database (4:14)
Adding User Signup (8:31)
Don't Store Plain-text Passwords! (1:18)
Hashing Passwords (5:01)
Getting Started with Auth Tokens (JWT) (2:23)
Getting Started with the Login Route (10:25)
Finishing The Login Logic (5:12)
Generating JWT (7:53)
Finishing The JWT Logic (4:22)
Adding Token Verification (14:32)
Adding Route Protection (5:16)
Retrieving & Storing User and Event IDs (7:59)
Adding an Authentication Middleware (3:51)
Enhancing & Using The Middleware (7:27)
Adding Authorization To Restrict Users From Editing & Deleting (5:58)
Adding a Registrations Table (3:02)
Registering Users (7:39)
Testing & Fixing the "Register" Route (2:49)
Cancelling Registrations (5:19)
Module Summary (1:01)
Course Roundup
Course Roundup (0:50)
Structs, Packages & Exports
Lesson content locked
If you're already enrolled,
you'll need to login
.
Enroll in Course to Unlock