English | MP4 | AVC 1280×720 | AAC 44KHz 2ch | 301 lectures (29h 12m) | 18.13 GB
The Ultimate Comprehensive Course – Perfect for Both Beginners and Experienced Developers
Go is an open source programming language that makes it easy to build simple, reliable, and efficient software.
Go is an amazing choice for a language as it was developed by some of the same individuals who created the C programming language, Unix, and UTF-8 – some of the most influential contributions to computer science. Robert Griesemer, Rob Pike, and Ken Thompson created Go to be a modern language that easily uses multiple cores, easily implements concurrency, easily works in distributed environments, and easily allows the programmer to write programs – it has a very lean and user-friendly syntax.
Go was created by luminaries in computer science at one of the best, if not the very best, software engineering firm to have ever existed – Google.
The credentials of Go are unsurpassed.
But why did Google create a new language?
In Google’s words, “Go was born out of frustration with existing languages and environments for systems programming. Programming had become too difficult and the choice of languages was partly to blame. One had to choose either efficient compilation, efficient execution, or ease of programming; all three were not available in the same mainstream language. Programmers who could were choosing ease over safety and efficiency by moving to dynamically typed languages such as Python and JavaScript rather than C++ or, to a lesser extent, Java. Go is an attempt to combine the ease of programming of an interpreted, dynamically typed language with the efficiency and safety of a statically typed, compiled language. It also aims to be modern, with support for networked and multicore computing. Finally, working with Go is intended to be fast: it should take at most a few seconds to build a large executable on a single computer. To meet these goals required addressing a number of linguistic issues: an expressive but lightweight type system; concurrency and garbage collection; rigid dependency specification; and so on. These cannot be addressed well by libraries or tools; a new language was called for.”
In my opinion, Go is the best programming language that you can be learning today. I began programming in 1982 with BASIC, I have worked with many languages, and Go is the best language which I have ever used. Go is also the top-paid programming language in America today.
Come learn about the greatest programming language ever created. You will leave with resources and code samples to start making all of your software and apps really go.
Table of Contents
Course introduction
1 Welcome
2 Course resources
3 Additional resources
4 The Power of Education to Transform Lives
Getting going with Go
5 Why Go
6 Documentation & example code
7 Exploring format printing and documentation
8 How computers work – core principles
9 ASCII, Unicode, & UTF-8 – understanding text
10 String literals and documentation
Hands-on exercises
11 Preface for Hands-on exercise #1
12 Hands-on exercise #1
The fundamentals of Go
13 Variables, zero values, blank identifier
14 Using printf for decimal & hexadecimal values
15 Numeral systems decimal, binary, & hexadecimal
16 Values, types, conversion, scope, & housekeeping
17 Built-in types, aggregate types, and composition
Hands-on exercises
18 Hands-on exercise #3 – go tour step 4 – 7
19 Hands-on exercise #4 – go tour step 8 – 10
20 Hands-on exercise #5 – go tour step 11 – 13
21 Hands-on exercise #6 – go tour step 14 – 15
22 Hands-on exercise #7 – go tour step 16 – 17 – bitwise ops & bit shifting
23 Hands-on exercise #8 (was #03) – iota
24 Hands-on exercise #9 (was #04) – measuring bits with bitwise operations
25 Hands-on exercise #10 (was #05) – zero value, =, type specificity, blank identi
26 Hands-on exercise #11 (was #06) – printf verbs to show values and types
27 Hands-on exercise #12 (was #07) – printf binary, decimal, & hexadecimal
28 Hands-on exercise #13 (was #08) – signed and unsigned int
Programming fundamentals for beginners
29 Introduction
30 Terminology
31 Understanding scope
32 Working at the terminal
33 Using bash on Windows
34 Terminal commands – part 1
35 Terminal commands – part 2
36 Github and ssh authentication
37 Setting up a github repo
38 Checksums
Your development environment
39 Getting up and running
40 Running go programs on your machine
41 Go install puts binary in $GOPATHbin
Go mod and dependency management
42 Introduction to go modules & dependency management
43 Modular code, dependency mgmt, go get – overview
44 Go modules in action go mod init & go mod tidy
45 Looking at the documentation for go mod tidy
46 Package visibility visible, not visible; exported, not exported
47 Modular code, dependency mgmt, go get – #1
48 Modular code, dependency mgmt, go get – #2
49 Tag git commits with version – overview
50 Tag git commits with version – example #1
51 Tag git commits with version – example #2
52 Specifying dependency version
Hands-on exercises
53 Hands-on exercise #14 (was #09)
54 Hands-on exercise #15 (was #10)
55 Hands-on exercise #16 (was #11)
56 Hands-on exercise #17 (was #12)
57 Hands-on exercise #18 (was #13)
58 Hands-on exercise #19 (was #14)
59 Hands-on exercise #20 (was #15)
60 Hands-on exercise #21 (was #16)
61 Hands-on exercise #22 & git clone (was #17)
Housekeeping – Hash Algorithms, Symmetric & Asymmetric Encryption, Communication
62 Hash Algorithms, Symmetric & Asymmetric Encryption, & Network Communication
Control Flow
63 Previewing code
64 Understanding control flow
65 If statements & comparison operators
66 Understanding & using Logical operators
67 The statement; statement & comma, ok idioms
68 Using switch statements to make decisions in code
69 Using select statements for concurrency communication
70 Understanding & using for statement to create loops
71 Multiple iteration – nesting a loop within a loop
72 Understanding & using for range loops
73 Finding a modulus remainder
Hands-on exercises
74 Hands-on exercise #23 (was #18)
75 Hands-on exercise #24 (was #19)
76 Hands-on exercise #25 (was #20)
77 Hands-on exercise #26 (was #21)
78 Hands-on exercise #27 (was #22)
79 Hands-on exercise #28 (was #23)
80 Hands-on exercise #29 (was #24)
81 Hands-on exercise #30 (was #25)
82 Hands-on exercise #31 (was #26) & infinite loops
83 Hands-on exercise #32 (was #27)
84 Hands-on exercise #33 (was #28) & a joke
85 Hands-on exercise #34 (was #29)
86 Hands-on exercise #35 (was #30)
87 Hands-on exercise #36 (was #31)
88 Hands-on exercise #37 (was #32)
89 Hands-on exercise #38 (was #33)
90 Hands-on exercise #39 (was #34)
91 Additional code
Grouping data values – array & slice
92 Review and preview
93 Introduction to grouping values
94 Array – an introduction to arrays
95 Hands-on exercise #40
96 Slice – composite literal
97 Hands-on exercise #41
98 Slice – for range & access values by index position
99 Slice – append to a slice
100 Slice – slicing a slice
101 Slice – deleting from a slice
102 Slice – make
103 Slice – multidimensional slice
104 Slice – slice internals & underlying array – 01
105 Slice – slice internals & underlying array – 02
106 Slice – slice internals & underlying array – 03
Hands-on exercises
107 Hands-on exercise #42
108 Hands-on exercise #43
109 Hands-on exercise #44
110 Hands-on exercise #45
111 Hands-on exercise #46
112 Hands-on exercise #47
113 Hands-on exercise #48
Grouping data values – map
114 Map – introduction
115 Map – for range over a map
116 Map – delete element
117 Map – comma ok idiom
118 Map – counting words in a book
Hands-on exercises
119 Hands-on exercise #49 – map[string][]string
120 Hands-on exercise #50 – add a record
121 Hands-on exercise #51 – delete a record
122 Hands-on exercise #52 – word frequency
Grouping data values – structs
123 Struct introduction
124 Embedded structs
125 Anonymous structs
126 Composition
Hands-on exercises
127 Hands-on exercise #53 – struct with slice
128 Hands-on exercise #54 – map struct
129 Hands-on exercise #55 – embed struct
130 Hands-on exercise #56 – anonymous struct
Functions in the go programming language
131 Introduction to functions
132 Syntax of functions in Go
133 Variadic parameter
134 Unfurling a slice
135 Defer
136 Methods
137 Interfaces & polymorphism
138 Exploring the stringer interface
139 Expanding on the stringer interface – wrapper func for logging
140 Writer interface & writing to a file
141 Writer interface & writing to a byte buffer
142 Writing to either a file or a byte buffer
143 Anonymous func
144 func expression
145 Returning a func
146 Callback
147 Closure
148 Function fundamentals
149 Recursion
150 Wrapper function
Hands-on exercises
151 Hands-on exercise #57 – func concepts
152 Hands-on exercise #58 – basic funcs
153 Hands-on exercise #59 – variadic func
154 Hands-on exercise #60 – defer func
155 Hands-on exercise #61 – method
156 Hands-on exercise #62 – interfaces
157 Hands-on exercise #63 – tests in go #1
158 Hands-on exercise #64 – tests in go #2 – unit tests
159 Hands-on exercise #65 – tests in go #3 – unit tests
160 Hands-on exercise #66 – documenting code with comments
161 Hands-on exercise #67 – interfaces & mock testing a db
162 Hands-on exercise #68 – anonymous func
163 Hands-on exercise #69 – func expression
164 Hands-on exercise #70 – func return
165 Hands-on exercise #71 – callback
166 Hands-on exercise #72 – closure
167 Hands-on exercise #73 – wrapper
Pointers
168 What are pointers
169 Seeing type & value for pointers
170 Dereferencing pointers
171 Pass by value, pointers reference types, and mutability
172 Pointer & value semantics defined
173 Pointer & value semantics heuristics
174 Pointers, values, the stack, & the heap
175 Exploring method sets part 1
176 Exploring method sets part 2
Hands-on exercises
177 Hands-on exercise #74 – create a pointer
178 Hands-on exercise #75 – dereference an address
179 Hands-on exercise #76 – interface implementation & method sets
180 Hands-on exercise #77 – value & pointer semantics
Generics
181 Type constraint
182 Type constraint & type set interface example
183 Type alias & underlying type constraints
184 Package constraints
185 Generics tutorial
186 Concrete type vs interface type
Application
187 JSON marshal
188 JSON unmarshal
189 Writer interface
190 Sort
191 Sort custom
192 bcrypt
Exercises – Ninja Level 8
193 Hands-on exercise #1
194 Hands-on exercise #2
195 Hands-on exercise #3
196 Hands-on exercise #4
197 Hands-on exercise #5
Concurrency
198 Concurrency vs parallelism
199 WaitGroup
200 Method sets revisited
201 Documentation
202 Race condition
203 Mutex
204 Atomic
Exercises – Ninja Level 9
205 Hands-on exercise #1
206 Hands-on exercise #2
207 Hands-on exercise #3
208 Hands-on exercise #4
209 Hands-on exercise #5
210 Hands-on exercise #6
Channels
211 Understanding channels
212 Directional channels
213 Using channels
214 Range
215 Select
216 Comma ok idiom
217 Fan in
218 Fan out
219 Context
Exercises – Ninja Level 10
220 Hands-on exercise #1
221 Hands-on exercise #2
222 Hands-on exercise #3
223 Hands-on exercise #4
224 Hands-on exercise #5
225 Hands-on exercise #6
226 Hands-on exercise #7
Error handling
227 Understanding
228 Checking errors
229 Printing and logging
230 Recover
231 Errors with info
Exercises – Ninja Level 11
232 Hands-on exercise #1
233 Hands-on exercise #2
234 Hands-on exercise #3
235 Hands-on exercise #4
236 Hands-on exercise #5
Writing documentation
237 Introduction
238 go doc
239 godoc
240 godoc.org
241 Writing documentation
Exercises – Ninja Level 12
242 Hands-on exercise #1
Testing & benchmarking
243 Introduction
244 Table tests
245 Example tests
246 Golint
247 Benchmark
248 Coverage
249 Benchmark examples
250 Review
Exercises – Ninja Level 13
251 Hands-on exercise #1
252 Hands-on exercise #2
253 Hands-on exercise #3
Farewell
254 Congratulations
Repetition leads to mastery
255 The original course
Concurrency
256 Concurrency & WaitGroup
257 Parallelism
258 Race Conditions
259 Mutex
260 Atomicity
261 Review & Channels Preview
Channels
262 Channels – Introduction
263 Range Clause
264 N-to-1
265 Semaphores – Part 1
266 Semaphores – Part 2
267 to-N
268 Channels as Arguments & Returns
269 Channel Direction
Applied Concurrency
270 Incrementor With Channels
271 Deadlock Challenge
272 Factorial Challenge
273 Pipeline Pattern
274 Factorial Challenge Redux
275 Factorial Challenge Redux Solution
276 Fan Out Fan In Pattern – Overview
277 Fan In Pattern
278 Fan Out Fan In – Example
Concurrency Challenges
279 Fan Out Fan In – Challenge
280 Fan Out Fan In – Solution
281 Fan Out Fan In – Challenge Factorial
282 Fan Out Fan In – Solution Factorial
283 Deadlock Challenge
284 Deadlock Solution
285 Incrementor Challenge Revisited
286 Incrementor Solution
Concurrency Resources
287 Additional Resources
Error Handling
288 An Introduction to Error Handling in Go
289 Improving Your Code with Golint
290 Handling Errors & Logging Errors to a File
291 Four Common Ways to Handle Errors
292 Custom Errors – Creating Values of Type error
293 Idiomatic Error Handling
294 Providing Context with Errors
295 Providing Even More Context with Errors
296 Error Handling Review & Resources
Farewell
297 Congratulations
298 Bonus lecture
Resolve the captcha to access the links!