Wrapping Up

[00:00:00]
>> Every introduction to programming language should start from the source of truth, kind of from the horse's mouth. And that's from go.dev. That's the official website for Go development. They have this tour of Go that you can use. I think it's like a 14 module experience. It goes around in the hello world to drive into concept like strux, interfaces, concurrency, looping, deferring, maps, pointers, all that.

[00:00:29]
I think it's a really good source. And it comes from the developers. Arguably, it really can't get that much better in terms of like the raw knowledge and how was intended to be used. And then, if you've done that, there's another good resource called gobyexample. And I really like gobyexample, because if you pull it up, if you guys can pull it up in your website, it literally is like a flat HTML file.

[00:00:53]
There's like no CSS, it just renders an ordered list of these modules. And if you click them, it's just another HTML Script, two columns. One is just text and the other one is like a static image of code. And, that's all you really need. I don't want fancy animations.

[00:01:11]
I don't want like sparkles, if I just wanna learn something, let's just give me the dirty, just go into write html. Let me read it. And it breaks it down into a very digestible way. The snippet of text isn't too long. You're not gonna spend an hour reading it.

[00:01:27]
It kind of breaks down exactly the component that it maps to in the image of code. And the reason why it's a little different than Tour of Go, it's because there's a lot more modules. It goes into a bit more granularity into very specific concepts. So I definitely think these two are a great way to truly start understanding Go if you're a complete beginner.

[00:01:51]
And then there's that last resource. And to me, this is arguably the best resource when it comes to Go. I don't be careful how I say that, but I think I want to put my name in the line for that. It's called Effective Go. It was developed by the official Go team.

[00:02:08]
What is it? It's a blog post in 2009, that's all this. And they haven't updated it since. It's long. It's greasy, again, no CSS. But, what this blog post describes is very different than the previous two examples. The previous two examples, it's syntax, it's code examples, some explanation, effective Go doesn't introduce any kind of hidden secrets.

[00:02:39]
Okay, you did this, this is the hidden secret of how you write good code. Effective Go describes how to think like a Go developer. I wanna kind of let that waft in the air a little bit, because thinking like a Go developer, you will probably be able to use the tools that they intended, more like a Go developer.

[00:03:03]
Because like some of us, Go wasn't my first programming language. I came from Python. And then I started writing Go code like a Python developer. And it worked. It was fine. There was really no big problem with that. But if Effective Go is able to really shift your focus and think more how the core engineering team wanted you to think like a Go developer.

[00:03:28]
So it's a really good resource. I always say if you're done the tours of Go, the Hello World to Go, whatever, read this Effective of Go. It's a must to be honest for any Go engineer. If you're a fan of textbooks, I got some textbooks recommendation. There's a really good book called the Go Programming Language by Jonathan Cohen again, it's a really nice book.

[00:03:46]
I think, if you see that the cover you will recognize it's just white and blue. It's a really good book. Again, I really like easily things are easily consumable, easily digestible. I think this Go book does a really good job of it. And then there's two textbooks by Alex Edwards, who deserves an incredible shot of her work.

[00:04:08]
The two books are called Let's Go and Let's Go Further. Has anyone heard of those textbooks here? Nice, okay. For those of you that didn't, who haven't, that's a treat. These two textbooks have shaped a lot of how Go is written from like an HTTP server perspective. So Let's Go is this first intro to Go, you build an application, it's really nice.

[00:04:34]
I wouldn't say it's dense, but it's just long. I think it's like five 500 plus pages, but it really goes through the entire suite of how to build an application. I think you build a code bin or something I may forgot in the first book. But I really, really like Let's Go Further.

[00:04:50]
And I've read Let's Go Further three times, because it really taught me how to write servers in Go. How to process handlers. How to decouple my functions. How to use these native data structures go offers to write my application code. And again, it's like 500 pages, but it does not feel like you're in 500 pages.

[00:05:12]
You literally just go, go, go, go, emphasis on all of those intended, all right? That's a really good book. I think it's only available on PDF, so there's no actual physical textbook. Hopefully, that's not too much of a turnoff. It's worth it, trust me. And in the last resource that I don't really see too many individuals talk about, it's a conference talks, Go conference talks, specifically ones made and hosted by Rob Pike.

[00:05:41]
Again, Rob Pike was one of the core engineers. He was actually the tech lead, if memory system correctly of Goaling back in 06, 07, 08, and when they released in 09. And his conference talks are like bar non some of the best resources. Even the ones from 2009 and earlier, and you may be thinking like, what?

[00:06:00]
It's almost been like 20 years, 15 years since those. How is it possible that those are still valid? And it emphasized the point earlier. Go is boring, go move slow. The code that Rob and his team wrote back then in those conference talks in 2008 and in 2009 will look very, very similar to the code you will write today in this day and age, okay?

[00:06:26]
And that's by design. That's because of the simplicity that Go was baked in with. So I definitely recommend looking at these Rob Pike conference talks, he talks, some of them concurrency patterns, advanced concurrency patterns. Concurrency is not parallelism. He always goes to gopher con, I think once or twice here different areas in the world.

[00:06:45]
There's a gopher con Australia, Amsterdam, there's one state, so he's everywhere. So check them out there on YouTube. I highly recommend these resource, just play it observe, take it in And then. Yeah, but the most important thing is, build stuff. Bar none, bar absolute none. You got to build stuff, all right?

[00:07:07]
If you're just consuming content, reading. The best analogy is like a swimmer who never swam. You're watching videos on swimming, you're reading how to do the Breaststroke, whatever, but you've never gone to the pool, you can't really say you're a good swimmer until you do that. So always just build stuff.

[00:07:27]
A common thing I always get asked is how do I know what to build? What if I don't have a project idea, what do i do? Just build simple HTTP. So just build randomness, nothingness, literally. Pull up an IDE, make your main.go, slap some basic routes using a standard library.

[00:07:45]
And if you have to do that two days in a row, so be it. But just get that memory habit of just writing code on your keyboard, writing Go, and I think it goes a very long way.
>> Is there an easy way to tear down all of the infrastructure with the CDK?

[00:07:59]
>> Yeah, you can do it through the command line. There's a command, I think it's called CDK Destroy, quite literally. I'll destroy all the infrastructure you deployed. But all this will not actually continue to run the bill. Lambda invocation won't be, if you're not invoking, it's not gonna run up the bill.

[00:08:15]
That would be populated, so yeah. Yeah, roasted turkey destroyed to run the CDK that we read. Thank you for that, great great point. I mean with all that being said, that's that's the end. That's it, thank you guys for watching.
>> [APPLAUSE]