Published on: 2021-07-28 15:29:22
Categories: 28
Share:
Getting Started With Golang is a course that teaches all the key principles of using the Go programming language, which is one of the most sought after and popular languages.
Publisher: Academind
Instructors: Maximilian Schwarzmüller
Language: English
Education Level: Basic to Advanced
Number of Courses: 121
Duration: 11 hours and 30 minutes
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
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
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 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)
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)
“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)
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 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 (2:23)
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)
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)
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 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)
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)
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)
Working with Interfaces
Module Introduction (0:55)
What’s the Problem? (6:31)
Interfaces As a Solution (ie 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)
Embedding Interfaces & Structs
Module Introduction (0:44)
Embedding Interfaces (8:15)
Embedding Structs (5:57)
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)
NO prior Go knowledge is required.
General programming knowledge (any language) helps but is also NOT required.
After Extract, watch with your favorite Player.
Subtitle: None
Quality: 1080p
Course changes:
Version 2021/7 has increased by 40 lessons for about 4 hours compared to version 2021/6.
4.8 GB
Sharing is caring: