Top 9 Recommended Go Self-Study Materials! [September 2023]

Learn to write modern, fast, and secure web applications in Google's Go programming language, and learn it from an award winning University professor with 20 years of teaching experience, and 20 years of experience working in the industry as an entrepreneur.

Go is a modern, type safe, compiled, and extremely fast programming language. It it is ideally suited for building safe, scalable, incredibly fast web applications.

This course is well-suited for both absolute beginners, and for developers who already know something about web development, but want to add Go to their toolbox.

We start with an overview of the Go language, and then cover everything you need to get started writing web applications, including an overview of HTML5, a survey of JavaScript and JavaScript modules, how to work with Cascading Style Sheets to make our application look the way we want, and much more.

The major project in this course is building a bookings and reservation system for a Bed & Breakfast. Visitors to our site will be able to search for accommodations by date and make an online reservation, and the site owner will be able to manage reservations from a secure back end.

By the time you finish this course, you will have a solid grasp of what it takes to build a completely functional, secure, and fast web application from the ground up, and you will have a solid understanding of the Go programming language.

1. Introduction
2. Introduction: who I am, and what we're going to do
3. Why Go? Why not PHP, or Python, or Node.js, or whatever?
4. Why use Go? - System Resources
5. Installing Go, an IDE, and writing a simple program
6. Getting help: How to ask questions
7. Some Useful Resources
8. Overview of the Go Language
9. A note about the terminal on Windows: Git Bash
10. Variables & Functions
11. Pointers
12. Types and Structs
13. Receivers: Structs with functions
14. Other data structures: Maps and Slices
15. Decision Structures
16. Loops and ranging over data
17. Interfaces
18. Test quiz
19. Packages
20. Channels
21. Reading and Writing JSON
22. Writing Tests in Go
23. Building a Basic Web Application
24. How web applications work: the request/response lifecycle
25. Making a "Hello, World" web application
26. Making our application module-ready
27. Functions and handlers
28. Error checking
29. Serving HTML Templates
30. A note for Windows Users
31. Reorganizing our code, and adding some basic styling to pages
32. Enabling Go Modules and refactoring our code to use packages
33. Working with Layouts
34. Building a simple template cache
35. Building a more complex template cache
36. A note about the next lectures
37. Setting application wide configuration
38. Why the application wide config is so useful
39. Optimizing our template cache by using an application config
40. A note about the next lecture
41. Sharing data with templates
42. Improved Routing & Middleware
43. Using pat for routing
44. Using chi for routing
45. Developing our own middleware
46. State Management with Sessions
47. Installing and setting up a sessions package
48. Experimenting with sessions
49. Choosing a Project, and Working With Forms
50. What are we going to build?
51. Setting up our project
52. Enabling static files
53. Creating pages as HTML
54. Creating a landing page
55. Creating a page for each room
56. Adding a form to search for availability
57. Improving our form
58. Creating the reservation page
59. Javascript & CSS
60. What is Javascript, and why should I care?
61. Making a better date picker
62. Custom alerts using Notie
63. Creating modals with SweetAlert
64. Implementing a Javascript module
65. Adding custom alerts in our Javascript module
66. Using our Javascript module on the "Book Now" button
67. What is CSS, and how does it work?
68. Coverting our HTML to Go Templates, and creating handlers
69. Converting our pages to Go templates
70. Creating handlers for our forms & adding CSRF Protection
71. Creating a handler that return JSON
72. Sending & processing an AJAX request
73. Sending AJAX post and generalizing our custom function
74. Refactoring to use internal packages
75. Server-side form validation
76. Server side form validation II
77. Server side form validation III
78. Server Side form validation IV
79. Displaying a response to user after posting form data
80. Finishing up our response to user, and adding alerts
81. An aside: Alternate Templating Engines
82. Writing Tests
83. Writing tests for our main package
84. Writing tests for our GET handlers
85. Writing tests for our POST handlers
86. Writing tests for our Render package I
87. Writing tests for our Render package II
88. Getting test coverage
89. Exercise: Writing tests for the Forms package
90. Solution to writing tests for the Forms package
91. Making running our application easier
92. Improved Error Handling
93. Centralizing our error handling to a helpers package
94. Using our ClientError and ServerError helper functions
95. Updating our tests
96. Persisting Data with PostgreSQL
97. Installing PostgreSQL
98. Connecting to the database with DBeaver on a Mac
99. Connecting to the database with DBeaver on Windows
100. Basic SQL syntax
101. More complex queries
102. Designing the Database Structure
103. Identifying database structure, and Entity Relationship Diagarams
104. Install Soda
105. Creating the users table using migrations
106. Creating the rest of our database using migrations
107. Setting up a foreign key
108. Setting up the rest of our foreign keys
109. Adding Indices & Exercise
110. Solution to Exercise
111. Connecting our Application to the Database
112. How to connect a Go application to a database
113. Creating a Driver package
114. Connecting to the database and adding the SQL connection to our Repository
115. Setting up models
116. Cleaning up our code
117. A word about ORMs
118. Setting up database functions: inserting a reservation
119. Testing our insert reservation function
120. Inserting Room Restrictions
121. Searching for availability by room
122. Searching for availablity for all rooms
123. Connecting our handlers to our new database functions
124. Connecting search availablity to the make reservation page
125. Cleaning up our make reservation page and testing everything
126. Cleaning up the reservation summary page and improving validation
127. Searching for availability by Room
128. Providing feedback when searching by room, and connecting to the reservation pag
129. Connecting the rooms page to the make reservation page
130. Connecting the Major's Suite page, and extracting our javascript module
131. Adding a migration for seeding rooms
132. Adding a migration for seeding restrictions
133. Updating our tests
134. Creating a test database repository
135. Updating our existing tests to handle sessions
136. Improving our tests by handling multiple cases
137. Testing Post handlers
138. Testing AvailabilityJSON
139. Completed Handler tests
140. Simplifying adding post parameters
141. Sending Mail using Go
142. Sending email using the Standard Library
143. Installing a mailer package and setting up a mail channel
144. Installing Mailhog on a Mac for testing purposes
145. Installing Mailhog on Windows for testing purposes
146. Creating and sending mail notifications
147. Solution to sending notification to property owner
148. Sending nicely formatted email using Foundation
149. Updating our tests
150. Authentication
151. Create the login screen
152. Creating the authentication handlers for the login screen
153. Creating the authentication and user database functions
154. Creating our handler to log in
155. Writing Authentication Middleware
156. Adding a user to the database
157. Testing Login
158. Checking to see if a user is logged in, and logging a user out
159. Protecting our routes with authentication middleware
160. Setting up secure back end administration
161. Picking an admin template
162. Convert the admin template into a Go template
163. Important: A note on the admin.layout.tmpl file
164. Solution to creating admin templates
165. Create stub handlers for admin functionality
166. Listing all reservations
167. Listing new reservations
168. Showing one reservation
169. Database functions for editing a reservation
170. Editing a reservation
171. Marking a reservation as processed
172. Deleting a reservation
173. Showing the reservation calendar
174. Reservation Calendar II
175. Reservation Calendar III
176. Reservation Calendar IV
177. Handling Calendar changes I
178. Handling Calendar changes II
179. Handling Calendar changes III
180. Handling Calendar changes IV
181. Fixing our redirects
182. Updating our tests
183. Fixing a bug missed by our tests
184. A word about the updated tests
185. Updating our applications to accept command line parameters
186. Changing our app to use command line flags
187. An alternative: the .env file
188. Deploying Our Application to a Server
189. Using vi to edit files on remote server
190. Choosing a server platform
191. Add admin user to migrations
192. Installing Go on the server, and getting our code up there
193. Setting up the remote database and building the application on our server
194. A note about Caddy 2.5.0
195. Connecting the application to the web server
196. Setting up Supervisor
197. Writing an update script for the server
198. A note about sending mail from the live server
199. Finishing Touches
200. Updating to Bootstrap 5

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

Go, often referred to as Golang, is well-known for making it remarkably easy to work with concurrency. In order to make a particular function run concurrently, all we have to do is prepend the word "go" to the function call, and it cheerfully runs in the background, as a GoRoutine. Go's built in scheduler takes are of making sure that a given GoRoutine runs when it should, and as efficiently as it can.

However, this does not mean that working with concurrency is simple in Go—thread safe programming takes careful planning, and most importantly it requires that developers have an absolutely solid understanding of how Go deals with concurrency.

In the standard library, Go offers us several ways of dealing with concurrently running parts of our program, right in the standard library: sync.WaitGroup, which lets us wait for tasks to finish; sync.Mutex, which allows us to lock and unlock resources, so that no two GoRoutines can access the same memory location at the same time; and finally, Channels, which allow GoRoutines to send and receive data to and from each other.

Go's approach to concurrency is fairly straightforward, and is more or less summed up this mantra: Don't communicate by sharing memory; instead, share memory by communicating. Channels are the means by which we usually share memory by communicating.

In this course, we'll cover the use of WaitGroups, Mutexes, and Channels, and we'll do so in detail. We'll also cover some of the problems inherent in concurrency, including early program termination and race conditions. Initially, we'll gain a good understanding of how these things work by solving some of the classic problems found in the field of computer science, including the Dining Philosophers, the Producer/Consumer problem, and the Sleeping Barber. These problems are classics for a reason: they force a developer to figure out the best approach to working with code that run concurrently, or in parallel.

Finally, we'll finish the course out with a more "real-world" problem, where we have to register a customer for some kind of subscription service, and take care of invoicing, registration, and all the things necessary to get a new customer up and running. We'll do so, naturally, as quickly as we can by dividing the necessary tasks up into smaller tasks, and having them run concurrently.

1. Introduction
2. Introduction
3. A bit about me
4. Installing Go
5. Installing Visual Studio Code
6. Installing Make
7. Asking for help
8. Mistakes: we all make them.
9. Goroutines, the go keyword, and WaitGroups
10. What we'll cover in this section
11. Creating GoRoutines and identifying a problem
12. WaitGroups to the rescue
13. Writing tests with WaitGroups
14. Challenge: working with WaitGroup
15. Solution to Challenge
16. Race Conditions, Mutexes, and an Introduction to Channels
17. What we'll cover in this section
18. Race Conditions: an example
19. Adding sync.Mutex to our code
20. Testing for race conditions
21. A more complex example
22. Writing a test for our weekly income project
23. Producer/Consumer - Using Channels for the first time
24. Getting started with the Producer - the pizzeria function
25. Making a pizza: the makePizza function
26. Finishing up the Producer code
27. Creating and running the consumer: ordering a pizza
28. Finishing up our Producer/Consumer project
29. A Classic Problem: The Dining Philosophers
30. What we'll cover in this section
31. Getting started with the problem
32. Implementing the diningProblem logic
33. Challenge: Printing out the order in which the meal is finished
34. Solution to challenge
35. Writing a test for our program
36. Channels, and another classic: The Sleeping Barber problem
37. What we'll cover in this section
38. Introduction to channels
39. The select statement
40. Buffered Channels
41. Getting started with the Sleeping Barber project
42. Defining some variables, the barber shop, and getting started with the code
43. Adding a Barber
44. Starting the barbershop as a GoRoutine
45. Sending clients to the shop
46. Trying things out
47. Final Project - Building a Subscription Service
48. What we'll cover in this section
49. Setting up a simple web application
50. Setting up our Docker development environment
51. Adding postgres
52. Setting up a Makefile
53. Adding sessions & Redis
54. Setting up the application config
55. Setting up a route & handler for the home page, and starting the web server
56. Setting up templates and building a render function
57. Adding session middleware
58. Setting up additional stub handlers and routes
59. Implementing graceful shutdown
60. Populating the database
61. Adding a data package and database models
62. Implementing the login/logout functions
63. Sending Email Concurrently
64. What we'll cover in this section
65. Getting started with the mailer code
66. Building HTML and Plain Text messages
67. Sending a message (synchronously)
68. Getting started sending a message (asynchronously)
69. Writing a helper function to send email easily
70. Sending an email on incorrect login
71. Adding cleanup tasks to the shutdown() function
72. Registering a User and Displaying Plans
73. What we'll cover in this section
74. Adding mail templates and URL signer code
75. Starting on the handler to create a user
76. Activating a user
77. Giving user data to our templates
78. Displaying the Subscription Plans page
79. Adding a route and trying things out for the "Plans" page
80. Writing a stub handler for choosing a plan
81. Adding Concurrency to Choosing a Plan
82. What we'll cover in this section
83. Getting the plan id, the plan, and the user
84. Generating an Invoice
85. Generating a manual
86. Trying things out, subscribing a user, updating the session, and redirecting
87. Testing
88. What we'll cover in this section
89. Setting up our tests
90. Testing Routes
91. Testing the Renderer
92. Modifying the data package to make it testable
93. Implementing the PlanTest type
94. Getting started testing Handlers
95. Testing the Login Handler
96. Testing a handler that uses concurrency

If you are like most people wanting to learn a programming language, you don't have much spare time.  What time you have is extremely valuable.   If you want to learn Google's GO programming language, then,  what you need is a course that will teach the essential Go programming skills quickly.

Think of a word processing program like Microsoft word - it has lots of advanced features that most people never use.   It's the same with computer programming.  A typical programming language has many parts that rarely get used, and a lot of what is taught in a typical computer course or textbook never gets used in the real world by professional developers.

So why learn it all?  It makes much more sense to learn just want you actually need to know to become productive and be then able to apply for GoLang developer positions.   If you really want to learn those other parts of the Go lang language, then you can later, and it's highly likely you will pick it up faster anyway at that point because of the skills you have already learned.

That's what this course is all about - giving you the skills you need quickly without any fluff or useless information.

The course is aimed at complete beginners.  No previous experience is necessary or assumed. If you are coming from another programming language like Java or C++, or C# then you will also feel right at home here, and you can skip any of the introductory parts if you wish.  But keep in mind there are differences in Go compared to those languages, so it's probably a good idea to watch all videos anyway.

What will you learn in the course?

You will learn about many important GO code concepts including.

• Learn the syntax of the Go language by writing several simple text-based games

• Learn about the difference between Object-oriented programs and Go, which uses Composition

• Learn to think like a programmer: making decisions, looping logic, and performing calculations

• Learn about Go’s use of goroutines, channels, and the select statement for concurrent programming

• Learn how Go can be used to build a production-ready web application

Some of the other specific things you will work through include:-

• How to write a Go program

• Learn the language while building simple games

• Learn all about the Go compiler

• Learn best practices when writing Go code

• Learn how to write idiomatic Go code

• Learn how to build a terminal-based Go program

• Learn low to build a basic web-based Go program

• Learn how to use delve, the Go debugger, to find and fix errors in your programs

Along the way, we will work with a lot of GO example code.  We'll start with badly written code, and go through it thoroughly to improve it and make it bug-free.  This is an essential skill and you will learn that in this course.

The course uses a combination of small snippets of code, and then larger real-world projects that you can run and edit and improve - you will learn how to think like a programmer and how to make the most out of the GO programming language.

What about the instructor?

Your instructor in the course is Trevor Sawler. 

Trevor has twenty years of experience in professional software development, and twenty years of experience as a University professor.

He has worked with a broad range of clients, including Thomson Nelson, Hewlett Packard, the Royal Bank of Canada, Keybank, Sprint, and many, many others.   As a professor, Trevor has taught in a wide variety of course areas, including Computer Science, English, Irish, and American literature, and a number of "crossover" courses that bridge the liberal arts and technological fields.

What about if you have questions?

As if this course wasn’t complete enough, Trevor offers full support, answering any questions you have via the course Q&A section.

This means you’ll never find yourself stuck on one lesson for days on end. With their hand-holding guidance, you’ll progress smoothly through this course without any major roadblocks.

There’s no risk either!

This course comes with a full 30-day money-back guarantee. Meaning if you are not completely satisfied with the course or your progress, simply let the instructors know and they will refund you 100%, every last penny no questions asked.

You either end up with GO skills, go on to develop great programs and potentially make an awesome career for yourself, or you try the course and simply get all your money back if you don’t like it…

You literally can’t lose.

Ready to get started, developer?

Enrol now using the “Add to Cart” button on the right, and get started on your way to creative, advanced GO brilliance. Or, take this course for a free spin using the preview feature, so you know you’re 100% certain this course is for you.

See you on the inside (hurry, the Go class is waiting!)

1. Getting Started
2. Introduction
3. Installing Go
4. Installing Visual Studio Code
5. Hello, World!
6. Structure of a Go Program
7. Variables and Dot Notation
8. Running Eliza
9. Introduction to Go
10. Summary
11. Section 1 Quiz
12. Starting to Code
13. Introduction
14. Variables
15. Guess the Number Game
16. Finishing Guess the Number
17. Why Use Variables?
18. Guess the Number Challenge
19. Scope
20. Scope Challenge
21. Scope Challenge Solution
22. Summary
23. Section 2 Quiz
24. Console Input and Output
25. Introduction
26. Console Input with a Package
27. Console Input Part 2
28. Listening for keypresses in Hammer Bitcoin game
29. String Interpolation
30. Experimenting with String Interpolation
31. Challenge
32. Solution to Challenge
33. Summary
34. Section 3 Quiz
35. Types, Expression, and Composition
36. Introduction
37. Basic Types
38. Aggregate Types
39. Pointers
40. Slices
41. Maps
42. Functions
43. Channels
44. Interfaces
45. Expressions
46. Booleans
47. Compound Booleans
48. Hammer Bitcoin Challenge
49. Hammer Bitcoin Challenge Solution
50. Composition
51. Exported vs. Unexported
52. Summary
53. Section 4 Quiz
54. Flow Control
55. Introduction
56. Three Part Loop
57. The While Loop in Go
58. The Infinite Loop in Go
59. Nested Loops and the Debugger
60. Debugging Console Applications
61. Debugging Hammer Bitcoin
62. for loops in Eliza
63. Understanding more about Eliza
64. The While Loop in our Menu App
65. Solution to Challenge
66. Which way is better?
67. The do while loop in go
68. Summary
69. Section 5 Quiz
70. if/else, switch and select
71. Introduction
72. if statement
73. else statement
74. More on if and else and introducting switch
75. Solution to Challenge
76. Introducing select
77. Using select in rock-paper-scissors
78. Finishing up channels and select in rock-paper-scissors
79. Solution to Challenge
80. Summary
81. Section 6 Quiz
82. Operators
83. Introduction
84. Operators and Precedence
85. Primary Operators
86. Precedence
87. Using the Modulus Operator
88. Modulus in rock-paper-scissors
89. Relational and Conditional Operators
90. Short Circuit Evaluation
91. Assignment Operators
92. Section 7 Quiz
93. Working with strings in Go
94. What is a string?
95. Indexing
96. String length
97. The strings package
98. String manipulation
99. More string manipulation
100. Dealing with case
101. Solution to Challenge
102. Section 8 Quiz
103. Building a Simple Web Application
104. Introduction
105. Hello World web
106. Serving HTML
107. Creating the Home Page
108. Improving our Home Page
109. Serving our HTML Page
110. Implementing the rock, paper, scissors logic
111. Introducing JSON
112. Changing content using JavaScript
113. Calling our web application from the browser
114. Finishing up our application
115. Challenge
116. Solution to Challenge
117. Extra Information - Source code, and other stuff
118. Source Codes
119. Bonus Lecture and Information

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