English | MP4 | AVC 1280×720 | AAC 44KHz 2ch | 294 lectures (28h 51m) | 13.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 Creating our first go program – hello gophers!
8 Exploring format printing and documentation
9 How computers work – core principles
10 ASCII, Unicode, & UTF-8 – understanding text
11 String literals and documentation
Hands-on exercises
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 #2 – go tour step 1 – 3
19 Hands-on exercise #3 – go tour step 4 – 7
20 Hands-on exercise #4 – go tour step 8 – 10
21 Hands-on exercise #5 – go tour step 11 – 13
22 Hands-on exercise #6 – go tour step 14 – 15
23 Hands-on exercise #7 – go tour step 16 – 17 – bitwise ops & bit shifting
24 Hands-on exercise #8 (was #03) – iota
25 Hands-on exercise #9 (was #04) – measuring bits with bitwise operations
26 Hands-on exercise #10 (was #05) – zero value, =, type specificity, blank identi
27 Hands-on exercise #11 (was #06) – printf verbs to show values and types
28 Hands-on exercise #12 (was #07) – printf binary, decimal, & hexadecimal
29 Hands-on exercise #13 (was #08) – signed and unsigned int
Programming fundamentals for beginners
30 Introduction
31 Terminology
32 Understanding scope
33 Working at the terminal
34 Using bash on Windows
35 Terminal commands – part 1
36 Terminal commands – part 2
37 Github and ssh authentication
38 Setting up a github repo
39 Checksums
Your development environment
40 Getting up and running
41 Running go programs on your machine
42 Go install puts binary in $GOPATHbin.encrypted
Go mod and dependency management
43 Introduction to go modules & dependency management
44 Modular code, dependency mgmt, go get – overview
45 Go modules in action go mod init & go mod tidy
46 Looking at the documentation for go mod tidy
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
COURSE UPDATE – MORE VIDEOS COMING TOMORROW! – END OF NEW CONTENT UNTIL TOMORROW
181 COURSE UPDATE EXPLANATION
Application
182 JSON documentation
183 JSON marshal
184 JSON unmarshal
185 Writer interface
186 Sort
187 Sort custom
188 bcrypt
Exercises – Ninja Level 8
189 Hands-on exercise #1
190 Hands-on exercise #2
191 Hands-on exercise #3
192 Hands-on exercise #4
193 Hands-on exercise #5
Concurrency
194 Concurrency vs parallelism
195 WaitGroup
196 Method sets revisited
197 Documentation
198 Race condition
199 Mutex
200 Atomic
Exercises – Ninja Level 9
201 Hands-on exercise #1
202 Hands-on exercise #2
203 Hands-on exercise #3
204 Hands-on exercise #4
205 Hands-on exercise #5
206 Hands-on exercise #6
Channels
207 Understanding channels
208 Directional channels
209 Using channels
210 Range
211 Select
212 Comma ok idiom
213 Fan in
214 Fan out
215 Context
Exercises – Ninja Level 10
216 Hands-on exercise #1
217 Hands-on exercise #2
218 Hands-on exercise #3
219 Hands-on exercise #4
220 Hands-on exercise #5
221 Hands-on exercise #6
222 Hands-on exercise #7
Error handling
223 Understanding
224 Checking errors
225 Printing and logging
226 Recover
227 Errors with info
Exercises – Ninja Level 11
228 Hands-on exercise #1
229 Hands-on exercise #2
230 Hands-on exercise #3
231 Hands-on exercise #4
Writing documentation
233 Introduction
234 go doc
235 godoc
236 godoc.org
237 Writing documentation
Exercises – Ninja Level 12
238 Hands-on exercise #1
Testing & benchmarking
239 Introduction
240 Table tests
241 Example tests
242 Golint
243 Benchmark
244 Coverage
245 Benchmark examples
246 Review
Exercises – Ninja Level 13
247 Hands-on exercise #1
248 Hands-on exercise #2
249 Hands-on exercise #3
Farewell
250 Congratulations
Repetition leads to mastery
251 The original course
Concurrency
252 Concurrency & WaitGroup
253 Parallelism
254 Race Conditions
255 Mutex
256 Atomicity
257 Review & Channels Preview
Channels
258 Channels – Introduction
259 Range Clause
260 N-to-1
261 Semaphores – Part 1
262 Semaphores – Part 2
263 to-N
264 Channels as Arguments & Returns
265 Channel Direction
Applied Concurrency
266 Incrementor With Channels
267 Deadlock Challenge
268 Factorial Challenge
269 Pipeline Pattern
270 Factorial Challenge Redux
271 Factorial Challenge Redux Solution
272 Fan Out Fan In Pattern – Overview
273 Fan In Pattern
274 Fan Out Fan In – Example
Concurrency Challenges
275 Fan Out Fan In – Challenge
276 Fan Out Fan In – Solution
277 Fan Out Fan In – Challenge Factorial
278 Fan Out Fan In – Solution Factorial
279 Deadlock Challenge
280 Deadlock Solution
281 Incrementor Challenge Revisited
282 Incrementor Solution
Concurrency Resources
283 Additional Resources
Error Handling
284 An Introduction to Error Handling in Go
285 Improving Your Code with Golint
286 Handling Errors & Logging Errors to a File
287 Four Common Ways to Handle Errors
288 Custom Errors – Creating Values of Type error
289 Idiomatic Error Handling
290 Providing Context with Errors
291 Providing Even More Context with Errors
292 Error Handling Review & Resources
Farewell
293 Congratulations
294 Bonus lecture
Resolve the captcha to access the links!