Go - The Complete Guide

Learn Go ("Golang") from the ground up & in great depth by building multiple demo projects, incl. a REST API

What you'll learn

Learn Go from the ground up & in great depth

Learn about values, variables, functions, pointers, packages & more

Learn how to structure and store data with structs, arrays, slices & maps

Work with Go's concurrency features like Goroutines & channels

Build multiple demo projects

Build a REST API with authentication & a SQL database as a major course project

Join more than 2,500,000 students who've been taught by me across all my courses

Requirements

Basic programming experience (with any language, doesn't matter) is strongly recommended

NO prior Go knowledge is assumed

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.Course OverviewThis course is your comprehensive journey through the world of Go. From basic syntax to advanced features, this course covers every aspect needed to master Go. Here's what you'll learn:Go Fundamentals: Dive deep into Go syntax, variables, types, and control structures.Concurrent Programming: Unravel the power of Go's concurrency model with goroutines and channels.Complex Data Structures: Master arrays, slices, maps, and struct types for efficient data manipulation.Advanced Features: Explore interfaces, error handling, and package management.Real-World Applications: Build practical, real-world applications to consolidate your learning.Optimization Techniques: Learn best practices and optimization techniques for writing efficient Go code.Who Should Enroll?This course is tailored for:Developers looking to add a powerful language to their toolkit.Backend engineers aspiring to build scalable, high-performance applications.Professionals seeking a deep, practical understanding of Go.Why Choose This Course?Expert Instruction: Learn from an experienced Go developer & bestselling online course instructor.Flexible Learning: Access the course anytime, anywhere, at your pace.Demo Projects: Apply your knowledge by building multiple demo projects - e.g., a complete REST APICertificate of Completion: Earn a certificate to showcase your newfound Go expertise.Ready to Go?Embark on your journey to mastering Go. Enroll now and transform your career with the power of Go programming.

Overview

Section 1: Getting Started

Lecture 1 Welcome To The Course!

Lecture 2 What Is Go? And Why Is It Awesome?

Lecture 3 Installing Go (Alternative: Web-based Setup)

Lecture 4 Local Code Editor Setup For Go Development

Lecture 5 Writing a First Go Program

Lecture 6 About The Course & Course Content

Lecture 7 How To Get The Most Out Of This Course

Lecture 8 Join Our Learning Community

Section 2: Go Essentials

Lecture 9 Module Introduction

Lecture 10 Working with Functions & Values

Lecture 11 Organizing Code with Packages

Lecture 12 The Important Of The Name "main"

Lecture 13 Understanding Go Modules & Building Go Programs

Lecture 14 The "main" Function Is Important!

Lecture 15 Onwards To A New Project

Lecture 16 Working with Variables, Values & Operators

Lecture 17 Understanding Value Types

Lecture 18 Go Types & Null Values

Lecture 19 Outputting Values

Lecture 20 Type Conversions & Explicit Type Assignment

Lecture 21 Using Alternative Variable Declaration Styles

Lecture 22 Making Sense of Constant Values ("Constants")

Lecture 23 Understanding the Importance Of Variables

Lecture 24 Improved User Input Fetching

Lecture 25 fmt.Scan() Limitations

Lecture 26 Exercise: Building a Profit Calculator

Lecture 27 Exercise Solution

Lecture 28 Formatting Strings (Text) - Basics

Lecture 29 Formatting Floats in Strings

Lecture 30 Building Multiline Strings

Lecture 31 Creating Formatted Strings

Lecture 32 Understanding Functions

Lecture 33 Functions: Return Values & Variable Scope

Lecture 34 An Alternative Return Value Syntax

Lecture 35 Exercise: Working with Functions

Lecture 36 Onwards to Control Structures

Lecture 37 Introducing "if" Statements & Booleans

Lecture 38 Working with "else if"

Lecture 39 Exercise: "if" Statements

Lecture 40 Using "else"

Lecture 41 Nested "if" Statements & Using "return" To Stop Function Execution

Lecture 42 Repeating Code With "for" Loops

Lecture 43 Infinite Loops, "break" & "continue"

Lecture 44 Conditional For Loops

Lecture 45 Making Sense of "switch" Statements

Lecture 46 Writing To Files

Lecture 47 Reading From Files

Lecture 48 Handling Errors

Lecture 49 Time to Panic!

Lecture 50 Section Exercise - The Task

Lecture 51 Section Exercise - Solution

Lecture 52 Module Summary

Section 3: Working with Packages

Lecture 53 Module Introduction

Lecture 54 Splitting Code Across Files In The Same Package

Lecture 55 Why Would You Use More Than One Package?

Lecture 56 Preparing Code For Multiple Packages

Lecture 57 Splitting Code Across Multiple Packages

Lecture 58 Importing Packages

Lecture 59 Exporting & Importing Identifiers (Variables, Functions & More)

Lecture 60 Using Third-Party Packages

Lecture 61 Module Summary

Section 4: Understanding Pointers

Lecture 62 Module Introduction

Lecture 63 Understanding Pointers

Lecture 64 Writing Code Without Pointers

Lecture 65 Creating a Pointer

Lecture 66 Pointers as Values

Lecture 67 A Pointer's Null Value

Lecture 68 Using Pointers & Passing Pointers To Functions

Lecture 69 Using Pointers For Data Mutation

Lecture 70 Example: The Scan() Function Uses Pointers

Lecture 71 Module Summary

Section 5: Structs & Custom Types

Lecture 72 Module Introduction

Lecture 73 The Starting Project

Lecture 74 Which Problem Do Structs Solve?

Lecture 75 Defining A Struct Type

Lecture 76 Instantiating Structs & Struct Literal Notation

Lecture 77 More On Struct Literals

Lecture 78 Alternative Struct Literal Notation & Struct Null Values

Lecture 79 Passing Struct Values As Arguments

Lecture 80 Structs & Pointers

Lecture 81 Introducing Methods

Lecture 82 Mutation Methods

Lecture 83 Using Creation / Constructor Functions

Lecture 84 Using Constructor Functions For Validation

Lecture 85 Structs, Packages & Exports

Lecture 86 Exposing Methods & A Different Constructor Function Name

Lecture 87 Struct Embedding

Lecture 88 Structs - A Summary

Lecture 89 Creating Other Custom Types & Adding Methods

Lecture 90 Practice Project: Getting User Input

Lecture 91 Practice Project: Creating a Struct & Constructor Function

Lecture 92 Practice Project: Adding a Method

Lecture 93 Practice Project: Handling Long User Input Text

Lecture 94 Practice Project: Preparing Save To File Functionality

Lecture 95 Practice Project: Encoding JSON Content

Lecture 96 Practice Project: Fixes

Lecture 97 Understanding Struct Tags

Section 6: Interfaces & Generic Code

Lecture 98 Module Introduction

Lecture 99 Preparing An Interface Use-Case

Lecture 100 Finishing Interface Preparations

Lecture 101 Creating a First Interface

Lecture 102 Using The Interface

Lecture 103 Embedded Interfaces

Lecture 104 The Special "Any Value Allowed" Type

Lecture 105 Working with Type Switches

Lecture 106 Extracting Type Information From Values

Lecture 107 Interfaces, Dynamic Types & Limitations

Lecture 108 Introducing Generics

Section 7: Managing Related Data with Arrays, Slices & Maps

Lecture 109 Module Introduction

Lecture 110 Introducing Arrays

Lecture 111 Working with Arrays

Lecture 112 Selecting Parts of Arrays With Slices

Lecture 113 More Ways Of Selecting Slices

Lecture 114 Diving Deeper Into Slices

Lecture 115 Building Dynamic Lists With Slices

Lecture 116 Exercise - Problem

Lecture 117 Exercise - Solution

Lecture 118 Unpacking List Values

Lecture 119 Introducing Maps

Lecture 120 Mutating Maps

Lecture 121 Maps vs Structs

Lecture 122 Using The Special "make" Function

Lecture 123 "make"ing Maps

Lecture 124 Working with Type Aliases

Lecture 125 For Loops with Arrays, Slices & Maps

Section 8: Functions: Deep Dive

Lecture 126 Module Introduction

Lecture 127 Functions as Values & Function Types

Lecture 128 Returning Functions As Values

Lecture 129 Introducing Anonymous Functions

Lecture 130 Understanding Closures

Lecture 131 Making Sense Of Recursion

Lecture 132 Using Variadic Functions

Lecture 133 Splitting Slices Into Parameter Values

Section 9: Practice Project: Price Calculator

Lecture 134 Module Introduction

Lecture 135 Building a First, Basic Version Of The Program

Lecture 136 Setting Up A First Struct

Lecture 137 Adding a Constructor Function

Lecture 138 Adding a Method

Lecture 139 Loading Data From A File

Lecture 140 Working With The File Data

Lecture 141 Outsourcing Sharable Logic Into A Package

Lecture 142 Outsourcing File Access Into A Package

Lecture 143 Storing JSON Data In Files

Lecture 144 Adding a FileManager Struct

Lecture 145 Adding & Using Struct Tags

Lecture 146 Working on a Swappable Struct

Lecture 147 Interfaces To The Rescue

Lecture 148 Error Handling

Lecture 149 Module Summary

Section 10: Concurrency - Running Tasks In Parallel

Lecture 150 Module Introduction

Lecture 151 Introducing Goroutines

Lecture 152 Running Functions As Goroutines

Lecture 153 Understanding Goroutine Behavior

Lecture 154 Introducing & Using Channels

Lecture 155 Working with Multiple Channels & Goroutines

Lecture 156 Goroutines & Channels in a Project

Lecture 157 Setting Up An Error Channel

Lecture 158 Managing Channels with the "select" Statement

Lecture 159 Deferring Code Execution with "defer"

Section 11: Course Project: Build a REST API (incl. Authentication & SQL Database)

Lecture 160 Module Introduction

Lecture 161 Planning The API

Lecture 162 Installing the Gin Framework

Lecture 163 Setting Up A First Route & Handling a First Request

Lecture 164 Setting Up An Event Model

Lecture 165 Registering a POST Route

Lecture 166 Testing Requests & Fixing the POST Request Handler

Lecture 167 Adding a SQL Database

Lecture 168 Creating A SQL Database Table

Lecture 169 Storing Data in the Database (INSERT)

Lecture 170 Getting Events From Database (SELECT)

Lecture 171 Preparing Statements vs Directly Executing Queries (Prepare() vs Exec()/Query())

Lecture 172 Getting Single Event Data By ID

Lecture 173 Refactoring Code & Outsourcing Routes

Lecture 174 Registering an "Update Event" Route & Handler

Lecture 175 Updating Events

Lecture 176 Deleting Events

Lecture 177 Adding a "Users" Table To The SQL Database

Lecture 178 Adding User Signup

Lecture 179 Don't Store Plain-text Passwords!

Lecture 180 Hashing Passwords

Lecture 181 Getting Started with Auth Tokens (JWT)

Lecture 182 Getting Started with the Login Route

Lecture 183 Finishing The Login Logic

Lecture 184 Generating JWT

Lecture 185 Finishing The JWT Logic

Lecture 186 Adding Token Verification

Lecture 187 Adding Route Protection

Lecture 188 Retrieving & Storing User and Event IDs

Lecture 189 Adding an Authentication Middleware

Lecture 190 Enhancing & Using The Middleware

Lecture 191 Adding Authorization To Restrict Users From Editing & Deleting

Lecture 192 Adding a Registrations Table

Lecture 193 Registering Users

Lecture 194 Testing & Fixing the "Register" Route

Lecture 195 Cancelling Registrations

Lecture 196 Module Summary

Section 12: Course Roundup

Lecture 197 Course Roundup

Lecture 198 Bonus Lecture

Beginner Go developers who want to learn the language in great depth,Experienced Go developers who need a refresher,Developers who got started with Go and want to dive deeper