Academind – Getting Started with Golang 2021-7 – Download

explanation

Getting Started with Golang is a course that teaches all the core principles needed to use the Go programming language, one of the best and most popular languages.

Here’s what you’ll learn in the Getting Started with Golang course:

What is Go and how does it work?
Speaker structure and rules
Key principles of working with values and variables
Everything about what types of Go values are, how to change them, and how to use them.
How to write functions in Go language
Special features of this language, such as multiple return values
How to arrange code in packages and modules
Working with third-party modules
Run and build Go programs
It’s all about controlling the flow of your code using loops and conditionals.
Complex data structures such as structures
Data communities such as arrays, slices, maps, etc.
A complete and comprehensible understanding of “pointers”
Learn more advanced features like “recursion”.
Detailed description of the interface
Utilization and integration of interfaces and structures
All about synchronization, goroutines, and channels

Course specifications

Publisher: AcademyMind
teacher: Maximilian Schwarzmuller
Language: English
Education level: from basic to advanced
Number of courses: 121
Duration: 11 hours 30 minutes

Course topics: Getting started with Golang:

Getting started
Welcome to the course (1:00)
What’s going on? (6:12)
Why would you use Go? (3:52)
Install Go (3:55)
Setting up the code editor (VS Code) (2:40)
Finalizing Editor Configuration and First Run Code (6:53)
Basic programming knowledge is helpful! (1:55)
About this course (2:21)
How to get the most out of this course (3:50)
Enable code snapshot attachment

Go basics: values, variables, and types
Module introduction (1:26)
Basic syntax and language features (9:08)
Getting Started with Values and Value Types (5:25)
Variable Exploration (9:34)
“int” type and math operations (8:20)
Practice Time: Problems (5:38)
Practice Time: Solutions (10:24)
Working with floating point and type conversion (7:47)
float64 vs float32 (3:30)
Variables and “Null Values”
A quick look at the “bool”, “rune”, and “byte” types (7:10)
String Operations and Type Conflicts (6:26)
Working with multiline strings
Formatting Strings (11:05)
Practice Time: Problems (2:41)
Practice Time: Solutions (7:36)
Go Packages and Modules: Theory (5:33)
Creating and Using Your First Module (4:59)
Packages and Export + Import Operations (9:01)
Using Constant Values (Constants) (3:54)
Module Summary (2:52)
module resource

The Basics – Hands-on Time (Building a BMI Calculator App) Module Introduction (1:49)
Creating a Go module (4:23)
Print Output (3:40)
Get User Input (8:19)
Cleaning and Parsing User Input (10:15)
Calculating BMI and Outputting Rich Strings (3:40)
Using Constant Values (4:20)
Split Your Code into Files and Packages (7:38)
US/English units

function operations
Module introduction (0:49)
What is a “feature”? (3:49)
Creating functions and working with parameters + return values (10:10)
Skills Practice (3:43)
Go Special: Multiple Return Values (7:56)
Using Named Return Values (3:39)
Module Summary (1:38)

Features – Hands-on Time (Strengthening BMI Project)

Module Introduction (2:52)
Create your first function (3:44)
Outsourcing User Input Logic (5:21)
Finishing up refactoring the “main” function (5:22)
Avoid Code Duplication (6:24)
Module Summary (1:11)

Understanding pointers
Module Introduction (0:46)
What is a pointer and why do we have a pointer? (8:07)
Creating your first pointer (5:06)
Pointer Operations (5:35)
Advantages (and Disadvantages) of Pointers (8:47)

“Structure data using structures”
Module Introduction (0:54)
What and Why + First Struct Definition (9:25)
Creating a Structure Instance (6:21)
Creating structures using “creation functions” (3:39)
Structures and Pointers (4:31)
Accessing Structure Values (8:41)
Add methods to structures (7:19)
Module Summary (4:17)

Structures – Lab Time (Storing Data in Files)
Module Introduction (3:06)
Defining a Structure (3:29)
Creating a Structure Instance (9:44)
Add Method (5:02)
Reading user input (14:06)
Write to File (7:53)

Data collection: arrays, slices, maps

Module introduction (1:08)
Introduction to arrays for storing lists of data (8:02)
Working with Arrays (6:18)
Selecting Part of an Array with a Slice (3:26)
Different Ways to Use Slices (2:23)
Slice – A Deep Dive (9:43)
Creating a Dynamic List Using Fragments (9:16)
Practice Time – Problems (4:17)
Practice Time – Solutions (20:10)
Unpacking List Values (3:29)
Introduction to maps (6:48)
Map Transformation (3:41)
Maps and Structures (4:00)

Control Structure Operations
Module introduction (1:14)
Project Setup Tasks (5:34)
Introducing the “if” statement (3:46)
More about “if” statements and Boolean values (Boolean) (4:40)
“else” & “else if” (5:08)
Combining Conditions (4:28)
Using the “switch” statement
Expected Error Handling (8:10)
Returning an Error from a Function (3:33)
Putting What You Learn into Practice (13:50)
About “Loops” (Why do we need loops?) (5:44)
Introduction to the basic “for” loop (5:11)
More Useful Loops (2:55)
Practicing a basic “for” loop (4:22)
Go’s “While” Loop (9:43)
Preparing for Different Scenarios (5:29)
Iterating over collections (arrays, slices, maps) (5:22)
“Continue” and “Cut off” (2:33)
Module Summary (2:47)

Main project: Building the “Monster Slayer” game
Module Introduction (1:46)
Planning your app (5:20)
Project Initialization (2:12)
Add core game steps and logic (5:24)
Print text and add your first package (4:05)
Tracking Active Rounds (4:59)
Show available player actions (3:38)
Get started with getting user input (6:54)
Validating and Using User Input (11:05)
(True) Generating Random Numbers (7:17)
Add logic for various tasks (7:02)
Using Constants (5:45)
Confirm the winner (11:12)
Add “game over” logic (3:50)
Round data output (including structures) (18:05)
Managing Multiple Rounds (Using Slices) (5:45)
Write to log file (10:11)
Module Summary (1:12)

Building third-party modules and Go apps

Module Introduction (1:17)
Using third-party modules (10:46)
Building and Deploying Modules
Building a Go project (standalone executable) (3:50)
Issue: Executables and File Paths (7:38)

Learn more about values, variables, and constants
Module introduction (1:30)
Variables, scopes, and variable shadowing (7:35)
“Creating” Value (10:26)
“New” Features (7:01)
New vs. Created (1:21)
Working with Custom Types (10:35)
More information about custom types
More About Constants (7:55)
Module Summary (3:18)

Learn more about functions
Module introduction (0:59)
Using Functions as Values and Function Types (15:10)
Returning a function from a function (6:21)
Introduction to anonymous functions (6:34)
Working with closures (6:42)
Using recursion (11:20)
Introduction to Variadic Functions (6:47)
Split a Slice into a Parameter List (3:05)
Defer function execution using “defer” (9:04)
scare! (4:10)
Module Summary (2:42)

interface operations
Module introduction (0:55)
what’s the problem? (6:31)
Interface as a Solution (i.e. What is an Interface?) (6:17)
Time Example: Built-in Interfaces Already Used (4:54)
Interface: Rules and Rules (5:06)
Empty Interface (4:36)
Flexible Code with Empty Interfaces and Type Switches (11:03)
Module Summary (1:30)

Includes interfaces and structures
Module Introduction (0:44)
Embedding Interface (8:15)
Embedding Structure (5:57)

Concurrency, Goroutines, and Channels
Module introduction (0:53)
What is concurrency? (1:43)
Introduction to Goroutines (7:45)
Channel Operations (8:59)
Read multiple times from a channel (1:59)
Sending Values Through Channels (8:25)
Iterating through channel values (5:26)
Using Buffered Channels (7:04)
Using the “select” statement (4:09)
Module Summary (2:43)

Course Prerequisites:

No prior Go knowledge required.

General programming knowledge (any language) is helpful but not required.

movie

Getting started with Golang

Sample video getting started with Golang:

installation manual

After extracting, watch with your favorite players.

Subtitles: None

Quality: 1080p

Course changes:

The 2021/7 version has an increase of 40 lessons over approximately 4 hours compared to the 2021/6 version.