These kinds of talks where the presenter is a true expert in his field.

I'm on a Go youtube lectures spree and every time a finish one of them, I wanna refactor all the code I've done so far :)

Still easily one of the best Go "best practices" video on youtube

Pointer vs. Value discussion: Based on the Method vs. Function discussion, ADT should be strictly adhered to. Operations that modify the ADT are modeled as functions that take the old state as an argument and return the new state as part of the result. In other words, a function should enforce immutability. The ADT approach helps with concurrency, making the code cleaner and easier to read. As an API user, I shouldn't worry about the state changing when I pass a structure. Of course, the pure ADT model's problem is memory consumption. That's why ADT models are generally implemented in VMs that can routinely find old structures without references and remove them from memory.

Good talk. Hugo powers my blog, and I love it!

Fantastic talk! I am new to go and had no idea on the proper way to handle errors. I am off to fix my code :D

Good talk. It's cool to watch this in 2022, as it can be considered ancient relative to Go's lifetime

Great stuff, thanks for the lecture!

There needs to be a book on these. He's racing through concepts that could use a lot more detail.

Really great talk. Thanks for this

Methods not necessary imply mutation, therefore generating shortcodes (13:00) can be a method as well, maybe even a lazy var which is instantiated only once. Languages like C++/Swift have const/mutating keywords for indicating a method mutating or not mutating its fields

Thank you very much! Great presentation to us!

Very helpful, Steve!

You are a rock star!!!

Excellent talk I really appreciated the code examples :) Nicely done sir.

Awesome talk. Good sound too.

I sincerely believe that io.Reader and io.Writer are the two most powerful interfaces in the language. They're so underrated that it kind of makes me sad.

Pointers vs values - it's not just about usage. "If you want to share it, use a pointer" is a pretty contextless way to describe an issue that can easily become sensitive. Don't share unless you absolutely need to is a better way because otherwise a good starter is: I'll share because it's more flexible and I'll see about it later. But memory allocation is an important point as overusing pointers is a sure way to shoot yourself in the foot sooner rather than later.

My video tags and descriptions: 1) Don't user interfaces 3:19 2) Don't use io.Reader & io.Writer 6:24 3) Requiring brod interface 8:44 4) Method vs function 10:41 5) Pointer Vs Value 14:58 6) Error is does not a string 16:56 7) To be safe or not to be 22:14 P.S. Top secret skill: 24:56

great talk;

great sensei .... got me up to speed on docker.

Really good stuff!

Thaaaaank you, some one should collect all these pull request reviews and upload it in one website with git diff + comments :D

Great!

Sirrrr, it is great 👍

Thanks

great talk

In the example for using functions over methods when no side effects are intended I'd argue that *Page should be Page instead - its a clearer argument for expressing no side-effects when you have a value receiver where side effects are not possible.

COOL. GOT IT!!! 😆

i am from china. and learn a lot from this video. tkx

受益匪浅。

Really good talk! I learnt a lot. Am coming from Python!

9:49: I would argue that this design principle applies to OO interfaces just as well.

Also, internally.. Channels use mutexes anyway, so its not necessarily a bad thing to use..

nice!

Almost all of them are not actually Go-specific mistakes. In particular those are the same for most JVM languages.

Just to be clear, maps are the only issue with concurrent access. A quick fix is to use sync.Map, but in a lot of cases using a drop-in replacement using a slice of struct{k,v string m Mutex} is slightly faster as you only need to lock on write with a high load of concurrent access.

If a method is supposed to modify the state (vs functions), how come you wouldn't use a pointer in a receiver...?

the real problem with not using a reader is that the buffers might be really large.

*gling* *gling* *gling* :}

The 8:30 slides shows that the code is not correct. Marshalling in a computer science is the process of transforming the memory representation of an object into a data format suitable for storage or transmission. In above slide the logic is actually doing the opposite. It transforms data coming from storage or transmission (in Reader) into memory representation v.config (out). The function in Viper should be called unmarshalConfig.

I don’t know if I’d say go is a new language anymore

why are p.BaseFileName() and p.lineNumRawContentStart() not functions but methods? (at 13:04)

Am I a complete noob or did you forgot to explain why those patterns are mistakes?

In Java, almost everything is a pointer.. things are passed by reference by default with the exception of primitive unboxed numerics

how should i understand "time is ticking"?

Alright, you convinced me. I'm going to stop watching videos and go fail now!

After reading some pieces of Go code of Ethereum I finally land here.

12:53 NO

Except the fastest static site generator is not "Hugo" anymore but "Zola" (written in Rust). Good talk btw

wild Francesc appears at the end

Biggest Mistake; Not Makimg Mistakes

The method vs. function debate is absurd. The presenter needs to learn or spend time with OO programming. Class methods don't have to be logically connected to states. I developed in C during the 80s. The problem with structs is that the data is the point of coupling. The class hides data. In OO, the focus is on behavior and not the state. The OO state can be anywhere and can change. The strategy allows the implementation of the module to be changed without disturbing the client programs.

too slow and fluffy to be useful