Home
Category
Search
Cart
Menu

Find your desired course

Select Your Favourite
Category And Start Learning.

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

As Featured In