Learn How To Code: Google's Go (golang) Programming Language
45h 27m 58s
English
Paid
Course description
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 1.65 Million students how to use the Go Programming Language.
Read more about the course
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.
Requirements:
- No prerequisite knowledge is required to take this course. This course starts at the very beginning and will teach you everything you need to know to be an outstanding programmer.
What you’ll learn:
- The ultimate comprehensive course
- For beginners and experienced devs
- Taught by a university professor
- From beginning to advanced concepts
- Concurrency, channels, benchmarking
- Testing, error handling, documentation
- Hands-on exercises with solutions
- Access to valuable code base
- This course is tried, tested, and proven
- Over 2.65 Million students taught
- Lifetime course access
- Learn at your own pace
- 100% satisfaction guaranteed
Watch Online
Watch Online Learn How To Code: Google's Go (golang) Programming Language
0:00
/ #1: Welcome!
All Course Lessons (364)
| # | Lesson Title | Duration | Access |
|---|---|---|---|
| 1 | Welcome! Demo | 02:57 | |
| 2 | Why go? | 11:15 | |
| 3 | How to succeed | 11:18 | |
| 4 | Course outline | 07:07 | |
| 5 | Documentation | 06:50 | |
| 6 | The terminal | 06:52 | |
| 7 | Bash on windows | 08:18 | |
| 8 | Shell / bash commands I | 11:14 | |
| 9 | Shell / bash commands II | 07:37 | |
| 10 | Installing Go | 10:20 | |
| 11 | Go modules - introduction | 02:54 | |
| 12 | Go workspace | 06:10 | |
| 13 | Environment variables | 09:08 | |
| 14 | Intro to IDE's | 01:48 | |
| 15 | VS Code IDE | 03:14 | |
| 16 | Using go get to get course code | 13:50 | |
| 17 | IDE's | 11:22 | |
| 18 | Go commands | 15:09 | |
| 19 | Github repos | 11:02 | |
| 20 | Github explored | 08:35 | |
| 21 | Package management | 06:08 | |
| 22 | Go modules overview | 06:16 | |
| 23 | Creating a go module | 04:53 | |
| 24 | Adding a dependency | 04:53 | |
| 25 | Upgrading dependencies | 03:55 | |
| 26 | Playground | 06:20 | |
| 27 | Hello world | 10:32 | |
| 28 | Introduction to packages | 16:06 | |
| 29 | Short declaration operator | 12:54 | |
| 30 | The var keyword | 11:41 | |
| 31 | Exploring type | 13:02 | |
| 32 | Zero value | 04:03 | |
| 33 | The fmt package | 09:37 | |
| 34 | Creating your own type | 05:48 | |
| 35 | Conversion, not casting | 06:05 | |
| 36 | Hands-on exercise #1 | 05:33 | |
| 37 | Hands-on exercise #2 | 03:12 | |
| 38 | Hands-on exercise #3 | 02:51 | |
| 39 | Hands-on exercise #4 | 05:23 | |
| 40 | Hands-on exercise #5 | 03:20 | |
| 41 | Hands-on exercise #6 | 10:30 | |
| 42 | Bool type | 08:08 | |
| 43 | How computers work | 21:26 | |
| 44 | Numeric types | 15:02 | |
| 45 | String type | 15:31 | |
| 46 | Numeral systems | 17:51 | |
| 47 | Constants | 03:37 | |
| 48 | Iota | 02:48 | |
| 49 | Bit shifting | 11:13 | |
| 50 | Hands-on exercise #1 | 01:55 | |
| 51 | Hands-on exercise #2 | 03:09 | |
| 52 | Hands-on exercise #3 | 01:14 | |
| 53 | Hands-on exercise #4 | 02:36 | |
| 54 | Hands-on exercise #5 | 00:53 | |
| 55 | Hands-on exercise #6 | 01:13 | |
| 56 | Understanding control flow | 01:48 | |
| 57 | Loop - init, condition, post | 04:15 | |
| 58 | Loop - nesting loops | 03:55 | |
| 59 | Loop - for statement | 10:23 | |
| 60 | Loop - break & continue | 06:38 | |
| 61 | Loop - printing ascii | 06:40 | |
| 62 | Conditional - if statement | 07:20 | |
| 63 | Conditional - if, else if, else | 03:11 | |
| 64 | Loop, conditional, modulus | 03:25 | |
| 65 | Conditional - switch statement | 08:36 | |
| 66 | Conditional - switch statement documentation | 08:28 | |
| 67 | Conditional logic operators | 04:00 | |
| 68 | Hands-on exercise #1 | 02:19 | |
| 69 | Hands-on exercise #2 | 02:36 | |
| 70 | Hands-on exercise #3 | 01:56 | |
| 71 | Hands-on exercise #4 | 01:12 | |
| 72 | Hands-on exercise #5 | 02:35 | |
| 73 | Hands-on exercise #6 | 01:05 | |
| 74 | Hands-on exercise #7 | 01:29 | |
| 75 | Hands-on exercise #8 | 01:26 | |
| 76 | Hands-on exercise #9 | 02:07 | |
| 77 | Hands-on exercise #10 | 05:32 | |
| 78 | Array | 04:48 | |
| 79 | Slice - composite literal | 05:30 | |
| 80 | Slice - for range | 03:24 | |
| 81 | Slice - slicing a slice | 04:35 | |
| 82 | Slice - append to a slice | 05:18 | |
| 83 | Slice - deleting from a slice | 04:54 | |
| 84 | Slice - make | 09:49 | |
| 85 | Slice - multi-dimensional slice | 03:58 | |
| 86 | Map - introduction | 11:50 | |
| 87 | Map - add element & range | 04:17 | |
| 88 | Map - delete | 03:16 | |
| 89 | Hands-on exercise #1 | 02:39 | |
| 90 | Hands-on exercise #2 | 01:16 | |
| 91 | Hands-on exercise #3 | 04:01 | |
| 92 | Hands-on exercise #4 | 03:14 | |
| 93 | Hands-on exercise #5 | 02:25 | |
| 94 | Hands-on exercise #6 | 05:43 | |
| 95 | Hands-on exercise #7 | 09:14 | |
| 96 | Hands-on exercise #8 | 04:02 | |
| 97 | Hands-on exercise #9 | 01:26 | |
| 98 | Hands-on exercise #10 | 01:37 | |
| 99 | Struct | 04:08 | |
| 100 | Embedded structs | 05:37 | |
| 101 | Reading documentation | 07:41 | |
| 102 | Anonymous structs | 03:32 | |
| 103 | Housekeeping | 18:48 | |
| 104 | Hands-on exercise #1 | 04:12 | |
| 105 | Hands-on exercise #2 | 04:09 | |
| 106 | Hands-on exercise #3 | 03:55 | |
| 107 | Hands-on exercise #4 | 03:56 | |
| 108 | Syntax | 12:37 | |
| 109 | Variadic parameter | 09:05 | |
| 110 | Unfurling a slice | 13:25 | |
| 111 | Defer | 06:14 | |
| 112 | Methods | 07:17 | |
| 113 | Interfaces & polymorphism | 20:15 | |
| 114 | Anonymous func | 04:30 | |
| 115 | func expression | 03:49 | |
| 116 | Returning a func | 11:51 | |
| 117 | Callback | 12:51 | |
| 118 | Closure | 09:28 | |
| 119 | Recursion | 09:35 | |
| 120 | Hands-on exercise #1 | 10:10 | |
| 121 | Hands-on exercise #2 | 04:06 | |
| 122 | Hands-on exercise #3 | 06:07 | |
| 123 | Hands-on exercise #4 | 05:20 | |
| 124 | Hands-on exercise #5 | 10:04 | |
| 125 | Hands-on exercise #6 | 02:07 | |
| 126 | Hands-on exercise #7 | 04:15 | |
| 127 | Hands-on exercise #8 | 02:25 | |
| 128 | Hands-on exercise #9 | 08:26 | |
| 129 | Hands-on exercise #10 | 03:13 | |
| 130 | What are pointers? | 11:55 | |
| 131 | When to use pointers | 08:29 | |
| 132 | Method sets | 06:32 | |
| 133 | Hands-on exercise #1 | 01:03 | |
| 134 | Hands-on exercise #2 | 05:38 | |
| 135 | JSON documentation | 12:13 | |
| 136 | JSON marshal | 06:29 | |
| 137 | JSON unmarshal | 16:15 | |
| 138 | Writer interface | 15:38 | |
| 139 | Sort | 05:45 | |
| 140 | Sort custom | 10:33 | |
| 141 | bcrypt | 12:03 | |
| 142 | Hands-on exercise #1 | 04:08 | |
| 143 | Hands-on exercise #2 | 08:01 | |
| 144 | Hands-on exercise #3 | 05:18 | |
| 145 | Hands-on exercise #4 | 01:48 | |
| 146 | Hands-on exercise #5 | 07:15 | |
| 147 | Concurrency vs parallelism | 05:51 | |
| 148 | WaitGroup | 12:29 | |
| 149 | Method sets revisited | 12:02 | |
| 150 | Documentation | 13:19 | |
| 151 | Race condition | 12:30 | |
| 152 | Mutex | 04:29 | |
| 153 | Atomic | 05:45 | |
| 154 | Hands-on exercise #1 | 16:15 | |
| 155 | Hands-on exercise #2 | 11:57 | |
| 156 | Hands-on exercise #3 | 11:06 | |
| 157 | Hands-on exercise #4 | 04:43 | |
| 158 | Hands-on exercise #5 | 04:49 | |
| 159 | Hands-on exercise #6 | 05:40 | |
| 160 | Understanding channels | 15:53 | |
| 161 | Directional channels | 09:56 | |
| 162 | Using channels | 06:36 | |
| 163 | Range | 05:35 | |
| 164 | Select | 10:29 | |
| 165 | Comma ok idiom | 05:57 | |
| 166 | Fan in | 07:58 | |
| 167 | Fan out | 06:36 | |
| 168 | Context | 14:40 | |
| 169 | Hands-on exercise #1 | 03:20 | |
| 170 | Hands-on exercise #2 | 02:37 | |
| 171 | Hands-on exercise #3 | 03:27 | |
| 172 | Hands-on exercise #4 | 06:17 | |
| 173 | Hands-on exercise #5 | 02:45 | |
| 174 | Hands-on exercise #6 | 03:08 | |
| 175 | Hands-on exercise #7 | 04:55 | |
| 176 | Understanding | 14:43 | |
| 177 | Checking errors | 07:05 | |
| 178 | Printing and logging | 09:12 | |
| 179 | Recover | 10:08 | |
| 180 | Errors with info | 03:46 | |
| 181 | Hands-on exercise #1 | 11:54 | |
| 182 | Hands-on exercise #2 | 10:38 | |
| 183 | Hands-on exercise #3 | 06:02 | |
| 184 | Hands-on exercise #4 | 01:41 | |
| 185 | Hands-on exercise #5 | 18:27 | |
| 186 | Introduction | 05:20 | |
| 187 | go doc | 07:54 | |
| 188 | godoc | 06:47 | |
| 189 | godoc.org | 04:26 | |
| 190 | Writing documentation | 12:05 | |
| 191 | Hands-on exercise #1 | 04:40 | |
| 192 | Introduction | 14:15 | |
| 193 | Table tests | 07:46 | |
| 194 | Example tests | 09:48 | |
| 195 | Golint | 04:46 | |
| 196 | Benchmark | 09:27 | |
| 197 | Coverage | 08:37 | |
| 198 | Benchmark examples | 12:14 | |
| 199 | Review | 12:33 | |
| 200 | Hands-on exercise #1 | 13:32 | |
| 201 | Hands-on exercise #2 | 19:06 | |
| 202 | Hands-on exercise #3 | 15:05 | |
| 203 | Congratulations | 05:59 | |
| 204 | Why choose the Go programming language? | 12:16 | |
| 205 | Hello World! | 09:38 | |
| 206 | Section Overview | 03:13 | |
| 207 | The Terminal | 06:14 | |
| 208 | Installation Insights | 08:49 | |
| 209 | Go Workspace | 08:49 | |
| 210 | Environment Variables | 06:52 | |
| 211 | Windows - Configuring Path Variables | 08:02 | |
| 212 | Mac - Configuring Path Variables | 10:24 | |
| 213 | Linux - Machine Setup | 33:40 | |
| 214 | Linux - Machine Configuration | 12:44 | |
| 215 | Linux - Configuring Path Variables | 21:42 | |
| 216 | Testing Your Installation | 04:33 | |
| 217 | Section Review | 04:05 | |
| 218 | Section Overview | 01:52 | |
| 219 | Go Editors | 09:08 | |
| 220 | WebStorm & Atom.io | 06:35 | |
| 221 | Creating Your First Project | 09:04 | |
| 222 | Hello World with Webstorm | 08:16 | |
| 223 | The Go Command & Documentation | 05:48 | |
| 224 | Understanding Github | 07:38 | |
| 225 | Using Github | 14:25 | |
| 226 | Section Review | 03:41 | |
| 227 | Section Overview | 02:04 | |
| 228 | How Computers Work - Part I | 09:57 | |
| 229 | How Computers Work - Part II | 12:30 | |
| 230 | Github Update Command | 08:56 | |
| 231 | Numeral Systems | 04:08 | |
| 232 | Binary Numbering System | 07:41 | |
| 233 | Hexadecimal Numbering System | 07:09 | |
| 234 | Text Encoding | 09:26 | |
| 235 | Coding Scheme Programs | 09:34 | |
| 236 | Format Printing | 09:47 | |
| 237 | Section Review | 09:17 | |
| 238 | Section Overview | 05:51 | |
| 239 | Packages | 07:55 | |
| 240 | Go Commands | 05:47 | |
| 241 | Variables | 08:46 | |
| 242 | Scope | 07:51 | |
| 243 | Scope II | 10:09 | |
| 244 | Closure | 11:16 | |
| 245 | Blank Identifier | 04:26 | |
| 246 | Constants | 09:03 | |
| 247 | Constants II | 07:22 | |
| 248 | Words of Encouragement | 03:43 | |
| 249 | Pointers | 06:20 | |
| 250 | Using Pointers | 07:46 | |
| 251 | Remainder | 05:48 | |
| 252 | Section Review | 15:04 | |
| 253 | Section Overview | 07:05 | |
| 254 | For Loop | 06:54 | |
| 255 | Nested Loops | 06:24 | |
| 256 | Conditions, Break, & Continue | 07:24 | |
| 257 | Documentation & Terminology | 13:02 | |
| 258 | Rune | 06:24 | |
| 259 | String Type | 10:41 | |
| 260 | Switch Statements | 07:28 | |
| 261 | If Statements | 07:09 | |
| 262 | Exercise Solutions | 14:02 | |
| 263 | Section Review | 08:42 | |
| 264 | Section Overview | 01:52 | |
| 265 | Intro To Functions | 07:49 | |
| 266 | Func Returns | 05:28 | |
| 267 | Variadic Functions | 06:50 | |
| 268 | Variadic Arguments | 05:08 | |
| 269 | Func Expressions | 05:43 | |
| 270 | Closure | 06:05 | |
| 271 | Callbacks | 06:50 | |
| 272 | Callback Example | 05:36 | |
| 273 | Recursion | 05:05 | |
| 274 | Defer | 04:21 | |
| 275 | Pass By Value | 06:42 | |
| 276 | Reference Types | 05:07 | |
| 277 | Anonymous Self-Executing Functions | 01:40 | |
| 278 | Bool Expressions | 07:24 | |
| 279 | Exercises - Part I | 07:47 | |
| 280 | Exercises - Part II | 06:42 | |
| 281 | Section Review | 10:28 | |
| 282 | Data Structures Overview | 06:08 | |
| 283 | Array | 08:29 | |
| 284 | Array Examples | 10:46 | |
| 285 | Slices | 10:05 | |
| 286 | Slice Examples | 09:39 | |
| 287 | More Slice Examples | 06:34 | |
| 288 | Creating A Slice | 12:44 | |
| 289 | Incrementing A Slice Item | 05:17 | |
| 290 | Section Review | 12:30 | |
| 291 | Maps Introduction | 06:19 | |
| 292 | Map Examples - Part I | 08:31 | |
| 293 | Map Examples - Part II | 08:47 | |
| 294 | Map Examples - Part III | 05:10 | |
| 295 | Map Documentation | 10:44 | |
| 296 | Map Range Loop | 03:44 | |
| 297 | GitHub Pull | 04:09 | |
| 298 | Hash Tables | 13:53 | |
| 299 | Hashing Words | 10:58 | |
| 300 | Hashing Words II | 12:06 | |
| 301 | Build A Hash Table | 09:14 | |
| 302 | Finished Hash Algorithm | 11:42 | |
| 303 | Structs Introduction | 06:15 | |
| 304 | OOP in Go | 11:38 | |
| 305 | User-Defined Types | 10:47 | |
| 306 | Composition | 10:29 | |
| 307 | JSON Marshal | 11:41 | |
| 308 | JSON Unmarshal | 03:14 | |
| 309 | JSON Encode | 06:42 | |
| 310 | JSON Decode | 05:36 | |
| 311 | Interfaces | 10:25 | |
| 312 | Code Substitutability | 12:27 | |
| 313 | Bill Kennedy | 08:32 | |
| 314 | Donovan & Kernighan | 11:55 | |
| 315 | Sort Package | 10:28 | |
| 316 | Sort Solution | 09:41 | |
| 317 | Sort Reverse | 15:56 | |
| 318 | Sort Slice Int | 03:36 | |
| 319 | Empty Interface | 08:57 | |
| 320 | Method Sets | 11:41 | |
| 321 | Conversion vs Assertion | 10:22 | |
| 322 | Concurrency & WaitGroup | 05:11 | |
| 323 | Parallelism | 04:43 | |
| 324 | Race Conditions | 04:10 | |
| 325 | Mutex | 03:47 | |
| 326 | Atomicity | 03:59 | |
| 327 | Review & Channels Preview | 08:36 | |
| 328 | Channels - Introduction | 09:31 | |
| 329 | Range Clause | 05:37 | |
| 330 | N-to-1 | 05:23 | |
| 331 | Semaphores - Part 1 | 07:30 | |
| 332 | Semaphores - Part 2 | 01:38 | |
| 333 | 1-to-N | 04:15 | |
| 334 | Channels as Arguments & Returns | 07:03 | |
| 335 | Channel Direction | 05:48 | |
| 336 | Incrementor With Channels | 06:02 | |
| 337 | Deadlock Challenge | 07:15 | |
| 338 | Factorial Challenge | 04:44 | |
| 339 | Pipeline Pattern | 06:36 | |
| 340 | Factorial Challenge Redux | 05:38 | |
| 341 | Factorial Challenge Redux Solution | 04:39 | |
| 342 | Fan Out / Fan In Pattern - Overview | 03:33 | |
| 343 | Fan In Pattern | 07:04 | |
| 344 | Fan Out / Fan In - Example | 16:21 | |
| 345 | Fan Out / Fan In - Challenge | 01:32 | |
| 346 | Fan Out / Fan In - Solution | 09:12 | |
| 347 | Fan Out / Fan In - Challenge: Factorial | 02:07 | |
| 348 | Fan Out / Fan In - Solution: Factorial | 11:23 | |
| 349 | Deadlock Challenge | 00:43 | |
| 350 | Deadlock Solution | 04:23 | |
| 351 | Incrementor Challenge Revisited | 01:12 | |
| 352 | Incrementor Solution | 05:45 | |
| 353 | Additional Resources | 04:54 | |
| 354 | An Introduction to Error Handling in Go | 05:42 | |
| 355 | Improving Your Code with Golint | 05:57 | |
| 356 | Handling Errors & Logging Errors to a File | 08:46 | |
| 357 | Four Common Ways to Handle Errors | 05:46 | |
| 358 | Custom Errors - Creating Values of Type error | 07:26 | |
| 359 | Idiomatic Error Handling | 04:29 | |
| 360 | Providing Context with Errors | 05:12 | |
| 361 | Providing Even More Context with Errors | 07:13 | |
| 362 | Error Handling Review & Resources | 04:48 | |
| 363 | Congratulations | 05:59 | |
| 364 | Bonus lecture | 05:38 |
Unlock unlimited learning
Get instant access to all 363 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.
Learn more about subscriptionComments
0 commentsSimilar courses
Golang mini course for beginners
Sources: Anthony GG
Golang mini course for beginners is a compact and comprehensible course for developers who are just beginning to get acquainted with the Go programming...
2 hours 54 minutes 34 seconds
Build SaaS apps in Go (2nd edition)
Sources: Dominic St-Pierre
Learn how to build performant and maintainable API-first web server in Go. I put some emphasis and content regarding building a SaaS in Go. If you want to build
4 hours 30 minutes 22 seconds
Golang (Go) Concurrency: Hands-On Guide
Sources: udemy
Unlock the potential of parallel programming in Go with this practical guide. This course is designed for intermediate and advanced level developers...
2 hours 9 minutes 27 seconds
Ultimate Service 3.0
Sources: ardanlabs.com
This updated course teaches you how to build production-level services in Go, leveraging the power of Kubernetes.
13 hours 33 minutes 5 seconds
Getting Started With Golang
Sources: Academind Pro
Learn all the key fundamentals of Go - one of the most in-demand and popular programming languages you can learn these days! Go (or Golang) is a very modern, performant and popu...
15 hours 19 minutes 14 seconds
Want to join the conversation?
Sign in to comment