Go - The Complete Guide
Learn Go ("Golang") from the ground up & in great depth by building multiple demo projects, incl. a REST API.
About This Course
Welcome to "Go - The Complete Guide"!
Unleash Your Potential - with Go and this course! This definitive online course is meticulously designed for both newcomers and professionals eager to excel in the dynamic realm of Go programming.
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.
That's why I built this course! This course is your comprehensive journey through the world of Go. From basic syntax to advanced features, it covers every aspect needed to master Go programming!
By the end of the course, you'll be able to build scalable, high-performance applications and write efficient, production-ready Go code.
Why Learn Go?
Go combines simplicity with powerful performance, making it perfect for backend development, cloud services, and modern applications. My goal is to ensure that you feel confident building applications with Go, so that you can create scalable systems, enhance your existing projects, or simply boost your portfolio as a developer - whatever your goal is: This course gets you there!
What's in This Course?
This course will teach you WHY Go is a great choice for modern development and introduce you to all the key concepts you'll need - from fundamentals to advanced features.
Go Fundamentals
Dive deep into Go syntax, variables, types, and control structures. Build a solid foundation to understand how Go works and why it's so efficient.
Concurrent Programming
Unravel the power of Go's concurrency model with goroutines and channels. Learn how to write concurrent code that's both efficient and easy to understand.
Complex Data Structures
Master arrays, slices, maps, and struct types for efficient data manipulation. Understand how to organize and manage data effectively in Go.
Advanced Features
Explore interfaces, error handling, and package management. Learn advanced patterns that will make your Go code more maintainable and professional.
In Detail, You'll Learn
This course covers everything you need to master Go programming with multiple demo projects where all concepts are applied step-by-step.
Core Concepts
Master these essential Go skills:
- Go syntax, variables, types & control structures
- Functions, methods & receivers
- Arrays, slices, maps & struct types
- Pointers & memory management
- Error handling & best practices
- Package management & modules
Advanced Topics
Take your skills to the next level:
- Goroutines & concurrent programming
- Channels & synchronization
- Interfaces & polymorphism
- Building REST APIs with Go
- Optimization techniques & best practices
- Building & improving multiple demo projects
Multiple Demo Projects Included!
This course includes multiple demo projects where you'll build real-world applications - including a complete REST API! You'll work with practical patterns and scenarios to ensure you're ready to use Go in your own projects.
No Prior Go Knowledge Required
See The Course In Action
Curriculum
- 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
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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 Prerequisites
Here's what you need to get the most out of this course
- Basic programming experience (with any language, doesn't matter) is strongly recommended.
- NO prior Go knowledge is assumed.
All pre-requisites are covered by courses in our "Academind Pro" Membership.
Your Instructor
Maximilian Schwarzmüller
Founder & Instructor
Self-taught developer with 3,500,000+ students and 900,000 YouTube subscribers. I co-founded Academind with Manuel Lorenz to help people master new skills and build amazing projects.
Join 2838 happy students!
Choose the plan that works best for you
Single-Course License
Full access to "Go - The Complete Guide"
This is a one-time payment that grants access to this course only, not to any other courses.
Academind Pro Membership
Unlimited access to this and all other current & future courses!
This is a recurring payment. You can cancel anytime from your profile. For more info, contact Academind.
Continue Your Learning Journey
Expand your skills with these hand-picked courses that complement what you'll learn here.
