Go Bootcamp: Master Golang with 1000+ Exercises and Projects

Go Bootcamp: Master Golang with 1000+ Exercises and Projects

English | MP4 | AVC 1280×720 | AAC 44KHz 2ch | 23 Hours | 15.2 GB

Master and Deeply Understand Google’s Go from Scratch with Illustrated In-Depth Tutorials & 1000+ Hands-On Exercises.

Go is a programming language created by Google, and this course is the most intuitive, in-depth, and highest-quality Go course on Udemy, with an insane level of attention to detail. You’ll understand both the why and how. We’ve included thousands of animations, exercises, quizzes, examples, challenges, projects, and so on. By the end of the course, you’ll become a confident Go programmer from scratch.

Why should you take this course now?

Watch ultra-detailed, entertaining, intuitive, and easy to understand illustrations and animations.

Solve 1000+ hands-on exercises (solutions are also included).

Create projects including a log parser, file scanner, spam masker, and more.

Learn Go programming tips and tricks that you can’t find easily anywhere else.

Learn the Go internals and common Go idioms and best-practices.

Why should you learn Go (aka Golang and Go lang)?

Go is one of the most desired, easy to learn, and the highest paying programming languages. There are 1+ million Go programmers around the world, and the number is increasing each day exponentially. It’s been used by Google, Facebook, Twitter, Uber, Docker, Kubernetes, Heroku, and many others.

Go is Efficient like C, C++, and Java, and Easy to use like Python and Javascript. It’s Open-Source, Simple, Powerful, Efficient, Cross-Platform (OS X, Windows, Linux, …), Compiled, Garbage-Collected, and Concurrent.

Go is best for Command-line Tools, Web APIs, Distributed Network Applications like Microservices, Database Engines, Big-Data Processing Pipelines, and so on.

What are you going to learn from this course (briefly)?

  • Go OOP: Interfaces and Methods
  • Internals of Methods and Interfaces
  • Functions and Pointers: Program design, pass by value, and addressability.
  • Implicit interface satisfaction
  • Type assertion and Type Switch
  • Empty interface: []interface{} vs interface{}
  • Value, Pointer, and Nil Receivers
  • Promoted Methods
  • Famous Interfaces
  • Tips about when to use interfaces
  • fmt.Stringer, sort.Sort, json.Marshaler, json.Unmarshaler, and so on.
  • Composite Types: Arrays, Slices, Maps, and Structs
  • Internals of Slices and Maps
  • Backing array, slice header, capacity, and map header
  • JSON encoding and decoding, field tags, embedding
  • Make, copy, full Slice expressions and append mechanics
  • UTF-8 encoding and decoding
  • Go Type System Mechanics
  • Type inference, underlying, predeclared, and unnamed types.
  • Untyped constants and iota.
  • Blank Identifier, short declaration, redeclaration, scopes, naming conventions
  • I/O
  • Process Command-Line Arguments, printf, working with files, bufio.Scanner, …
  • How to create your own Go packages
  • How to run multiple Go files, and how to use third-party packages
  • Go tools
  • Debugging Go code, go doc, and others.
  • …and more.
Table of Contents

Setup your Environment
1 Grab the Roadmap!
2 Install Go on OS X
3 Install Go on Windows
4 Find your way in the code repository
5 Get the code for the course

Write Your First Go Program
6 Write Your First Go Program!
7 What is GOPATH
8 Create folders and files
9 Write your first program
10 Compile with go build
11 Learn the difference between Compile-Time and Runtime
12 Run with go run
13 FIRST GO PROGRAM EXERCISES
14 Packages
15 Let’s understand the first program
16 What is a package
17 Learn the differences between Executable and Library Packages
18 Scopes What is the importance of names
19 What is a package scope
20 The same names in the same package
21 Importing happens in the file scope
22 Renaming imported packages
23 Statements and Expressions
24 What is a statement
25 What is an expression
26 Print the number of CPUs
27 How Go comments work
28 What is Go Doc
29 FUNDAMENTALS EXERCISES
30 Write a Library Package!
31 Create your first library package
32 How Go standard library exports
33 Export a function from your package
34 LIBRARY PACKAGE EXERCISES

Master the Type System of Go
35 Variables
36 Roadmap
37 Introduction to Variables
38 Learn the basic data types of Go
39 DATA TYPES EXERCISES
40 How to declare a variable
41 Every Go type has a zero value
42 What is a blank identifier
43 How to declare multiple variables
44 Let’s declare a couple of variables!
45 DECLARATION EXERCISES
46 What is type inference
47 Why can’t you short declare a variable in the package-level
48 How to short declare multiple variables
49 What is redeclaration
50 When to use a short declaration
51 SHORT DECLARATION EXERCISES
52 How to assign to a single variable
53 How to assign to multiple variables
54 Mini Example Path Separator
55 ASSIGNMENT EXERCISES
56 Let’s convert a value!
57 Learn the importance of type names
58 TYPE CONVERSION EXERCISES
59 Get input from terminal
60 Learn the basics of os.Args
61 Greet people using os.Args
62 Recap Variables
63 OS.ARGS EXERCISES
64 Print Formatted Output
65 Println vs Printf
66 What is an Escape Sequence
67 How to print using Printf
68 The verbs can be type-safe too!
69 Recap Let’s summarize
70 PRINTF EXERCISES
71 Numbers and Strings
72 Learn the basic arithmetic operators of Go
73 What is the result of 32
74 Convert Celsius to Fahrenheit
75 What is the IncDec Statement
76 Calculate the area using assignment operations
77 Convert Feet to Meters
78 Recap Numbers
79 NUMBERS EXERCISES
80 What is a Raw String Literal
81 How to combine multiple strings
82 How to get the length of a string
83 Example Banger Yell it back!
84 Recap Strings
85 STRINGS EXERCISES
86 Go Type System Mechanics
87 Introduction and Roadmap
88 [For Beginners] Bits and Bytes #1
89 [For Beginners] Bits and Bytes #2
90 What is a Predeclared Type
91 Overflow Go beyond
92 Understand the Defined Types
93 Defined Types Real-Life Example
94 Create Your Own Types
95 Underlying Types
96 Underlying Types Example
97 Aliased Types Don’t use it at home
98 Recap Go Type System
99 TYPES EXERCISES
100 Untyped Constants
101 Introduction and Roadmap
102 Why might you want to use a constant
103 Learn the rules of constants
104 Examples of Typed Constants
105 How to declare multiple constants
106 Recap Constants
107 How untyped constants work under the hood
108 What is a Default Type
109 Example time.Duration
110 Refactor Feet to Meters
111 Recap Typeless Constants
112 What is iota
113 Recap iota
114 CONSTANTS EXERCISES
115 Naming Things Recommendations

Control Flow and Error Handling
116 If Statement
117 Introduction and Roadmap
118 [For Beginners] Comparison Operators
119 Learn the relation between comparison and assignability
120 [For Beginners] Logical AND
121 [For Beginners] Logical OR
122 [For Beginners] Logical NOT
123 Recap Boolean Operators
124 [For Beginners] If Statement
125 [For Beginners] Else and Else If
126 Refactor Feet to Meters
127 Recap If Statement
128 IF EXERCISES
129 Pass Me Create a Password-Protected Program
130 Tiny Challenge Validate a single user
131 Solution Validate a single user
132 Tiny Challenge Validate multiple users
133 Solution Validate multiple users
134 Error Handling
135 Introduction
136 What is a nil value
137 What is an error value
138 Error handling example
139 Challenge Feet to Meter
140 Solution Feet to Meter
141 Recap Error Handling
142 What is a Simple Statement
143 Scopes of simple statements
144 Famous Shadowing Gotcha
145 Recap Error Handling
146 ERR HANDLING EXERCISES
147 Switch Statement
148 Introduction and Roadmap
149 Learn the Switch Statement Basics
150 What is a default clause
151 Use multiple values in case conditions
152 Use bool expressions in case conditions
153 How does the fallthrough statement work
154 What is a short switch
155 Tiny Challenge Parts of a Day
156 Solution Parts of a Day
157 If vs Switch Which one to use
158 Recap Switch Statement
159 SWITCH EXERCISES
160 Loops
161 Introduction and Roadmap
162 There is only one loop statement in Go
163 How to break from a loop
164 How to continue a loop (+BONUS Debugging)
165 Create a multiplication table
166 LOOP EXERCISES #1
167 How to loop over a slice
168 For Range Learn the easy way!
169 Recap Loops
170 LOOP EXERCISES #2

Projects For Beginners
171 Randomization in Go
172 Randomization and Go
173 Seed the randomizer with time
174 Write the Game Logic
175 RANDOMIZATION EXERCISES
176 Mini Project Word Finder
177 Build the Word Finder Program
178 Labeled Break and Continue
179 Break from a Switch
180 Yes there is a goto statement in Go
181 LABELED STATEMENT EXERCISES

Arrays and Memory Layout
182 Learn Go’s Fixed Arrays
183 Introduction and Roadmap
184 What is an array in Go
185 Let’s create an array
186 Learn the gotcha when using a for range on arrays
187 What is a composite literal
188 Refactor the Hipster’s Love Bookstore to array literals
189 Tiny Challenge #1 Moodly
190 Can you compare array values
191 Can you assign an array value to another one
192 ARRAYS EXERCISES #1
193 How to use multi-dimensional arrays
194 Tiny Challenge #2 Moodly
195 Learn the rarely known feature of Go The Keyed Elements
196 Learn the relation between composite and unnamed types
197 Recap Arrays
198 ARRAYS EXERCISES #2

Project Write a Retro Clock
199 Grab the Slides!
200 Challenge Retro Led Clock
201 Challenge Explanation
202 Let’s print the digits
203 Let’s print the clock
204 It’s time to animate the clock!
205 RETRO CLOCK EXERCISES

Slices and Internals
206 Slices Master Go’s Dynamic Arrays
207 Introduction and Roadmap
208 Learn the differences between slices and arrays
209 Can you compare a slice to another one
210 Create a unique number generator
211 SLICE EXERCISES
212 Append Let’s grow a slice!
213 APPEND EXERCISES
214 Slicing Let’s cut that slice!
215 How to create pagination using slices (+ Sprintf)
216 SLICING EXERCISES
217 Slice Internals
218 What is a Backing Array
219 What’s a slice header
220 What does a slice header look like in the actual Go runtime code
221 What is the capacity of a slice
222 Extend a slice using its capacity
223 When does the append function create a new backing array
224 Animate When the backing array of a slice grows
225 SLICE INTERNALS EXERCISES
226 Advanced Operations
227 Full Slice Expressions Limit the capacity of a slice
228 make() Preallocate the backing array
229 copy() Copy elements between slices
230 How to use multi-dimensional slices
231 ADVANCED SLICE OPS EXERCISES

Project Write a File Finder
232 Build an Empty File Finder Program
233 Fetch the Files
234 Write to a file
235 Optimize!
236 FILE FINDER EXERCISES

Project Animate a Bouncing Ball
237 Project Animate a Bouncing Ball
238 Challenge
239 Challenge Document
240 Step #1 Create and Draw the Board
241 Step #2 Optimize by adding a Buffer
242 Step #3 Animate the Ball
243 BOUNCING BALL EXERCISES

UTF-8 Encode and Decode
244 Learn how to encode and decode UTF-8 strings
245 Introduction and Roadmap
246 Resources
247 Let’s learn the basics of bytes, runes and strings
248 Let’s write a character-set program
249 Let’s convert, index, and slice bytes, runes and strings
250 How can you decode a string
251 String Header Why strings are immutable
252 Recap Strings Revisited
253 UTF-8 EXERCISES

Project Create a Spam Masker
254 Project Let’s Build a Spam Masker
255 Challenge
256 Challenge Document
257 Detect the link patterns
258 Mask the links
259 Text Wrapper Challenge
260 Let’s build a Unicode text wrapper

Maps and Internals
261 Learn Go’s Maps and Internals
262 Create an English to Turkish dictionary
263 Populate the dictionary
264 Map Internals How maps work behind the scenes
265 MAP EXERCISES

Project Create a Log Parser
266 Scan for Input using bufio.Scanner
267 Scan user input using bufio.Scanner
268 Use maps as sets
269 Create a Log Parser using maps and bufio.Scanner
270 SCANNER EXERCISES

Structs Encode and Decode JSON
271 Structs Organize Data
272 What is a struct
273 Let’s create a struct!
274 When can you compare struct values
275 Go OOP Struct Embedding
276 Rewrite Log Parser to Structs
277 Encode values to JSON
278 Decode values from JSON
279 STRUCT EXERCISES

Functions, Pointers and Addressability
280 Functions The Building Blocks
281 Learn the function basics
282 Confine variables to a function
283 Rewrite Log Parser using functions
284 Learn the Pass By Value Semantics
285 Prove Yourself Functions
286 FUNC EXERCISES
287 Pointers Indirectly update data
288 What is a pointer
289 Learn the pointer mechanics
290 Learn how to work with pointers to composite types
291 Rewrite the Log Parser using Pointers
292 Pointers or Values Be Consistent
293 Prove Yourself Pointers
294 POINTER EXERCISES

Methods OOP with Go
295 Methods Grab the code
296 Methods Enhance types with additional behavior
297 Pointer Receivers Change the received value
298 Non-Structs Attach methods to almost any type

Interfaces Implicit OOP Way
299 Interfaces Grab the code!
300 Interfaces Be dynamic!
301 Type Assertion Extract the dynamic value!
302 Empty Interface Represent any type of value
303 Type Switch Detect and extract multiple values
304 Promoted Methods Let’s make a little bit of refactoring

Interfaces Marshaler, Sorter, and so on
305 Famous Interfaces Grab the code!
306 Don’t interface everything!
307 Stringer Grant a type the ability to represent itself as a string
308 Sorter Let a type know how to sort itself
309 Marshalers Customize JSON encoding and decoding of a type

BONUS SECTION THANK YOU!
310 Bonus Lecture