Top 9 Recommended Go Self-Study Materials! [November 2024]

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 Overview

This 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:

1. Go Fundamentals: Dive deep into Go syntax, variables, types, and control structures.

2. Concurrent Programming: Unravel the power of Go's concurrency model with goroutines and channels.

3. Complex Data Structures: Master arrays, slices, maps, and struct types for efficient data manipulation.

4. Advanced Features: Explore interfaces, error handling, and package management.

5. Real-World Applications: Build practical, real-world applications to consolidate your learning.

6. Optimization Techniques: Learn best practices and optimization techniques for writing efficient Go code.

In this course, you'll learn about all those core Go concepts by building multiple demo projects - including a complete REST API with user authentication & SQL database access!

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 API

• Certificate 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.

1. Getting Started
2. Welcome To The Course!
3. What Is Go? And Why Is It Awesome?
4. Installing Go (Alternative: Web-based Setup)
5. Local Code Editor Setup For Go Development
6. Writing a First Go Program
7. About The Course & Course Content
8. How To Get The Most Out Of This Course
9. Join Our Learning Community
10. Course Setup
11. Go Essentials
12. Module Introduction
13. Working with Functions & Values
14. Organizing Code with Packages
15. The Important Of The Name "main"
16. Understanding Go Modules & Building Go Programs
17. The "main" Function Is Important!
18. Onwards To A New Project
19. Working with Variables, Values & Operators
20. Understanding Value Types
21. Go Types & Null Values
22. Outputting Values
23. Type Conversions & Explicit Type Assignment
24. Using Alternative Variable Declaration Styles
25. Making Sense of Constant Values ("Constants")
26. Understanding the Importance Of Variables
27. Improved User Input Fetching
28. fmt.Scan() Limitations
29. Exercise: Building a Profit Calculator
30. Exercise Solution
31. Formatting Strings (Text) - Basics
32. Formatting Floats in Strings
33. Creating Formatted Strings
34. Building Multiline Strings
35. Understanding Functions
36. Functions: Return Values & Variable Scope
37. An Alternative Return Value Syntax
38. Exercise: Working with Functions
39. Onwards to Control Structures
40. Introducing "if" Statements & Booleans
41. Working with "else if"
42. Exercise: "if" Statements
43. Using "else"
44. Nested "if" Statements & Using "return" To Stop Function Execution
45. Repeating Code With "for" Loops
46. Infinite Loops, "break" & "continue"
47. Conditional For Loops
48. Making Sense of "switch" Statements
49. Writing To Files
50. Reading From Files
51. Handling Errors
52. Time to Panic!
53. Section Exercise - The Task
54. Section Exercise - Solution
55. Module Summary
56. Working with Packages
57. Module Introduction
58. Splitting Code Across Files In The Same Package
59. Why Would You Use More Than One Package?
60. Preparing Code For Multiple Packages
61. Splitting Code Across Multiple Packages
62. Importing Packages
63. Exporting & Importing Identifiers (Variables, Functions & More)
64. Using Third-Party Packages
65. Module Summary
66. Understanding Pointers
67. Module Introduction
68. Understanding Pointers
69. Writing Code Without Pointers
70. Creating a Pointer
71. Pointers as Values
72. A Pointer's Null Value
73. Using Pointers & Passing Pointers To Functions
74. Using Pointers For Data Mutation
75. Example: The Scan() Function Uses Pointers
76. Module Summary
77. Structs & Custom Types
78. Module Introduction
79. The Starting Project
80. Which Problem Do Structs Solve?
81. Defining A Struct Type
82. Instantiating Structs & Struct Literal Notation
83. Alternative Struct Literal Notation & Struct Null Values
84. Passing Struct Values As Arguments
85. Structs & Pointers
86. Introducing Methods
87. Mutation Methods
88. Using Creation / Constructor Functions
89. Using Constructor Functions For Validation
90. Structs, Packages & Exports
91. Exposing Methods & A Different Constructor Function Name
92. Struct Embedding
93. Structs - A Summary
94. Creating Other Custom Types & Adding Methods
95. Practice Project: Getting User Input
96. Practice Project: Creating a Struct & Constructor Function
97. Practice Project: Adding a Method
98. Practice Project: Handling Long User Input Text
99. Practice Project: Preparing Save To File Functionality
100. Practice Project: Encoding JSON Content
101. Practice Project: Fixes
102. Understanding Struct Tags
103. Interfaces & Generic Code
104. Module Introduction
105. Preparing An Interface Use-Case
106. Finishing Interface Preparations
107. Creating a First Interface
108. Using The Interface
109. Embedded Interfaces
110. The Special "Any Value Allowed" Type
111. Working with Type Switches
112. Extracting Type Information From Values
113. Interfaces, Dynamic Types & Limitations
114. Introducing Generics
115. Managing Related Data with Arrays, Slices & Maps
116. Module Introduction
117. Introducing Arrays
118. Working with Arrays
119. Selecting Parts of Arrays With Slices
120. More Ways Of Selecting Slices
121. Diving Deeper Into Slices
122. Building Dynamic Lists With Slices
123. Exercise - Problem
124. Exercise - Solution
125. Unpacking List Values
126. Introducing Maps
127. Mutating Maps
128. Maps vs Structs
129. Using The Special "make" Function
130. "make"ing Maps
131. Working with Type Aliases
132. For Loops with Arrays, Slices & Maps
133. Functions: Deep Dive
134. Module Introduction
135. Functions as Values & Function Types
136. Returning Functions As Values
137. Introducing Anonymous Functions
138. Understanding Closures
139. Making Sense Of Recursion
140. Using Variadic Functions
141. Splitting Slices Into Parameter Values
142. Practice Project: Price Calculator
143. Module Introduction
144. Building a First, Basic Version Of The Program
145. Setting Up A First Struct
146. Adding a Constructor Function
147. Adding a Method
148. Loading Data From A File
149. Working With The File Data
150. Outsourcing Sharable Logic Into A Package
151. Outsourcing File Access Into A Package
152. Storing JSON Data In Files
153. Adding a FileManager Struct
154. Adding & Using Struct Tags
155. Working on a Swappable Struct
156. Interfaces To The Rescue
157. Error Handling
158. Module Summary
159. Concurrency - Running Tasks In Parallel
160. Module Introduction
161. Introducing Goroutines
162. Running Functions As Goroutines
163. Understanding Goroutine Behavior
164. Introducing & Using Channels
165. Working with Multiple Channels & Goroutines
166. Goroutines & Channels in a Project
167. Setting Up An Error Channel
168. Managing Channels with the "select" Statement
169. Deferring Code Execution with "defer"
170. Course Project: Build a REST API (incl. Authentication & SQL Database)
171. Module Introduction
172. Planning The API
173. Installing the Gin Framework
174. Setting Up A First Route & Handling a First Request
175. Setting Up An Event Model
176. Registering a POST Route
177. Testing Requests & Fixing the POST Request Handler
178. Initializing A Database
179. Adding a SQL Database
180. Creating A SQL Database Table
181. Storing Data in the Database (INSERT)
182. Getting Events From Database (SELECT)
183. Preparing Statements vs Directly Executing Queries (Prepare() vs Exec()/Query())
184. Getting Single Event Data By ID
185. Refactoring Code & Outsourcing Routes
186. Registering an "Update Event" Route & Handler
187. Updating Events
188. Deleting Events
189. Adding a "Users" Table To The SQL Database
190. Adding User Signup
191. Don't Store Plain-text Passwords!
192. Hashing Passwords
193. Getting Started with Auth Tokens (JWT)
194. Getting Started with the Login Route
195. Finishing The Login Logic
196. Generating JWT
197. Finishing The JWT Logic
198. Adding Token Verification
199. Adding Route Protection
200. Retrieving & Storing User and Event IDs

Go is an open source programming language created by Google.  As one of the fastest growing languages in terms of popularity, its a great time to pick up the basics of Go!

This course is designed to get you up and running as fast as possible with Go.  We'll quickly cover the basics, then dive into some of the more advanced features of the language.  Don't be tricked by other courses that only teach you for-loops and if-statements!  This is the only course on Udemy that will teach you how to use the full power of Go's concurrency model and interface type systems.

Go is designed to be easy to pick up, but tough to master.  Through multiple projects, quizzes, and assignments, you'll quickly start to master the language's quirks and oddities.  Go is like any other language - you have to write code to learn it!  This course will give you ample opportunities to strike out on your own and start working on your own programs.

In this course you will:

• Understand the basic syntax and control structures of the language
• Apply Go's concurrency model to build massively parallel systems
• Grasp the purpose of types, which is especially important if you're coming from a dynamically typed language like Javascript or Ruby
• Organize code through the use of packages
• Use the Go runtime to build and compile projects
• Get insight into critical design decisions in the language
• Gain a sense of when to use basic language features

Go is one of the fastest-growing programming languages released in the last ten years.  Get job-ready with Go today by enrolling now!

1. Getting Started
2. How to Get Help
3. Course Resources
4. Environment Setup
5. VSCode Installation
6. Go Support in VSCode
7. Gopls, undeclared name, type and module errors in VSCode
8. A Simple Start
9. Boring Ol' Hello World
10. Five Important Questions
11. Go Packages
12. Import Statements
13. File Organization
14. Test Your Knowledge: Packages
15. How to Access Course Diagrams
16. Deeper Into Go
17. Project Overview
18. New Project Folder
19. Variable Declarations
20. Test Your Knowledge: Variable Assignment
21. Functions and Return Types
22. Test Your Knowledge: Functions
23. Slices and For Loops
24. Test Your Knowledge: Slices and For Loops
25. OO Approach vs Go Approach
26. Custom Type Declarations
27. Receiver Functions
28. Test Your Knowledge: Functions with Receivers
29. Creating a New Deck
30. Slice Range Syntax
31. Multiple Return Values
32. Test Your Knowledge: Multiple Return Values
33. Byte Slices
34. Deck to String
35. Joining a Slice of Strings
36. Saving Data to the Hard Drive
37. Reading From the Hard Drive
38. Error Handling
39. Shuffling a Deck
40. Random Number Generation
41. Creating a go.mod File
42. Testing With Go
43. Errorf call has arguments but no formatting directives
44. Writing Useful Tests
45. Asserting Elements in a Slice
46. Testing File IO
47. Project Review
48. Assignment: Even or Odd?
49. Even or Odd Solution
50. Organizing Data With Structs
51. Structs in Go
52. Defining Structs
53. Declaring Structs
54. Updating Struct Values
55. Embedding Structs
56. Structs with Receiver Functions
57. Pass By Value
58. Structs with Pointers
59. Pointer Operations
60. Pointer Shortcut
61. Gotchas With Pointers
62. Test Your Knowledge: Pointers
63. Reference vs Value Types
64. Test Your Knowledge: Value vs Reference Types
65. Maps
66. What's a Map?
67. Manipulating Maps
68. Iterating Over Maps
69. Differences Between Maps and Structs
70. Test Your Knowledge: Maps
71. Interfaces
72. Purpose of Interfaces
73. Problems Without Interfaces
74. Interfaces in Practice
75. Rules of Interfaces
76. Extra Interface Notes
77. The HTTP Package
78. Reading the Docs
79. More Interface Syntax
80. Interface Review
81. The Reader Interface
82. More on the Reader Interface
83. Working with the Read Function
84. The Writer Interface
85. The io.Copy Function
86. The Implementation of io.Copy
87. A Custom Writer
88. Test Your Knowledge: Interfaces
89. Assignment: Interfaces
90. Interfaces Solution
91. Assignment: Hard Mode Interfaces
92. Hard Mode Interfaces Solution
93. Channels and Go Routines
94. Website Status Checker
95. Printing Site Status
96. Serial Link Checking
97. Go Routines
98. Theory of Go Routines
99. Channels
100. Channel Implementation
101. Blocking Channels
102. Receiving Messages
103. Repeating Routines
104. Alternative Loop Syntax
105. Sleeping a Routine
106. Function Literals
107. Channels Gotcha!
108. Channels and Go Routines
109. Extras
110. Bonus!

This course is the ultimate comprehensive resource for learning the Go Programming Language.

This course is perfect for both beginners and experienced developers. The course is full of examples, hands-on exercises, solutions to the hands-on exercises, and an amazing code repository.

This course is taught by one of the world's leading Go Programming Trainers, Todd McLeod. Todd was the first university professor in America to teach Go at the university level. Todd has taught over 3.25 Million students how to use the Go Programming Language. This course is tried, tested, and proven to train beginners and experienced developers how to use Go. 

This course has a tremendous amount of content and resources so that you can learn everything you need to know - whatever is appropriate for your ability level.

When you enroll in this course, you will have lifetime access to the course. You will be able to learn at your own pace. You will always be able to come back to the content to review it, or learn additional concepts when you are ready for them.

This course also comes with a 100% Satisfaction Money Back Guarantee.

I know that this is absolutely the best course in the entire world for learning the Go Programming Language.

I know that you are going to be completely satisfied with the course.

And, if for any reason the course does not work for you, then within the first 14 days, you can receive a full refund.

So enroll now!

You will get great value from this course and, more importantly, you will have a great time learning the greatest programming language every made - The Go Programming Language - The fastest growing, highest paying programming language in America.

Join me on this incredible journey. Sign-up Today.

Go is an open source programming language that makes it easy to build simple, reliable, and efficient software.

Go is an amazing choice for a language as it was developed by some of the same individuals who created the C programming language, Unix, and UTF-8 - some of the most influential contributions to computer science. Robert Griesemer, Rob Pike, and Ken Thompson created Go to be a modern language that easily uses multiple cores, easily implements concurrency, easily works in distributed environments, and easily allows the programmer to write programs - it has a very lean and user-friendly syntax.

Go was created by luminaries in computer science at one of the best, if not the very best, software engineering firm to have ever existed - Google.

The credentials of Go are unsurpassed.

But why did Google create a new language?

In Google’s words, “Go was born out of frustration with existing languages and environments for systems programming. Programming had become too difficult and the choice of languages was partly to blame. One had to choose either efficient compilation, efficient execution, or ease of programming; all three were not available in the same mainstream language. Programmers who could were choosing ease over safety and efficiency by moving to dynamically typed languages such as Python and JavaScript rather than C++ or, to a lesser extent, Java. Go is an attempt to combine the ease of programming of an interpreted, dynamically typed language with the efficiency and safety of a statically typed, compiled language. It also aims to be modern, with support for networked and multicore computing. Finally, working with Go is intended to be fast: it should take at most a few seconds to build a large executable on a single computer. To meet these goals required addressing a number of linguistic issues: an expressive but lightweight type system; concurrency and garbage collection; rigid dependency specification; and so on. These cannot be addressed well by libraries or tools; a new language was called for.”

In my opinion, Go is the best programming language that you can be learning today. I began programming in 1982 with BASIC, I have worked with many languages, and Go is the best language which I have ever used. Go is also the top-paid programming language in America today.

Come learn about the greatest programming language ever created. You will leave with resources and code samples to start making all of your software and apps really go.

1. Course introduction
2. Welcome
3. Course resources
4. Additional resources
5. The Power of Education to Transform Lives
6. Getting going with Go
7. Why Go?
8. Documentation & example code
9. Creating our first go program - hello gophers!
10. Exploring format printing and documentation
11. How computers work - core principles
12. ASCII, Unicode, & UTF-8 - understanding text
13. String literals and documentation
14. Hands-on exercises
15. Preface for Hands-on exercise #1
16. Hands-on exercise #1
17. The fundamentals of Go
18. Variables, zero values, blank identifier
19. Using printf for decimal & hexadecimal values
20. Numeral systems: decimal, binary, & hexadecimal
21. Values, types, conversion, scope, & housekeeping
22. Built-in types, aggregate types, and composition
23. Hands-on exercises
24. Hands-on exercise #2 - go tour step 1 - 3
25. Hands-on exercise #3 - go tour step 4 - 7
26. Hands-on exercise #4 - go tour step 8 - 10
27. Hands-on exercise #5 - go tour step 11 - 13
28. Hands-on exercise #6 - go tour step 14 - 15
29. Hands-on exercise #7 - go tour step 16 - 17 - bitwise ops & bit shifting
30. Hands-on exercise #8 (was #03) - iota
31. Hands-on exercise #9 (was #04) - measuring bits with bitwise operations
32. Hands-on exercise #10 (was #05) - zero value, :=, type specificity, blank identi
33. Hands-on exercise #11 (was #06) - printf verbs to show values and types
34. Hands-on exercise #12 (was #07) - printf binary, decimal, & hexadecimal
35. Hands-on exercise #13 (was #08) - signed and unsigned int
36. Programming fundamentals for beginners
37. Introduction
38. Terminology
39. Understanding scope
40. Working at the terminal
41. Using bash on Windows
42. Terminal commands - part 1
43. Terminal commands - part 2
44. Github and ssh authentication
45. Setting up a github repo
46. Checksums
47. Your development environment
48. Getting up and running
49. Running go programs on your machine
50. Go install puts binary in $GOPATH/bin
51. Go mod and dependency management
52. Introduction to go modules & dependency management
53. Modular code, dependency mgmt, go get - overview
54. Go modules in action: go mod init & go mod tidy
55. Looking at the documentation for go mod tidy
56. Package visibility: visible, not visible; exported, not exported
57. Modular code, dependency mgmt, go get - #1
58. Modular code, dependency mgmt, go get - #2
59. Tag git commits with version - overview
60. Tag git commits with version - example #1
61. Tag git commits with version - example #2
62. Specifying dependency version
63. Hands-on exercises
64. Hands-on exercise #14 (was #09)
65. Hands-on exercise #15 (was #10)
66. Hands-on exercise #16 (was #11)
67. Hands-on exercise #17 (was #12)
68. Hands-on exercise #18 (was #13)
69. Hands-on exercise #19 (was #14)
70. Hands-on exercise #20 (was #15)
71. Hands-on exercise #21 (was #16)
72. Hands-on exercise #22 & git clone (was #17)
73. Housekeeping - Hash Algorithms, Symmetric & Asymmetric Encryption, Communication
74. Hash Algorithms, Symmetric & Asymmetric Encryption, & Network Communication
75. Control Flow
76. Previewing code
77. Understanding control flow
78. If statements & comparison operators
79. Understanding & using Logical operators
80. The "statement; statement" & "comma, ok" idioms
81. Using switch statements to make decisions in code
82. Using select statements for concurrency communication
83. Understanding & using for statement to create loops
84. Multiple iteration - nesting a loop within a loop
85. Understanding & using for range loops
86. Finding a modulus / remainder
87. Hands-on exercises
88. Hands-on exercise #23 (was #18)
89. Hands-on exercise #24 (was #19)
90. Hands-on exercise #25 (was #20)
91. Hands-on exercise #26 (was #21)
92. Hands-on exercise #27 (was #22)
93. Hands-on exercise #28 (was #23)
94. Hands-on exercise #29 (was #24)
95. Hands-on exercise #30 (was #25)
96. Hands-on exercise #31 (was #26) & infinite loops
97. Hands-on exercise #32 (was #27)
98. Hands-on exercise #33 (was #28) & a joke
99. Hands-on exercise #34 (was #29)
100. Hands-on exercise #35 (was #30)
101. Hands-on exercise #36 (was #31)
102. Hands-on exercise #37 (was #32)
103. Hands-on exercise #38 (was #33)
104. Hands-on exercise #39 (was #34)
105. Additional code
106. Grouping data values - array & slice
107. Review and preview
108. Introduction to grouping values
109. Array - an introduction to arrays
110. Hands-on exercise #40
111. Slice - composite literal
112. Hands-on exercise #41
113. Slice - for range & access values by index position
114. Slice - append to a slice
115. Slice - slicing a slice
116. Slice - deleting from a slice
117. Slice - make
118. Slice - multidimensional slice
119. Slice - slice internals & underlying array - 01
120. Slice - slice internals & underlying array - 02
121. Slice - slice internals & underlying array - 03
122. Hands-on exercises
123. Hands-on exercise #42
124. Hands-on exercise #43
125. Hands-on exercise #44
126. Hands-on exercise #45
127. Hands-on exercise #46
128. Hands-on exercise #47
129. Hands-on exercise #48
130. Grouping data values - map
131. Map - introduction
132. Map - for range over a map
133. Map - delete element
134. Map - comma ok idiom
135. Map - counting words in a book
136. Hands-on exercises
137. Hands-on exercise #49 - map[string][]string
138. Hands-on exercise #50 - add a record
139. Hands-on exercise #51 - delete a record
140. Hands-on exercise #52 - word frequency
141. Grouping data values - structs
142. Struct introduction
143. Embedded structs
144. Anonymous structs
145. Composition
146. Hands-on exercises
147. Hands-on exercise #53 - struct with slice
148. Hands-on exercise #54 - map struct
149. Hands-on exercise #55 - embed struct
150. Hands-on exercise #56 - anonymous struct
151. Functions in the go programming language
152. Introduction to functions
153. Syntax of functions in Go
154. Variadic parameter
155. Unfurling a slice
156. Defer
157. Methods
158. Interfaces & polymorphism
159. Exploring the stringer interface
160. Expanding on the stringer interface - wrapper func for logging
161. Writer interface & writing to a file
162. Writer interface & writing to a byte buffer
163. Writing to either a file or a byte buffer
164. Anonymous func
165. func expression
166. Returning a func
167. Callback
168. Closure
169. Function fundamentals
170. Recursion
171. Wrapper function
172. Hands-on exercises
173. Hands-on exercise #57 - func concepts
174. Hands-on exercise #58 - basic funcs
175. Hands-on exercise #59 - variadic func
176. Hands-on exercise #60 - defer func
177. Hands-on exercise #61 - method
178. Hands-on exercise #62 - interfaces
179. Hands-on exercise #63 - tests in go #1
180. Hands-on exercise #64 - tests in go #2 - unit tests
181. Hands-on exercise #65 - tests in go #3 - unit tests
182. Hands-on exercise #66 - documenting code with comments
183. Hands-on exercise #67 - interfaces & mock testing a db
184. Hands-on exercise #68 - anonymous func
185. Hands-on exercise #69 - func expression
186. Hands-on exercise #70 - func return
187. Hands-on exercise #71 - callback
188. Hands-on exercise #72 - closure
189. Hands-on exercise #73 - wrapper
190. Pointers
191. What are pointers?
192. Seeing type & value for pointers
193. Dereferencing pointers
194. Pass by value, pointers / reference types, and mutability
195. Pointer & value semantics defined
196. Pointer & value semantics heuristics
197. Pointers, values, the stack, & the heap
198. Exploring method sets part 1
199. Exploring method sets part 2
200. Hands-on exercises

In this course, you will learn step-by-step how to design, develop and deploy a backend web service from scratch. I believe the best way to learn programming is to build a real application. Therefore, throughout the course, you will learn how to build a backend web service for a simple bank. It will provide APIs for the frontend to do the following things:

• Create and manage bank accounts.

• Record all balance changes to each of the accounts.

• Perform a money transfer between 2 accounts.

The programming language we will use to develop the service is Golang, but the course is not just about coding in Go. You will learn a lot of different topics regarding backend web development. They are presented in 6 sections:

1. In the 1st section, you will learn deeply about how to design the database, generate codes to talk to the DB in a consistent and reliable way using transactions, understand the DB isolation levels, and how to use it correctly in production. Besides the database, you will also learn how to use docker for local development, how to use Git to manage your codes, and how to use GitHub Action to run unit tests automatically.

2. In the 2nd section, you will learn how to build a set of RESTful HTTP APIs using Gin - one of the most popular Golang frameworks for building web services. This includes everything from loading app configs, mocking DB for more robust unit tests, handling errors, authenticating users, and securing the APIs with JWT and PASETO access tokens. 

3. In the 3rd section, you will learn how to build your app with Docker and deploy it to a production Kubernetes cluster on AWS. The lectures are very detailed with a step-by-step guide, from how to build a minimal docker image, set up a free-tier AWS account, create a production database, store and retrieve production secrets, create a Kubernetes cluster with EKS, use GitHub Action to automatically build and deploy the image to the EKS cluster, buy a domain name and route the traffics to the service, secure the connection with HTTPS and auto-renew TLS certificate from Let's Encrypt.

4. In the 4th section, we will discuss several advanced backend topics such as managing user sessions, building gRPC APIs, using gRPC gateway to serve both gRPC and HTTP requests at the same time, embedding Swagger documentation as part of the backend service, partially updating a record using optional parameters, and writing structured logger HTTP middlewares and gRPC interceptors.

5. Then the 5th section will introduce you to asynchronous processing in Golang using background workers and Redis as its message queue. We'll also learn how to create and send emails to users via Gmail SMTP server. Along the way, we'll learn more about writing unit tests for our gRPC services that might involve mocking multiple dependencies at once.

6. The final section 6th concludes the course with lectures about how to improve the stability and security of the server. We'll keep updating dependency packages to the latest version, use Cookies to make the refresh token more secure, and learn how to gracefully shut down the server to protect the processing resources. As this part is still a work in progress, we will keep making and uploading new videos about new topics in the future. So please come back here to check them out from time to time.

This course is designed with a lot of details, so that everyone, even those with very little programming experience can understand and do it by themselves. I firmly believe that after the course, you will be able to work much more confidently and effectively on your projects.

1. Working with database [Postgres + SQLC]
2. Design DB schema and generate SQL code with dbdiagram.io
3. Setup development environment on Windows: WSL2, Go, VSCode, Docker, Make, Sqlc
4. Setup development environment on MacOS: Install Go and Visual Studio Code
5. Use Docker + Postgres + TablePlus to create DB schema
6. How to write & run database migration in Golang
7. Generate CRUD Golang code from SQL | Compare db/sql, gorm, sqlx & sqlc
8. Write SQL queries for transfers and entries table and generate Go code
9. Write unit tests for database CRUD with random data in Golang
10. Configure the right sql_package in your sqlc.yaml file
11. A clean way to implement database transaction in Golang
12. DB transaction lock & How to handle deadlock in Golang
13. How to avoid deadlock in DB transaction? Queries order matters!
14. Deeply understand transaction isolation levels & read phenomena
15. Setup Github Actions for Golang + Postgres to run automated tests
16. Building RESTful HTTP JSON API [Gin + JWT + PASETO]
17. Implement RESTful HTTP API in Go using Gin
18. Load config from file & environment variables in Go with Viper
19. Mock DB for testing HTTP API in Go and achieve 100% coverage
20. Implement transfer money API with a custom params validator
21. Add users table with unique & foreign key constraints in PostgreSQL
22. How to handle DB errors in Golang correctly
23. How to securely store passwords? Hash password in Go with Bcrypt!
24. How to write stronger unit tests with a custom gomock matcher
25. Why PASETO is better than JWT for token-based authentication?
26. How to create and verify JWT & PASETO token in Golang
27. Implement login user API that returns PASETO or JWT access token in Go
28. Implement authentication middleware and authorization rules in Golang using Gin
29. Deploying the application to production [Docker + Kubernetes + AWS]
30. How to build a small Golang Docker image with a multistage Dockerfile
31. How to use docker network to connect 2 stand-alone containers
32. How to write docker-compose file and control service start-up orders
33. How to create a free-tier AWS account
34. Auto build & push docker image to AWS ECR with Github Actions
35. How to create a production database on AWS RDS
36. Store & retrieve production secrets with AWS secrets manager
37. Kubernetes architecture & How to create an EKS cluster on AWS
38. How to use kubectl & k9s to connect to a kubernetes cluster on AWS EKS
39. How to deploy a web app to Kubernetes cluster on AWS EKS
40. Register a domain & set up A-record using Route53
41. How to use Ingress to route traffics to different services in Kubernetes
42. Auto issue & renew TLS certificates with cert-manager and Let's Encrypt
43. Automatic deploy to Kubernetes with Github Action
44. Advanced Backend Topics [Sessions + gRPC]
45. How to manage user session with refresh token
46. Generate DB documentation page and schema SQL dump from DBML
47. Introduction to gRPC
48. Define gRPC API and generate Go code with protobuf
49. How to run a golang gRPC server and call its API
50. Implement gRPC API to create and login users in Go
51. gRPC Gateway: write code once, serve both gRPC & HTTP requests
52. How to extract information from gRPC metadata
53. Automatic generate & serve swagger documentation from Go server
54. Embed static front-end files inside Golang backend server's binary
55. Validate gRPC parameters and send human/machine friendly response
56. Run DB migrations directly inside Golang code
57. Partial update DB record with SQLC nullable arguments
58. Build gRPC update API with optional parameters
59. Add authorization to protect gRPC API
60. Write structured logs for gRPC APIs
61. How to write HTTP logger middleware in Go
62. Asynchronous processing with background workers [Asynq + Redis]
63. Implement background worker with Redis task queue
64. Integrate async worker to Go web server
65. Send async tasks to Redis within a DB transaction
66. How to handle errors and print logs for Async workers
67. Some delay might be good for your async tasks
68. How to send email in Go via Gmail
69. How to skip test in Go and config test flag in vscode
70. Email verification feature: design DB and send email
71. Implement email verification API in Go
72. Unit test gRPC API with mock DB & Redis
73. How to test a gRPC API that requires authentication
74. Improve the stability and security of the server [PGX + RBAC + CORS]
75. Upgrade and config sqlc with version 2 syntax
76. Switch DB driver from lib/pq to pgx
77. How to properly handle DB errors with pgx driver
78. Docker compose: port + volume mapping
79. How to install & use binary packages in Go
80. Implement role-based access control (RBAC) in Go
81. Grant AWS EKS cluster access to Postgres and Redis using security group
82. Deploy gRPC + HTTP server to AWS EKS cluster
83. Don't lose money on AWS
84. Graceful shutdown gRPC/HTTP servers and async worker
85. Go 1.22 fixed the most common for-loop trap
86. How to setup CORS policy in Go
87. Hey, it's not the end yet!
88. What's next?

In this project-based course, we will build a complete REST API in Go from scratch and deploy it to the cloud, ready to handle real traffic and scale affordably.

Our journey begins by creating a simple TCP server, which will help us explore the net/http package in Go and understand the basics of handling network communication.

Next, we’ll dive into the theory behind building reliable and composable Go web applications. From there, we’ll develop our project step-by-step, covering carefully curated topics such as request handling, middleware creation, database integration, request and database optimisations and rate limiting to equip you with the skills needed to ship real backend services to the cloud and manage real-world traffic efficiently.

This course aims to provide you with the foundational knowledge required to build and understand backend systems, implement industry best practices, and create production-ready APIs that are secure, scalable, and maintainable. It is not just a step-by-step tutorial, but a comprehensive learning experience that prepares you for real-world scenarios.

Legal Notice:

All product and company names, logos, and trademarks featured on this thumbnail are the property of their respective owners. Their use in this course does not imply any affiliation, sponsorship, or endorsement by these companies.

1. Introduction
2. Project Overview
3. Why Go with Go?
4. Preface for Udemy Students
5. Course Resources
6. Getting your Tools Ready
7. Project Architecture
8. Design Principles for a REST API
9. Building a server from TCP to HTTP
10. TCP Server - net package
11. Understanding Routing
12. HTTP Server - The net/http package
13. Encoding & Decoding JSON Requests
14. Scaffolding our API Server
15. Setting up your Development Environment
16. Clean Layered Architecture
17. Setting up the HTTP server and API
18. Hot Reloading in Go
19. Environment Variables
20. Databases
21. The Repository Pattern
22. Implementing the Repository Pattern
23. Persisting data with SQL
24. Configuring the DB Connection Pool
25. SQL Migrations
26. Posts CRUD
27. Marshalling JSON responses
28. Creating a User Feed Post
29. Getting a Post From a User
30. Internal Errors Package
31. HTTP Payload Validation
32. DB Relationships & SQL Joins
33. Adding Comments to Posts
34. Updating and Deleting Posts
35. Standardising JSON Responses
36. Optimistic Concurrency Control
37. Managing SQL Query Timeouts
38. Database Seeding
39. Challenge: Create Comments for Posts
40. User Feed
41. Creating the User Profile
42. Adding Followers
43. SQL Indexes
44. User Feed Algorithm
45. Filtering, Sorting, and Pagination
46. Pagination and Sorting
47. Feed Filtering
48. Documentation
49. Auto Generating Docs for the API
50. Documenting the Handlers
51. Structured Logging
52. Adding a Logger
53. User Creation
54. User Registration Overview
55. SQL Transactions
56. User Activation
57. Sending Emails
58. Sending the Invitation Email
59. Improving Further the Email
60. Extra: Building the Confirmation UI
61. Authentication
62. Authentication Overview
63. Basic Authentication
64. Generating Tokens
65. Validating Tokens
66. Challenge: Bug on Token Generation Handler
67. Authorization
68. Authorization Overview
69. Authorization Database Setup
70. Role Precedence Middleware
71. Fixing the User Invitation
72. Redis Caching
73. Designing for Performance
74. Caching the User Profile
75. Invalidating the Cache On Update
76. Testing
77. Testing Overview
78. Testing the User Handler
79. Spies
80. Graceful Shutdown
81. Graceful Server Shutdown
82. Rate Limiting
83. Rate Limiting our API
84. Handling CORS
85. Handling CORS errors
86. Server Metrics
87. Basic Server Metrics
88. Automation (CI/CD)
89. Continuous Integration
90. Changelog
91. Production Deployment
92. Deploying to Google Cloud