Advanced Golang Training

• Welcome To The Course!

• What Is Go? And Why Is It Awesome?

• Installing Go (Alternative: Web-based Setup)

• Local Code Editor Setup For Go Development

• Writing a First Go Program

• About The Course & Course Content

• Module Introduction

• Working with Functions & Values

• Organizing Code with Packages

• The Important Of The Name

• Understanding Go Modules & Building Go Programs

• The

• Onwards To A New Project

• Working with Variables, Values & Operators

• Understanding Value Types

• Outputting Values

• Type Conversions & Explicit Type Assignment

• Using Alternative Variable Declaration Styles

• Making Sense of Constant Values

• Understanding the Importance Of Variables

• Improved User Input Fetching

• Exercise: Building a Profit Calculator

• Exercise Solution

• Formatting Strings (Text) - Basics

• Formatting Floats in Strings

• Creating Formatted Strings

• Building Multiline Strings

• Understanding Functions

• Functions: Return Values & Variable Scope

• An Alternative Return Value Syntax

• Exercise: Working with Functions

• Onwards to Control Structures

• Introducing

• Working with

• Exercise:

• Using

• Nested

• Repeating Code With

• Infinite Loops,

• Making Sense of

• Writing To Files

• Reading From Files

• Handling Errors

• Time to Panic!

• Section Exercise - The Task

• Section Exercise - Solution

• Module Introduction

• Splitting Code Across Files In The Same Package

• Why Would You Use More Than One Package?

• Preparing Code For Multiple Packages

• Splitting Code Across Multiple Packages

• Importing Packages

• Exporting & Importing Identifiers

• Using Third-Party Packages

• Module Introduction

• The Starting Project

• Which Problem Do Structs Solve?

• Defining A Struct Type

• Instantiating Structs & Struct Literal Notation

• Alternative Struct Literal Notation & Struct Null Values

• Passing Struct Values As Arguments

• Structs & Pointers

• Introducing Methods

• Mutation Methods

• Using Creation / Constructor Functions

• Using Constructor Functions For Validation

• Structs, Packages & Exports

• Exposing Methods & A Different Constructor Function Name

• Struct Embedding

• Structs - A Summary

• Creating Other Custom Types & Adding Methods

• Practice Project: Getting User Input

• Practice Project: Creating a Struct & Constructor Function

• Practice Project: Adding a Method

• Practice Project: Handling Long User Input Text

• Practice Project: Preparing Save To File Functionality

• Practice Project: Encoding JSON Content

• Practice Project: Fixes

• Understanding Struct Tags

• Module Introduction

• Preparing An Interface Use-Case

• Finishing Interface Preparations

• Creating a First Interface

• Using The Interface

• Embedded Interfaces

• The Special

• Working with Type Switches

• Extracting Type Information From Values

• Interfaces, Dynamic Types & Limitations

• Introducing Generics

• Module Introduction

• Introducing Arrays

• Working with Arrays

• Selecting Parts of Arrays With Slices

• More Ways Of Selecting Slices

• Diving Deeper Into Slices

• Building Dynamic Lists With Slices

• Exercise - Problem

• Exercise - Solution

• Unpacking List Values

• Introducing Maps

• Mutating Maps

• Maps vs Structs

• Using The Special

• Working with Type Aliases

• For Loops with Arrays, Slices & Maps

• Module Introduction

• Functions as Values & Function Types

• Returning Functions As Values

• Introducing Anonymous Functions

• Understanding Closures

• Making Sense Of Recursion

• Using Variadic Functions

• Splitting Slices Into Parameter Values

• Module Introduction

• Building a First, Basic Version Of The Program

• Setting Up A First Struct

• Adding a Constructor Function

• Adding a Method

• Loading Data From A File

• Working With The File Data

• Outsourcing Sharable Logic Into A Package

• Outsourcing File Access Into A Package

• Storing JSON Data In Files

• Adding a FileManager Struct

• Adding & Using Struct Tags

• Working on a Swappable Struct

• Interfaces To The Rescue

• Error Handling

• Module Introduction

• Introducing Goroutines

• Running Functions As Goroutines

• Understanding Goroutine Behavior

• Introducing & Using Channels

• Working with Multiple Channels & Goroutines

• Goroutines & Channels in a Project

• Setting Up An Error Channel

• Managing Channels with the

• Deferring Code Execution with

• Module Introduction

• Planning The API

• Installing the Gin Framework

• Setting Up A First Route & Handling a First Request

• Setting Up An Event Model

• Registering a POST Route

• Testing Requests & Fixing the POST Request Handler

• Adding a SQL Database

• Creating A SQL Database Table

• Storing Data in the Database (INSERT)

• Getting Events From Database (SELECT)

• Getting Single Event Data By ID

• Refactoring Code & Outsourcing Routes

• Registering an

• Updating Events

• Deleting Events

• Adding a

• Adding User Signup

• Don't Store Plain-text Passwords!

• Hashing Passwords

• Getting Started with Auth Tokens (JWT)

• Getting Started with the Login Route

• Finishing The Login Logic

• Generating JWT

• Finishing The JWT Logic

• Adding Token Verification

• Adding Route Protection

• Retrieving & Storing User and Event IDs

• Adding an Authentication Middleware

• Enhancing & Using The Middleware

• Adding Authorization To Restrict Users From Editing & Deleting

• Adding a Registrations Table

• Registering Users

• Testing & Fixing the

• Cancelling Registrations