https://DevOpsCloud.io -- Cloud Monk Losang Jinpa, Ph.D., MCSE/MCT, GitOps DevOps Engineer

Getting Started With Golang by Maximilian Schwarzmuller

Go (or Golang) is a very modern, performant and popular programming language which you can use to build applications, scripts, automations, web servers and APIs and much more!

Go was originally invented and developed by a team at Google and whilst Google still heavily uses Go, it's now also very popular outside of Google. Golang regularly scores top placements in Stackoverflow surveys: In 2020, Go was the 5th most loved language according to the Stackoverflow survey.

Hence there was never a better time to get started with go and in this course, you'll learn all the key fundamentals of Go in great depth, step by step and from the ground up.

NO prior Go knowledge is assumed and you will of course learn all key concepts with both theory and practical examples, demo projects and exercises. After finishing this course, you will understand how Go works, how to write Go code and which features Go has to offer. Of course we're also going to build multiple demo projects throughout this course!

In detail, this course will teach you:

What Go is and how it works The general Go syntax and rules Key basics like working with values & variables All about Go's value types, how they differ and how you use them How to write functions with Go “Special features” like multiple return values in functions How to organize your code into packages and modules How to work with third-party modules How to run and build Go programs All about controlling code flow with conditionals and loops More complex data types like structs Collection value types like arrays, slices and maps (+ how and when to use them) A highly understandable explanation of “Pointers” Deep dives into values & variables Advanced function concepts like “Recursion” Detailed information about “Interfaces” Embedding of Interfaces and Structs All about concurrency, Goroutines and Channels And so much more! This course doesn't assume any prior Go knowledge and will turn you into a Go developer in a matter of hours!

11+ hours

140+ lessons

Course Curriculum

Getting Started

PreviewWelcome To The Course (1:00)
PreviewWhat Is Go? (6:12)
PreviewWhy Would You Use Go? (3:52)
PreviewInstalling Go (3:55)
PreviewCode Editor Setup (VS Code) (2:40)
PreviewFinishing Editor Config & First Go Code (6:53)
PreviewBasic Programming Knowledge Helps! (1:55)
PreviewAbout This Course (2:21)
PreviewHow To Get The Most Out Of This Course (3:50)
PreviewUsing Code Snapshot Attachments

Go Basics: Values, Variables & Types

StartModule Introduction (1:26)
StartBase Syntax & Language Features (9:08)
StartGetting Started With Values & Value Types (5:25)
StartExploring Variables (9:34)
StartThe "int" Type & Math Operations (8:20)
StartTime To Practice: Problem (5:38)
StartTime To Practice: Solution (10:24)
StartWorking With Floats & Type Conversions (7:47)
Startfloat64 vs float32 (3:30)
StartVariables & "Null Values"
StartA Brief Look At "bool", "rune" and "byte" Types (7:10)
StartString Operations & Type Clashes (6:26)
StartWorking with Multiline Strings
StartFormatting Strings (11:05)
StartTime To Practice: Problem (2:41)
StartTime To Practice: Solution (7:36)
StartGo Packages & Modules: The Theory (5:33)
StartCreating & Using A First Module (4:59)
StartWorking With Packages & Exports + Imports (9:01)
StartUsing Constant Values (Constants) (3:54)
StartModule Summary (2:52)
StartModule Resources

Go Basics - Time To Practice (Building a BMI Calculator App)

StartModule Introduction (1:49)
StartCreating Our Go Module (4:23)
StartPrinting Output (3:40)
StartFetching User Input (8:19)
StartCleaning & Parsing User Input (10:15)
StartBMI Calculation & Outputting Formatted Strings (3:40)
StartUsing Constant Values (4:20)
StartSplitting Our Code Into Files & Packages (7:38)
StartUS / English Units
StartModule Resources

Working with Functions

StartModule Introduction (0:49)
StartWhat Is A "Function"? (3:49)
StartCreating A Function & Working With Parameters + Return Values (10:10)
StartPracticing Functions (3:43)
StartGo Special Feature: Multiple Return Values (7:56)
StartUsing Named Return Values (3:39)
StartModule Summary (1:38)
StartModule Resources

Functions - Time To Practice (Enhancing The BMI Project)

StartModule Introduction (2:52)
StartCreating a First Function (3:44)
StartOutsourcing The User Input Logic (5:21)
StartFinishing the "main" Function Refactoring (5:22)
StartAvoiding Code Duplication (6:24)
StartModule Summary (1:11)
StartModule Resources

Understanding Pointers

StartModule Introduction (0:46)
StartWhat Are Pointers & Why Do We Have Them? (8:07)
StartCreating a First Pointer (5:06)
StartWorking With Pointers (5:35)
StartAdvantages Of Pointers (& Disadvantages) (8:47)
StartModule Resources

“Struct”uring Data with Structs

StartModule Introduction (0:54)
StartWhat & Why + Defining a First Struct (9:25)
StartCreating Struct Instances (6:21)
StartCreating Structs With "Creation Functions" (3:39)
StartStructs & Pointers (4:31)
StartAccessing Struct Values (8:41)
StartAdding Methods To Structs (7:19)
StartModule Summary (4:17)
StartModule Resources

Structs - Time To Practice (Storing Data In Files)

StartModule Introduction (3:06)
StartDefining a Struct (3:29)
StartCreating Struct Instances (9:44)
StartAdding a Method (5:02)
StartReading User Input (14:06)
StartWriting To Files (7:53)
StartModule Resources

Data Collections: Arrays, Slices & Maps

StartModule Introduction (1:08)
StartIntroducing Arrays For Storing Lists Of Data (8:02)
StartWorking With Arrays (6:18)
StartSelecting Parts Of Arrays With Slices (3:26)
StartMore Ways Of Using Slices (2:23)
StartSlices - Deep Dive (9:43)
StartCreating Dynamic Lists With Slices (9:16)
StartTime To Practice - Problem (4:17)
StartTime To Practice - Solution (20:10)
StartUnpacking List Values (3:29)
StartIntroducing Maps (6:48)
StartMutating Maps (3:41)
StartMaps vs Structs (4:00)
StartModule Resources

Working With Control Structures

StartModule Introduction (1:14)
StartWorking on the Project Setup (5:34)
StartIntroducing "if" Statements (3:46)
StartMore about "if" Statements & Boolean Values (Booleans) (4:40)
Start"else" & "else if" (5:08)
StartCombining Conditions (4:28)
StartUsing "switch" Statements
StartHandling Expected Errors (8:10)
StartReturning Errors In Functions (3:33)
StartPracticing What We Learned (13:50)
StartOnwards To "Loops" (and why do we need them?) (5:44)
StartIntroducing a Basic "for" Loop (5:11)
StartA More Useful Loop (2:55)
StartPracticing Basic "for" Loops (4:22)
StartGo's "while" Loop (9:43)
StartPreparing Another Scenario (5:29)
StartLooping Through Collections (Arrays, Slices, Maps) (5:22)
Start"continue" and "break" (2:33)
StartModule Summary (2:47)
StartModule Resources

The Main Project: Building the “Monster Slayer” Game

StartModule Introduction (1:46)
StartPlanning the App (5:20)
StartInitializing The Project (2:12)
StartAdding The Core Game Steps & Logic (5:24)
StartOutputting Text & Adding a First Package (4:05)
StartKeeping Track Of The Active Round (4:59)
StartDisplaying Available Player Actions (3:38)
StartGetting Started With Fetching User Input (6:54)
StartValidating & Using User Input (11:05)
StartGenerating (True) Random Numbers (7:17)
StartAdding Logic For Different Actions (7:02)
StartUtilizing Constants (5:45)
StartChecking For A Winner (11:12)
StartAdding the "End Game" Logic (3:50)
StartOutputting Round Data (with a Struct) (18:05)
StartManaging Multiple Rounds (with a Slice) (5:45)
StartWriting To A Log File (10:11)
StartModule Summary (1:12)
StartModule Resources

Third-Party Modules & Building Go Apps

StartModule Introduction (1:17)
StartUsing Third-Party Modules (10:46)
StartBuilding & Distributing Modules
StartBuilding Go Projects (Standalone Executables) (3:50)
StartA Gotcha: Executables & File Paths (7:38)
StartModule Resources

Diving Deeper Into Values, Variables & Constants

StartModule Introduction (1:30)
StartVariables, Scope & Variable Shadowing (7:35)
Start"make"ing Values (10:26)
StartThe "new" Function (7:01)
Startnew vs make (1:21)
StartWorking With Custom Types (10:35)
StartMore On Custom Types
StartMore On Constants (7:55)
StartModule Summary (3:18)
StartModule Resources

Diving Deeper Into Functions

StartModule Introduction (0:59)
StartUsing Functions As Values & Function Types (15:10)
StartReturning Functions In Functions (6:21)
StartIntroducing Anonymous Functions (6:34)
StartWorking with Closures (6:42)
StartUsing Recursion (11:20)
StartIntroducing Variadic Functions (6:47)
StartSplitting Slices Into Parameter Lists (3:05)
StartDeferring Function Execution with "defer" (9:04)
StartPanic! (4:10)
StartModule Summary (2:42)
StartModule Resources

Working with Interfaces

StartModule Introduction (0:55)
StartWhat's the Problem? (6:31)
StartInterfaces As a Solution (i.e. What are Interfaces?) (6:17)
StartExample Time: Built-in Interfaces We Already Used (4:54)
StartInterfaces: Rules & Conventions (5:06)
StartEmpty Interfaces (4:36)
StartFlexible Code With Empty Interfaces & Type Switches (11:03)
StartModule Summary (1:30)
StartModule Resources

Embedding Interfaces & Structs

StartModule Introduction (0:44)
StartEmbedding Interfaces (8:15)
StartEmbedding Structs (5:57)
StartModule Resources

Concurrency, Goroutines & Channels

StartModule Introduction (0:53)
StartWhat Is Concurrency? (1:43)
StartIntroducing Goroutines (7:45)
StartWorking With Channels (8:59)
StartReading From A Channel Multiple Times (1:59)
StartTransmitting Values Via Channels (8:25)
StartLooping Through Channel Values (5:26)
StartUsing Buffered Channels (7:04)
StartUsing The "select" Statement (4:09)
StartModule Summary (2:43)
StartModule Resources

Course Prerequisites

NO prior Go knowledge is required. General programming knowledge (any language) helps but is also NOT required.