Autoplay
Autocomplete
Previous Lecture
Complete and Continue
[LEGACY] Getting Started With Golang
Getting Started
Welcome To The Course (1:00)
What Is Go? (6:12)
Why Would You Use Go? (3:52)
Installing Go (3:55)
Code Editor Setup (VS Code) (2:40)
Finishing Editor Config & First Go Code (6:53)
Basic Programming Knowledge Helps! (1:55)
About This Course (2:21)
How To Get The Most Out Of This Course (3:50)
Using Code Snapshot Attachments
The Academind Pro Referral Program
Go Basics: Values, Variables & Types
Module Introduction (1:26)
Base Syntax & Language Features (9:08)
Getting Started With Values & Value Types (5:25)
Exploring Variables (9:34)
The "int" Type & Math Operations (8:20)
Time To Practice: Problem (5:38)
Time To Practice: Solution (10:24)
Working With Floats & Type Conversions (7:47)
float64 vs float32 (3:30)
Variables & "Null Values"
A Brief Look At "bool", "rune" and "byte" Types (7:10)
String Operations & Type Clashes (6:26)
Working with Multiline Strings
Formatting Strings (11:05)
Time To Practice: Problem (2:41)
Time To Practice: Solution (7:36)
Go Packages & Modules: The Theory (5:33)
Creating & Using A First Module (4:59)
Working With Packages & Exports + Imports (9:01)
Using Constant Values (Constants) (3:54)
Module Summary (2:52)
Module Resources
Go Basics - Time To Practice (Building a BMI Calculator App)
Module Introduction (1:49)
Creating Our Go Module (4:23)
Printing Output (3:40)
Fetching User Input (8:19)
Cleaning & Parsing User Input (10:15)
BMI Calculation & Outputting Formatted Strings (3:40)
Using Constant Values (4:20)
Splitting Our Code Into Files & Packages (7:38)
US / English Units
Module Resources
Working with Functions
Module Introduction (0:49)
What Is A "Function"? (3:49)
Creating A Function & Working With Parameters + Return Values (10:10)
Practicing Functions (3:43)
Go Special Feature: Multiple Return Values (7:56)
Using Named Return Values (3:39)
Module Summary (1:38)
Module Resources
Functions - Time To Practice (Enhancing The BMI Project)
Module Introduction (2:52)
Creating a First Function (3:44)
Outsourcing The User Input Logic (5:21)
Finishing the "main" Function Refactoring (5:22)
Avoiding Code Duplication (6:24)
Module Summary (1:11)
Module Resources
Understanding Pointers
Module Introduction (0:46)
What Are Pointers & Why Do We Have Them? (8:07)
Creating a First Pointer (5:06)
Working With Pointers (5:35)
Advantages Of Pointers (& Disadvantages) (8:47)
Module Resources
"Struct"uring Data with Structs
Module Introduction (0:54)
What & Why + Defining a First Struct (9:25)
Creating Struct Instances (6:21)
Creating Structs With "Creation Functions" (3:39)
Structs & Pointers (4:31)
Accessing Struct Values (8:41)
Adding Methods To Structs (7:19)
Module Summary (4:17)
Module Resources
Structs - Time To Practice (Storing Data In Files)
Module Introduction (3:06)
Defining a Struct (3:29)
Creating Struct Instances (9:44)
Adding a Method (5:02)
Reading User Input (14:06)
Writing To Files (7:53)
Module Resources
Data Collections: Arrays, Slices & Maps
Module Introduction (1:08)
Introducing Arrays For Storing Lists Of Data (8:02)
Working With Arrays (6:18)
Selecting Parts Of Arrays With Slices (3:26)
More Ways Of Using Slices (4:26)
Slices - Deep Dive (9:43)
Creating Dynamic Lists With Slices (9:16)
Time To Practice - Problem (4:17)
Time To Practice - Solution (20:10)
Unpacking List Values (3:29)
Introducing Maps (6:48)
Mutating Maps (3:41)
Maps vs Structs (4:00)
Module Resources
Working With Control Structures
Module Introduction (1:14)
Working on the Project Setup (5:34)
Introducing "if" Statements (3:46)
More about "if" Statements & Boolean Values (Booleans) (4:40)
"else" & "else if" (5:08)
Combining Conditions (4:28)
Using "switch" Statements
Handling Expected Errors (8:10)
Returning Errors In Functions (3:33)
Practicing What We Learned (13:50)
Onwards To "Loops" (and why do we need them?) (5:44)
Introducing a Basic "for" Loop (5:11)
A More Useful Loop (2:55)
Practicing Basic "for" Loops (4:22)
Go's "while" Loop (9:43)
Preparing Another Scenario (5:29)
Looping Through Collections (Arrays, Slices, Maps) (5:22)
"continue" and "break" (2:33)
Module Summary (2:47)
Module Resources
The Main Project: Building the "Monster Slayer" Game
Module Introduction (1:46)
Planning the App (5:20)
Initializing The Project (2:12)
Adding The Core Game Steps & Logic (5:24)
Outputting Text & Adding a First Package (4:05)
Keeping Track Of The Active Round (4:59)
Displaying Available Player Actions (3:38)
Getting Started With Fetching User Input (6:54)
Validating & Using User Input (11:05)
Generating (True) Random Numbers (7:17)
Adding Logic For Different Actions (7:02)
Utilizing Constants (5:45)
Checking For A Winner (11:12)
Adding the "End Game" Logic (3:50)
Outputting Round Data (with a Struct) (18:05)
Managing Multiple Rounds (with a Slice) (5:45)
Writing To A Log File (10:11)
Module Summary (1:12)
Module Resources
Third-Party Modules & Building Go Apps
Module Introduction (1:17)
Using Third-Party Modules (10:46)
Building & Distributing Modules
Building Go Projects (Standalone Executables) (3:50)
A Gotcha: Executables & File Paths (7:38)
Module Resources
Diving Deeper Into Values, Variables & Constants
Module Introduction (1:30)
Variables, Scope & Variable Shadowing (7:35)
"make"ing Values (10:26)
The "new" Function (7:01)
new vs make (1:21)
Working With Custom Types (10:35)
More On Custom Types
More On Constants (7:55)
Module Summary (3:18)
Module Resources
Diving Deeper Into Functions
Module Introduction (0:59)
Using Functions As Values & Function Types (15:10)
Returning Functions In Functions (6:21)
Introducing Anonymous Functions (6:34)
Working with Closures (6:42)
Using Recursion (11:20)
Introducing Variadic Functions (6:47)
Splitting Slices Into Parameter Lists (3:05)
Deferring Function Execution with "defer" (9:04)
Panic! (4:10)
Module Summary (2:42)
Module Resources
Working with Interfaces
Module Introduction (0:55)
What's the Problem? (6:31)
Interfaces As a Solution (i.e. What are Interfaces?) (6:17)
Example Time: Built-in Interfaces We Already Used (4:54)
Interfaces: Rules & Conventions (5:06)
Empty Interfaces (4:36)
Flexible Code With Empty Interfaces & Type Switches (11:03)
Module Summary (1:30)
Module Resources
Embedding Interfaces & Structs
Module Introduction (0:44)
Embedding Interfaces (8:15)
Embedding Structs (5:57)
Module Resources
Concurrency, Goroutines & Channels
Module Introduction (0:53)
What Is Concurrency? (1:43)
Introducing Goroutines (7:45)
Working With Channels (8:59)
Reading From A Channel Multiple Times (1:59)
Transmitting Values Via Channels (8:25)
Looping Through Channel Values (5:26)
Using Buffered Channels (7:04)
Using The "select" Statement (4:09)
Module Summary (2:43)
Module Resources
The "int" Type & Math Operations
Lecture content locked
If you're already enrolled,
you'll need to login
.
Enroll in Course to Unlock