WEBVTT 1 00:00:00.080 --> 00:00:03.520 Welcome to the deep dive. Today. We're really getting into 2 00:00:03.560 --> 00:00:06.440 the fundamentals of the Go programming language. We're using Go 3 00:00:06.519 --> 00:00:10.359 fundamentals Go for guides as our source here, and our 4 00:00:10.439 --> 00:00:13.960 mission really is to pull out the core ideas how 5 00:00:14.039 --> 00:00:18.000 GOT structures projects, it's basic elements, how it handles dependencies, 6 00:00:18.519 --> 00:00:21.839 basically giving you a solid understanding without feeling like you're 7 00:00:21.879 --> 00:00:23.239 reading a textbook exactly. 8 00:00:23.440 --> 00:00:29.280 We'll be looking at modules, packages, dependencies obviously, but also 9 00:00:29.519 --> 00:00:32.520 the language basics, numbers, strings. 10 00:00:32.560 --> 00:00:34.840 Booleans, variables, constants. 11 00:00:34.520 --> 00:00:37.679 Variables, constants, how to format things, and then collections like 12 00:00:37.759 --> 00:00:43.679 arrays and slices, maps, control structures, functions, interfaces. 13 00:00:43.240 --> 00:00:45.960 Error handling too, right, yeah, and concurrency it's a big one. 14 00:00:45.960 --> 00:00:50.640 And go oh yeah, definitely, guroteines, channels, context synchronization, primitives, 15 00:00:50.759 --> 00:00:53.399 even touching on the filesystem stuff. It's quite a bit, 16 00:00:53.399 --> 00:00:54.159 but we'll break it down. 17 00:00:54.200 --> 00:00:57.119 That's good. So for you listening, maybe you're prepping for 18 00:00:57.159 --> 00:00:59.640 a tech chat, or just want to brush up on Go, 19 00:00:59.840 --> 00:01:02.479 or you're just curious, this deep dive should give you 20 00:01:02.560 --> 00:01:05.680 a structured, insightful look. Hopefully some moha moments along the way, 21 00:01:05.959 --> 00:01:08.680 let's hope. So okay, let's start unpacking it at the 22 00:01:08.799 --> 00:01:11.920 very foundation. How does Go organized code. 23 00:01:11.599 --> 00:01:15.079 Right, It really starts with modules. Think of the Go 24 00:01:15.159 --> 00:01:19.599 dot mod file. It's goes way of promising reproducible builds. 25 00:01:19.599 --> 00:01:21.280 Reproducible builds meaning naing. 26 00:01:21.120 --> 00:01:23.159 Everyone on the team or you know, your build server 27 00:01:23.480 --> 00:01:26.680 uses the exact same versions of all the libraries. The 28 00:01:26.719 --> 00:01:29.079 Go dot mod file names your project, says what Go 29 00:01:29.239 --> 00:01:31.560 version it needs. Like the examples we looked at use 30 00:01:31.760 --> 00:01:32.719 Go one point nineteen. 31 00:01:32.760 --> 00:01:35.599 Okay, so godat mod is the project manifest and inside 32 00:01:35.599 --> 00:01:37.280 modules we have packages exactly. 33 00:01:37.400 --> 00:01:41.519 Packages are the fundamental unit of importable code. The key 34 00:01:41.560 --> 00:01:45.400 thing with naming them. Keep it short, simple, easy to recognize. 35 00:01:44.840 --> 00:01:47.400 Like squile L or HDPP precisely. 36 00:01:47.040 --> 00:01:50.439 Much better than say structured query language. Imagine typing that 37 00:01:50.480 --> 00:01:51.599 out every time you use it. 38 00:01:51.680 --> 00:01:54.040 Yeah, that would get old fast. Yeah. What if you 39 00:01:54.079 --> 00:01:57.120 have two packages with the same name, like from different places. 40 00:01:57.159 --> 00:02:00.599 Ah, good question. That's where import aliasing comes in. If 41 00:02:00.640 --> 00:02:03.719 you import say demo fubar and maybe another place bar, 42 00:02:03.799 --> 00:02:06.680 you can give one an alias like import pub demo fubar. 43 00:02:06.879 --> 00:02:08.879 Oh I see, so you'd use pub dot function name 44 00:02:08.960 --> 00:02:11.520 for one and maybe just bar another function for the 45 00:02:11.560 --> 00:02:12.319 other exactly. 46 00:02:12.360 --> 00:02:14.800 It avoids those name clashes and keeps things clear. 47 00:02:14.919 --> 00:02:18.840 Okay, so go dot mod tracks external stuff packages organize 48 00:02:18.840 --> 00:02:21.879 your internal code. How do you actually get those external libraries? 49 00:02:21.919 --> 00:02:24.039 That's the go get command. So if you need let's 50 00:02:24.080 --> 00:02:27.159 say that fleck library for working with words, Yeah, you 51 00:02:27.319 --> 00:02:31.319 just run Go get GitHub dot Com forward Slash, go Buffalo, flecked, 52 00:02:31.840 --> 00:02:36.240 Go fetches. It updates your Go dot mod with the dependency. 53 00:02:35.599 --> 00:02:37.800 In the version, and it also creates that go dot 54 00:02:37.800 --> 00:02:39.919 sum file. Right. What's that for again? 55 00:02:40.120 --> 00:02:43.120 Right, the go dot sum It's basically a lockfile with 56 00:02:43.199 --> 00:02:46.840 cryptographic hashes like digital fingerprints for your dependencies. It ensures 57 00:02:46.919 --> 00:02:49.319 the code you downloaded is exactly what it's supposed to be, 58 00:02:49.479 --> 00:02:53.240 hasn't been tampered with. Consistency and security, got. 59 00:02:53.039 --> 00:02:56.560 It like a security checkpoint and versions. How does go 60 00:02:56.719 --> 00:02:57.800 handle updates? 61 00:02:57.960 --> 00:03:01.240 It uses semantic versioning, you know, the major dot minor 62 00:03:01.319 --> 00:03:02.599 dot patch system. 63 00:03:02.360 --> 00:03:05.719 Where major means breaking changes, minor means new features, Patch 64 00:03:05.759 --> 00:03:07.319 means fixes pretty much. 65 00:03:07.400 --> 00:03:10.319 Yeah, Go get usually updates you to the latest minor 66 00:03:10.439 --> 00:03:13.719 or patch versions safely. One thing I'll watch out for, though, 67 00:03:13.800 --> 00:03:15.599 is sychnical imports. 68 00:03:15.240 --> 00:03:17.680 Where package A needs b and B needs. 69 00:03:17.479 --> 00:03:20.800 A Yeah, that can get messy fast, generally best to 70 00:03:20.840 --> 00:03:21.199 avoid that. 71 00:03:21.240 --> 00:03:25.360 Structure makes sense, Okay, modules, packages, dependencies clear. Now let's 72 00:03:25.360 --> 00:03:27.520 dive into the language itself, the basics. 73 00:03:27.639 --> 00:03:31.759 Okay, So GO is statically typed. 74 00:03:31.639 --> 00:03:34.479 Meaning it checks types before you run the code. 75 00:03:34.280 --> 00:03:37.000 Exactly, catches lots of errors early, like trying to add 76 00:03:37.039 --> 00:03:40.159 text to a number. It's also compiled straight to machine code, 77 00:03:40.240 --> 00:03:42.759 so it's fast, and it has garbage collection. 78 00:03:42.919 --> 00:03:44.599 The automatic memory cleanup. 79 00:03:44.280 --> 00:03:47.039 Crew that's the one takes a lot of manual memory 80 00:03:47.080 --> 00:03:48.719 management burden off the developer. 81 00:03:49.159 --> 00:03:52.159 Big plus definitely sounds helpful. Yeah, okay, let's talk numbers. 82 00:03:52.159 --> 00:03:52.879 What are the options? 83 00:03:53.039 --> 00:03:55.879 GO gives you a fair range. You've got integers signed 84 00:03:56.000 --> 00:03:58.479 in tate through in sixty four and unsigned and dad 85 00:03:58.680 --> 00:04:01.080 on sixty four plus t us the general int and 86 00:04:01.400 --> 00:04:04.479 that depend on your system architecture, and for decimals float 87 00:04:04.479 --> 00:04:07.479 thirty two and float sixty four. Usually float sixty four 88 00:04:07.520 --> 00:04:09.919 is the default choice unless you have specific needs. 89 00:04:10.159 --> 00:04:12.479 That's a lot of integer types. How do you choose? 90 00:04:12.680 --> 00:04:16.000 Often you can just start with int for whole numbers 91 00:04:16.160 --> 00:04:19.279 and float sixty four for decimals. The specific sizes like 92 00:04:19.319 --> 00:04:22.079 in eight become important when you're really optimizing for memory 93 00:04:22.240 --> 00:04:25.160 or you know, dealing with specific hardware interfaces. 94 00:04:25.319 --> 00:04:27.800 Okay, what about putting two big a number into a 95 00:04:27.839 --> 00:04:30.759 small type overflow right overflow? 96 00:04:31.000 --> 00:04:33.759 The compiler might catch it if you try to assign 97 00:04:33.800 --> 00:04:37.079 a value that's obviously too big, like varx once equals 98 00:04:37.079 --> 00:04:38.879 three hundred, that won't compile. 99 00:04:39.000 --> 00:04:40.519 But what about during calculations. 100 00:04:40.600 --> 00:04:43.240 Ah, that's different. If you add say one to a 101 00:04:43.279 --> 00:04:45.879 one eight that's already two fifty five, it doesn't crash. 102 00:04:45.959 --> 00:04:48.240 It wraps around, wraps around two zero yep. 103 00:04:48.040 --> 00:04:51.720 Wraps around to zero. Go doesn't automatically saturate or stop 104 00:04:51.759 --> 00:04:53.160 the calculation by default. 105 00:04:53.519 --> 00:04:56.600 Something to be aware of, good to know, subtle. Okay, 106 00:04:56.639 --> 00:04:58.519 what about text strings In GO? 107 00:04:59.000 --> 00:05:01.399 Strings are pretty straight forward. You've got your standard double 108 00:05:01.480 --> 00:05:04.879 quoted strings. They interpret escape sequences like in for new. 109 00:05:04.759 --> 00:05:07.040 Line t for tabs, standard stuff. 110 00:05:06.720 --> 00:05:09.879 And then you have raw string literals using backticks inside 111 00:05:09.879 --> 00:05:12.759 these backslashes or just backslashes, no special meaning. 112 00:05:13.120 --> 00:05:13.959 That sounds useful. 113 00:05:14.120 --> 00:05:17.480 It's great for multiline strings, like embedding JSON or writing 114 00:05:17.560 --> 00:05:21.839 regular expressions where you'd otherwise be escaping constantly. And GO 115 00:05:22.040 --> 00:05:25.040 handles UTF eight out of the box, so complex characters 116 00:05:25.079 --> 00:05:26.120 different languages. 117 00:05:25.839 --> 00:05:27.600 Usually just works and what's a roun? 118 00:05:28.120 --> 00:05:30.600 A roune is basically an alias for N thirty two. 119 00:05:30.879 --> 00:05:33.600 It represents a single Unicode code point, which might be 120 00:05:33.639 --> 00:05:35.079 one or more bites in UTF E. 121 00:05:35.240 --> 00:05:38.720 Okay, so strings cover text? Well? Yeah, what about simple 122 00:05:38.800 --> 00:05:39.560 true or false? 123 00:05:39.959 --> 00:05:43.360 That's the bool type values are just true or false 124 00:05:43.680 --> 00:05:45.720 essential for conditions obviously. 125 00:05:45.399 --> 00:05:48.480 Right, numbers, text booleans. Yeah, how do we actually hold 126 00:05:48.480 --> 00:05:49.600 onto these values? Variable? 127 00:05:49.720 --> 00:05:52.879 Yep, Variables You declare them with var than the name 128 00:05:52.959 --> 00:05:54.920 than the type like var count int. 129 00:05:54.800 --> 00:05:57.040 You assign with what If you declare but don't a sign, 130 00:05:57.120 --> 00:05:57.399 then it. 131 00:05:57.360 --> 00:05:59.879 Gets the zero value for its type zero for numbers, 132 00:06:00.000 --> 00:06:04.720 empty strength for strings, false for bulls, and nil for pointers, slices, maps, interfaces, 133 00:06:04.720 --> 00:06:05.160 et cetera. 134 00:06:05.439 --> 00:06:08.240 Mil Okay, is there a shorter way to declare? Yes? 135 00:06:08.639 --> 00:06:13.079 The short variable declaration name value. This declares and initializes 136 00:06:13.120 --> 00:06:15.800 in one go and go infers the type from the value. 137 00:06:16.040 --> 00:06:18.600 Very common, ah, the amperator got it? 138 00:06:18.839 --> 00:06:22.560 And naming rules start with a letter or underscore can 139 00:06:22.560 --> 00:06:27.360 contain letters, numbers, underscores, case sensitive, can't be a keyword 140 00:06:27.439 --> 00:06:30.800 like funk or if and go style prefers short names 141 00:06:31.240 --> 00:06:34.360 often yes, especially for variables with a very limited scope 142 00:06:34.399 --> 00:06:38.399 like loop counters Terseness is common, but clarity still matters, 143 00:06:38.439 --> 00:06:39.360 of course makes sense. 144 00:06:39.519 --> 00:06:41.000 And constants, how are they different? 145 00:06:41.120 --> 00:06:44.439 Declared with const The key thing is their value cannot 146 00:06:44.439 --> 00:06:47.920 be changed after declaration. They're fixed. They can be typed 147 00:06:48.040 --> 00:06:50.879 or untyped. Untyped constants are a bit more flexible. 148 00:06:50.959 --> 00:06:54.480 Okay, var for changeable const for fixed. Now, how do 149 00:06:54.519 --> 00:06:57.040 we display these values? Formatting? 150 00:06:57.120 --> 00:06:59.680 That's where the FMT package comes in. It's your standard 151 00:06:59.759 --> 00:07:00.959 in output. 152 00:07:00.600 --> 00:07:03.920 Toolkit FMT dot pron FMT dot print of those ones. 153 00:07:03.759 --> 00:07:06.920 Exactly, printlin prints things with spaces in between, and adds 154 00:07:06.920 --> 00:07:09.680 a newline. Print for formatted output using. 155 00:07:09.519 --> 00:07:12.120 Verbs verbs like percent or percent right. 156 00:07:12.000 --> 00:07:14.560 Percent is the default value. Format prients two shows the 157 00:07:14.560 --> 00:07:18.120 type percent for decimal integers, percents for strings, percent reported strings, 158 00:07:18.120 --> 00:07:21.480 percent for floats, lots of options sprintoff works like print, 159 00:07:21.519 --> 00:07:23.839 but returns the formatted string instead of printing. 160 00:07:23.639 --> 00:07:26.399 It useful and you can control padding and stuff. 161 00:07:26.240 --> 00:07:31.120 Yep padding integers, printing signs showing base prefixes for binary pers, 162 00:07:31.240 --> 00:07:35.240 octal perso x, percentx escape sequences like N and T 163 00:07:35.560 --> 00:07:39.680 work in strings too. FMT is pretty powerful for basic formatting. 164 00:07:40.079 --> 00:07:43.199 Cool. Okay, basic types and printing cover. Let's move on 165 00:07:43.199 --> 00:07:45.519 to collections, arrays, and slices. 166 00:07:45.680 --> 00:07:48.560 Right, So, rais and GO have a fixed size. You 167 00:07:48.560 --> 00:07:51.360 declare an array, say varnums five int, and it always 168 00:07:51.360 --> 00:07:53.720 has five integers. Can't change that size later. 169 00:07:54.040 --> 00:07:55.959 And all elements must be the same time correct. 170 00:07:55.959 --> 00:07:58.839 If you don't initialize it, elements get the zero value. 171 00:07:59.000 --> 00:08:01.720 The compiler also helps prevent you from accessing an index 172 00:08:01.720 --> 00:08:06.120 that's out of bounds. Importantly, arrays are value types value. 173 00:08:05.759 --> 00:08:07.839 Types, meaning if you assign one array to another, it 174 00:08:07.879 --> 00:08:09.160 copies everything exactly. 175 00:08:09.160 --> 00:08:10.639 You get a full independent copy. 176 00:08:10.759 --> 00:08:14.240 Okay, so fixed size value types. That sounds limiting sometimes, 177 00:08:14.240 --> 00:08:15.079 what about slices. 178 00:08:15.160 --> 00:08:18.319 That's where slices come in. They are dynamically sized flexible 179 00:08:18.399 --> 00:08:21.399 views into an underlying array, much more common in GO 180 00:08:21.560 --> 00:08:24.759 code than raw arrays. The view into an array, yeah, 181 00:08:25.199 --> 00:08:28.319 a slice has a pointer to the underlying array, a 182 00:08:28.439 --> 00:08:32.000 length how many elements it currently holds, and a capacity 183 00:08:32.440 --> 00:08:35.559 how large the underlying array segment is. You can create 184 00:08:35.600 --> 00:08:38.440 them with it literal like in one, two, three, or 185 00:08:38.559 --> 00:08:42.480 using the make function. Make yent five creates a slice 186 00:08:42.480 --> 00:08:47.120 of five integers initialized to zero. Make zero ten creates 187 00:08:47.159 --> 00:08:49.960 an empty slice, but with an underlying array capacity of 188 00:08:50.000 --> 00:08:50.960 ten ready to. 189 00:08:50.919 --> 00:08:54.279 Grow, and slices are reference types unlike arrays. 190 00:08:54.320 --> 00:08:58.519 Correct assigning a slice just copies the slice header pointer, length, capacity, 191 00:08:58.879 --> 00:09:01.159 not the underlying beta. Both slices will point to the 192 00:09:01.200 --> 00:09:01.720 same data. 193 00:09:01.759 --> 00:09:04.759 Ah, so changes through one slice are visible through the other. 194 00:09:04.639 --> 00:09:06.320 If they point to the same underlying elements. 195 00:09:06.399 --> 00:09:08.519 Yes, how do you add elements to a slice? It's 196 00:09:08.519 --> 00:09:09.279 it's their dynamic. 197 00:09:09.399 --> 00:09:11.919 You use the built in a pen function. My slice, 198 00:09:11.919 --> 00:09:14.679 a pend, my slice new value. If there's enough capacity 199 00:09:14.679 --> 00:09:16.799 in the underlying array, it just adds the element and 200 00:09:16.799 --> 00:09:17.639 increases the length. 201 00:09:17.679 --> 00:09:19.679 And if there isn't enough capacity. 202 00:09:19.440 --> 00:09:23.320 Then a pen allocates a new, larger underlying array, copies 203 00:09:23.360 --> 00:09:26.480 the old data over adds the new element, and returns 204 00:09:26.480 --> 00:09:28.879 a slice pointing to this new array. That's why you 205 00:09:28.879 --> 00:09:30.720 always assign the result of a pend back to your 206 00:09:30.759 --> 00:09:31.440 slice variable. 207 00:09:31.480 --> 00:09:33.840 Got it? You can depend a whole other slice too, right, yep? 208 00:09:33.960 --> 00:09:37.120 Using the operator a pend slice one, slice two. And 209 00:09:37.159 --> 00:09:40.759 there's a copy function to explicitly copy elements between slices. 210 00:09:40.799 --> 00:09:44.120 Okay, fixed arrays flexible slices, how do we loop through them? 211 00:09:44.159 --> 00:09:46.840 The four loop is goes only looping construct you can 212 00:09:46.919 --> 00:09:50.039 use the classic C style for with an index for 213 00:09:50.159 --> 00:09:53.399 i or o omeaning my slice i plus plus slice 214 00:09:53.559 --> 00:09:57.279 familiar but more idiomatic, and go is using with a 215 00:09:57.399 --> 00:10:01.000 range keyword for index value range my flesh. It iterates 216 00:10:01.039 --> 00:10:03.440 over the collection, giving you the index and the value 217 00:10:03.440 --> 00:10:04.080 at each step. 218 00:10:04.279 --> 00:10:06.639 Range works on a rais and slices what else. 219 00:10:06.480 --> 00:10:10.200 Maps strings gives indexed and run and channels only built 220 00:10:10.240 --> 00:10:14.159 in collection types. Mostly inside loops, you can use continue 221 00:10:14.200 --> 00:10:16.759 to skip to the next iteration or break to exit 222 00:10:16.799 --> 00:10:17.919 the loop entirely. 223 00:10:17.759 --> 00:10:21.480 Standard loop control. Okay, foreign range. Let's talk about maps 224 00:10:21.559 --> 00:10:22.759 key value pairs. 225 00:10:22.720 --> 00:10:26.080 Exactly like dictionaries or hash maps and other languages rate 226 00:10:26.120 --> 00:10:29.159 for lookups, you declare them using make map key type, 227 00:10:29.240 --> 00:10:32.399 value type, or a map literal like map string at one, one, 228 00:10:32.440 --> 00:10:32.840 two to two. 229 00:10:33.159 --> 00:10:34.919 How do you add or get values. 230 00:10:34.960 --> 00:10:38.159 Using square brackets with the key my map key value 231 00:10:38.200 --> 00:10:40.240 to set and vowel my map key to. 232 00:10:40.200 --> 00:10:41.799 Get What if the key isn't there when you try 233 00:10:41.840 --> 00:10:42.240 to get it. 234 00:10:42.200 --> 00:10:44.440 You get the zero value for the value type e g. 235 00:10:44.679 --> 00:10:47.600 Zero for end for string. But there's a better way 236 00:10:47.600 --> 00:10:52.240 to check if it exists. The calm op idiom value okay, 237 00:10:52.279 --> 00:10:55.840 my map key here okay will be boolean true if 238 00:10:55.840 --> 00:10:59.279 the key existed false. Otherwise value holds the actual value 239 00:10:59.320 --> 00:11:02.000 if okay is true, or the zero value if false. 240 00:11:02.360 --> 00:11:05.399 Prevents confusion between a stored zero value and a missing key. 241 00:11:05.559 --> 00:11:07.840 Ah, that's neat. Do maps have a fixed size? 242 00:11:08.080 --> 00:11:10.919 No, they grow dynamically as you add more entries. Practically 243 00:11:11.039 --> 00:11:13.519 unlimited really just limited by memory. Like slices. 244 00:11:13.559 --> 00:11:15.600 There are reference types, and the order you get things 245 00:11:15.600 --> 00:11:17.639 back when iterating isn't guaranteed correct. 246 00:11:17.720 --> 00:11:20.799 Iteration order over a map is intentionally randomized and go. 247 00:11:21.080 --> 00:11:22.639 Don't rely on it got. 248 00:11:22.399 --> 00:11:26.200 It maps for lookups, no guaranteed order. How about making 249 00:11:26.240 --> 00:11:27.840 decisions if statements. 250 00:11:27.799 --> 00:11:31.320 Yip standard to if lcfls. One neat GO feature is 251 00:11:31.320 --> 00:11:33.759 that you can declare a variable scope just to the 252 00:11:33.840 --> 00:11:38.240 if statement itself. If value okay, my map key okay, 253 00:11:38.519 --> 00:11:41.039 value and okay only exist inside the if in any 254 00:11:41.039 --> 00:11:41.639 else blocks. 255 00:11:41.720 --> 00:11:44.519 Oh that's tidy, keeps the scope tight. Yeah. What about switch? 256 00:11:44.799 --> 00:11:46.879 Switch is powerful and go. You can switch on a 257 00:11:46.960 --> 00:11:49.799 value and then have different case blocks. Unlike see your Java, 258 00:11:49.840 --> 00:11:52.799 there's no automatic fall through. A matched case executes and 259 00:11:52.840 --> 00:11:53.720 then the switch is done. 260 00:11:53.759 --> 00:11:55.639 No need for break everywhere exactly. 261 00:11:56.039 --> 00:11:57.840 If you want fall through, you have to use the 262 00:11:57.840 --> 00:12:01.159 fall through keyword explicitly. You can lists multiple values in 263 00:12:01.159 --> 00:12:03.600 a single case, and there's a default case. You can 264 00:12:03.600 --> 00:12:06.159 even use switch without an expression, making each case just 265 00:12:06.240 --> 00:12:09.279 a boolean condition switch case by zero, case by. 266 00:12:09.279 --> 00:12:13.120 Zero like a cleaner if lsif chain nice. Let's package 267 00:12:13.159 --> 00:12:15.440 up reusable code functions. 268 00:12:15.120 --> 00:12:18.679 Right define with the funk keyword. Function function name r 269 00:12:18.840 --> 00:12:21.799 one type one rchqwo type two return type. The main 270 00:12:21.799 --> 00:12:23.960 function in the main package is the entry point for 271 00:12:24.000 --> 00:12:25.120 executable programs. 272 00:12:25.320 --> 00:12:27.440 You have to declare the type for every argument. 273 00:12:27.600 --> 00:12:32.720 Yes always funk ad a in b nt in return 274 00:12:32.799 --> 00:12:36.559 a plus b. You can group types if consecutive ARBs 275 00:12:36.559 --> 00:12:39.960 have the same type funk ad a b n t in, 276 00:12:40.000 --> 00:12:43.440 and return values can return zero or more values. Just 277 00:12:43.480 --> 00:12:46.679 list the return types after the arguments. Funk divide ab 278 00:12:46.879 --> 00:12:50.080 float sixty four, float sixty four error. Returning an error 279 00:12:50.120 --> 00:12:52.720 as the last value is the standard go away to 280 00:12:52.840 --> 00:12:53.679 signal failure. 281 00:12:53.840 --> 00:12:55.559 Multiple return values are common, then. 282 00:12:55.639 --> 00:12:58.480 Very common, especially for the value and error pattern. You 283 00:12:58.480 --> 00:13:01.679 can also name the return values funk split some int 284 00:13:02.039 --> 00:13:04.720 x ynt. They act like variables declared at the start 285 00:13:04.759 --> 00:13:07.840 of the function. If a function returns values, the caller 286 00:13:07.879 --> 00:13:10.679 has to handle or explicitly ignore them using funk. 287 00:13:10.840 --> 00:13:14.200 Okay, what if a function needs to accept, say any 288 00:13:14.279 --> 00:13:15.159 number of arguments. 289 00:13:15.200 --> 00:13:18.039 That's very atic. Arguments use before the type of the 290 00:13:18.120 --> 00:13:22.120 last parameter funks, numbs, dot nt intinct. Inside the function, 291 00:13:22.279 --> 00:13:24.559 numbs is treated as a slice event, so you could. 292 00:13:24.360 --> 00:13:26.919 Call some one to two or some one two. 293 00:13:26.799 --> 00:13:30.320 Three four exactly. Very flexible for things like logging functions 294 00:13:30.440 --> 00:13:31.879 or database query builders. 295 00:13:32.000 --> 00:13:34.320 Cool. Now, what about defer That seems unique to. 296 00:13:34.279 --> 00:13:39.720 Go It is pretty distinctive. Differ schedules a function call 297 00:13:39.759 --> 00:13:43.399 to be executed just before the surrounding function. 298 00:13:43.200 --> 00:13:44.679 Returns, before it returns like at. 299 00:13:44.559 --> 00:13:48.240 The very end yep whether the function returns normally or panics. 300 00:13:48.480 --> 00:13:52.399 The deferred calls run. If you have multiple defers, they 301 00:13:52.440 --> 00:13:56.480 execute in last in first out laf order. 302 00:13:56.639 --> 00:13:59.279 I have a FILT, so the last one deferred runs first. 303 00:13:59.440 --> 00:14:02.559 Correct. The most common use is resource cleanup, like open 304 00:14:02.600 --> 00:14:06.840 a file, then immediately defer file close. Guarantees it gets closed. 305 00:14:06.559 --> 00:14:08.039 Even if there's an error later in the function. 306 00:14:08.279 --> 00:14:13.000 Exactly. It simplifies cleanup logic immensely. One key point the 307 00:14:13.200 --> 00:14:16.080 arguments to the deferred function are evaluated when the defer 308 00:14:16.200 --> 00:14:19.399 statement is executed, not when the call actually happens. 309 00:14:19.480 --> 00:14:22.279 Ah. Okay, So if you defer function using a variable, 310 00:14:22.399 --> 00:14:24.799 it uses the variable's value at that moment. 311 00:14:24.679 --> 00:14:26.840 Right, Something to keep in mind, especially with loops and 312 00:14:26.919 --> 00:14:27.960 anonymous functions. 313 00:14:28.000 --> 00:14:30.840 Got it defer for guaranteed cleanup? What about the innit function? 314 00:14:31.120 --> 00:14:34.360 A knit is special. It runs automatically when its package 315 00:14:34.399 --> 00:14:37.080 is initialized before main runs. You don't call it yourself? 316 00:14:37.120 --> 00:14:37.960 When would you use it? 317 00:14:38.159 --> 00:14:41.080 Usually for package levels setup you can have multiple init 318 00:14:41.120 --> 00:14:44.120 functions in a file or package. Within a file, they 319 00:14:44.200 --> 00:14:47.240 run in order of appearance across files in a package. 320 00:14:47.279 --> 00:14:50.480 The order isn't guaranteed, so maybe setting up database connections 321 00:14:50.559 --> 00:14:51.799 or registering. 322 00:14:51.320 --> 00:14:54.879 Things sometimes use for that. Yeah, like registering image formats 323 00:14:54.879 --> 00:14:57.600 by importing the image package for its in it side effect. 324 00:14:57.840 --> 00:15:00.200 But relying on import side effects is often seen as 325 00:15:00.240 --> 00:15:02.879 an anti pattern. Now, better to be explicit. 326 00:15:03.000 --> 00:15:06.320 Okay, in it for setup, but use with caution. Let's 327 00:15:06.320 --> 00:15:09.639 move to structuring more complex data structs and methods. 328 00:15:09.720 --> 00:15:12.360 Structs let you group different pieces of data together into 329 00:15:12.399 --> 00:15:17.720 a single custom type type, person, struct, name, string, age. 330 00:15:17.440 --> 00:15:20.120 And p. Simple enough, how do you access the fields? 331 00:15:20.279 --> 00:15:24.480 Dot notation dot p person name, Alice age thirty f 332 00:15:24.559 --> 00:15:25.679 mt printline P name. 333 00:15:25.759 --> 00:15:27.200 What about embedding. 334 00:15:27.080 --> 00:15:31.519 AH, Embedding is like anonymous fields type employee struct salary 335 00:15:31.519 --> 00:15:35.039 float sixty four. Now an employee value E has field 336 00:15:35.159 --> 00:15:38.639 Z salary, but also E name and ehe promoted from 337 00:15:38.679 --> 00:15:39.720 the embedded person struct. 338 00:15:39.720 --> 00:15:43.200 Do you access the embedded fields directly? Cool and methods 339 00:15:43.440 --> 00:15:44.960 functions attached to types. 340 00:15:44.919 --> 00:15:48.799 Exactly, You define a method with a receiver funker pee 341 00:15:48.840 --> 00:15:52.080 person Hell, my name is peak person p person grant 342 00:15:52.200 --> 00:15:53.639 here pee person is the receiver. 343 00:15:53.840 --> 00:15:56.240 You can have pointer receivers too, right, yeah, funk person 344 00:15:56.360 --> 00:15:57.600 setage new agent. Right. 345 00:15:57.679 --> 00:16:02.200 The big difference pointer receivers person can modify the original struct. 346 00:16:02.279 --> 00:16:07.039 Value value receivers person operate on a copy of the struct, 347 00:16:07.120 --> 00:16:10.600 so modifications inside the method don't affect the original. 348 00:16:11.360 --> 00:16:14.000 So use pointers if you need to change the struct. 349 00:16:13.840 --> 00:16:16.679 Generally yes, or if the struct is very large and 350 00:16:16.679 --> 00:16:19.720 you want to avoid copying it for performance reasons. Value 351 00:16:19.720 --> 00:16:21.759 receivers are simpler if you don't need mutation. 352 00:16:22.159 --> 00:16:25.039 Can you add methods to any type like built. 353 00:16:24.799 --> 00:16:27.679 In types, not directly to built ins like INNT, but 354 00:16:27.799 --> 00:16:30.399 you can define a new type based on it. Type 355 00:16:30.440 --> 00:16:33.120 my int int and add methods to my ind However, 356 00:16:33.159 --> 00:16:36.080 the new type doesn't inherit methods from the underlying type. 357 00:16:36.320 --> 00:16:38.840 You can also define methods for types from other packages, 358 00:16:38.879 --> 00:16:41.360 but only within the package where you define the method. 359 00:16:41.519 --> 00:16:43.559 What about calling methods on nil pointers? 360 00:16:43.960 --> 00:16:47.039 That can cause a panic if you're not careful. Methods 361 00:16:47.080 --> 00:16:50.480 with pointer receivers should ideally check if the receiver is nil. 362 00:16:51.080 --> 00:16:52.879 If p equals nil. 363 00:16:53.519 --> 00:16:57.879 Good practice, Okay, structs and methods. What about pointers themselves? 364 00:16:58.279 --> 00:17:01.440 Pointers hold the memory address of a value. GO is 365 00:17:01.559 --> 00:17:05.799 pass by value, meaning function arguments are copies. Pointers let 366 00:17:05.880 --> 00:17:09.160 you effectively pass by a reference, allowing functions to modify 367 00:17:09.200 --> 00:17:10.160 the original value. 368 00:17:10.359 --> 00:17:11.160 How do you work with them? 369 00:17:11.839 --> 00:17:15.119 Type declares a pointer type for example int, and the 370 00:17:15.200 --> 00:17:18.759 variable gets the memory address. Creates a pointer pointer variable 371 00:17:18.799 --> 00:17:21.079 to references the pointer to get the value it points to. 372 00:17:21.359 --> 00:17:23.839 So she takes the address follows the address pretty much. 373 00:17:24.000 --> 00:17:26.960 Using pointers avoids copying large data structures, which can be 374 00:17:26.960 --> 00:17:28.839 good for performance, but it also means you need to 375 00:17:28.839 --> 00:17:31.480 think about shared access and potential garbage collector impact. 376 00:17:31.640 --> 00:17:35.000 Got it pointers for indirect access and modification? Now testing 377 00:17:35.319 --> 00:17:37.559 crucial part of development. How does go do it? 378 00:17:37.640 --> 00:17:40.319 Go has great built in testing test files, end and 379 00:17:40.440 --> 00:17:43.279 test dot go test functions start with test and take 380 00:17:43.319 --> 00:17:46.799 a testing dot T argument test my function testing dot T. 381 00:17:46.960 --> 00:17:48.880 And it is used for reporting. 382 00:17:48.480 --> 00:17:53.039 Failures right TFA TALF expected percingop percy and expected actual 383 00:17:53.079 --> 00:17:56.079 logs and error, but continues t fetalf logs and stops 384 00:17:56.119 --> 00:17:58.839 the current test immediately. Good error messages are key. 385 00:17:58.960 --> 00:18:00.599 How do you run test Go tests in. 386 00:18:00.599 --> 00:18:04.680 The directory go test dash v gives verbose output showing 387 00:18:04.720 --> 00:18:05.519 each test run. 388 00:18:05.559 --> 00:18:08.119 What about code coverage? Seeing what percentage of your code 389 00:18:08.160 --> 00:18:09.039 the tests hit. 390 00:18:09.039 --> 00:18:13.000 Easy, Go test dash Tierra profile coverage dot out generates 391 00:18:13.000 --> 00:18:17.079 a profile. Then Go tool cover dash HTML coverage dot 392 00:18:17.119 --> 00:18:20.920 out opens a nice HTML report showing covered and uncovered lines. 393 00:18:21.119 --> 00:18:21.680 Very useful. 394 00:18:21.759 --> 00:18:25.920 That sounds great for finding gaps. Any techniques for organizing tests, Table. 395 00:18:25.759 --> 00:18:28.480 Driven tests are very popular and effective. You define a 396 00:18:28.519 --> 00:18:31.599 slice of test cases often strucks, each containing inputs and 397 00:18:31.599 --> 00:18:34.920 expected outputs. Then one loop runs all the cases. 398 00:18:34.680 --> 00:18:37.720 Keeps things dry, don't repeat yourself exactly and clear. 399 00:18:38.119 --> 00:18:41.279 Go also supports subtests using t run subtest name funct 400 00:18:41.279 --> 00:18:44.319 testing dot T you. This gives better output organization and 401 00:18:44.400 --> 00:18:47.000