วีดีโอ

Davis Maria Hernandez Helen Martinez Patricia

If you don’t use go you a ho lang

10:54 - Tip #4 Write exhaustive tests

15:26 Here is critical bug in this code, related with misunderstanding how defer works: The code within defer closures runs *after* the return statement. So it gonna be called in both scenario: success and fail. So, in general code must be written like: // Get a Tx for making transaction requests. tx, err := db.BeginTx(ctx, nil) if err != nil { // handle err } // Defer a rollback in case anything fails. defer tx.Rollback() // Insert article query. _, err = tx.ExecContext(ctx, "...") if err != nil { // handle err } // Insert Event logic. // Commit the transaction. if err = tx.Commit(); err != nil { // handle err } return nil

I wish there was another (functional) language using go runtime.

Baking telemetry into a programming language is a TOTAL NO GO. I would ditch the entire ecosystem and fallback onto ASM if all languages did that. Even those who assert that it is an opt-in should be scrutinized. Apparently they got paid by Ggl and speak on behalf of Ggl's interests. STOP SPYING STOP GLORYING BACKDOORS.

Great talk, great presenter.

after the citation of ousterhout I wen to look at the threads paper, and to me it seems ousterhout is still right, and pike got ousterhout's message wrong (just look at the conclusion slide), pike's own admission of "doing concurrency like things sometimes without even realizing it" is a problem and in agreement with ousterhout (but then, of course, he later goes on to talk exactly about the problems ousterhout stated ...)

Love listening to Rob.

this is very well explained.

the overly strong dependence on git has been the bane of my existence

Awesome talk!

i can answer that title question.. NOT MUCH, ALMOST EVERYTHING.. go really is the dumbest language ever invented and most people are dumb.. so.. success i guess..

Great Talk

So I went on Wikipedia to refresh my knowledge of all the amazing things this man did for the software industry, and I realized he looks two decades younger than he actually is. Way to efffin go, Rob!

00:39 🎉 Rob Pike reflects on the 14th anniversary of Go's launch, highlighting the journey and lessons learned since then. 01:48 🧠 Go's original goal wasn't just about creating a new programming language but providing a better way to write software, addressing issues beyond language features. 03:37 🐿 The Go Gopher played a significant role in Go's success, serving as a symbol of community engagement and technical excellence, but challenges arose with its Creative Commons licensing. 07:20 📜 Go's adherence to a formal specification, support for multiple implementations, and emphasis on compatibility were crucial factors in its success. 10:30 🛠 Go's tooling, including the Go command and Gofmt, significantly enhanced developer productivity and fostered a robust ecosystem. 13:21 💡 Go's novel approach to concurrency popularized the concept as a powerful tool for structuring server software, although clarification was needed on the differences between concurrency and parallelism. 16:49 🔄 Interfaces emerged as a fundamental concept in Go, facilitating a behavior-focused style of programming and encouraging library development and composability. 19:10 🤔 Go's journey with generics illustrates the complexities of language design, influenced by prior decisions such as the foundational role of interfaces, leading to a subtle yet profound evolution in the language's design. 20:59 💬 "Generics" in Go originated from a term for a different style of polymorphism, but it's an accurate but awkward term for parametric polymorphism. 21:26 🛠 Bootstrapping Go's compiler was done in C due to familiarity and efficiency, despite community preference for LLVM or self-hosting. 22:48 🔀 Go's unorthodox approach to cross-compilation facilitated rapid progress, despite some community skepticism. 23:15 💻 Translating Go's compiler from C to Go allowed for leveraging Go's advantages like testing and tooling, leading to a cleaner compiler. 24:13 🌐 Transitioning Go to an open-source project took time, with a learning curve on community engagement and management. 25:23 🚀 Go's insistence on code quality through mandatory reviews was unconventional but proved valuable for community contributions. 27:01 📦 Go's package management design consumed significant discussion initially, leading to a bumpy transition to importing external code. 28:39 📃 Initial documentation efforts in Go lacked practical examples, highlighting the community's preference for hands-on guidance. 29:50 🎮 Deploying executable code snippets online and in the Go Playground facilitated learning and experimentation, enhancing documentation effectiveness. 30:33 📈 Go's success stems from its design philosophy emphasizing simplicity, readability, and community support, leading to widespread adoption and uniformity in code style. 41:38 🔄 More can be done at compile time for concurrency models and deadlock detection in Go. 42:24 📦 Despite Go's successful standard library, there are regrets about early decisions, such as issues with the log and os packages, but efforts are being made to improve with updated versions. 44:03 💡 Arenas in memory management could be useful if done carefully, potentially saving CPU cycles, but they require proper guardrails to avoid breaking Go's safety rules. 45:53 🎨 Character design for the Go Gopher was primarily the work of Renee French, with variations in color evolving over time, including blue, pink, and monochrome versions.

I want the wallpaper from the beginning!

I just don't like the language named Go. It's not even unique. Go? Why is it called Go? Is it because it's fast? So unusual. What a name! 😅

** Strobe light warning ** (editor: some of us need this warning)

Honestly some of the go docs are still awful. Not as bad as a lot of the package documentation for a lot of packages like the AWS SDK for Go but that's not the Go teams fault

Nice to see a shout out on the gofmt slide

Folks, we love that you comment, but as a reminder, please keep your comments civil, and always aim to add to the discussion. If you have nothing to add to the discussion, please refrain from commenting. Otherwise it takes a lot of effort to moderate the comments.

👏Great talk!

Odin > Go 🔥🔥🔥

if err != nil go 🎊

Russ is clearly way more experienced than I'll ever be, so I'm probably wrong. I don't like obscure logic in tests. As the logic of the test might as well just be wrong. I also don't like the idea of custom mini languages and tests that 'correct' tests. It just seems like there's so much room to introduce problems into your tests. I want my tests easy to understand at a glance. For me and for the other people on the team. If I have to figure out some obscure custom mini language to understand whether my code is bad or the test is bad, I'm not happy.

Mostly very good advise on how to write good tests and a great talk well worth watching. I disagree in one point though. Putting lot of logic into test cases is a bad idea. It makes them harder to understand and more likely to be buggy themselves. Instead, test code should be as trivial as possible (using tables for test cases is fine). This also means that it is totally fine to have redundant code in your test cases.

I don't think that the person mainly responsible for most of what Go got wrong is in position to objectively say what it got right and wrong

I would like to uncover uncover

I LOVE GO!

33:26 Rob Pike describes telemetry of google chrome.

🎯 Key Takeaways for quick navigation: 00:09 🤖 *About the speaker and talk expectations* - Ragav Roy, engineer at VMware, works on network virtualization and contributes open source - Talk will cover coroutines as generalized subroutines, history of coroutines, classifications, implementing in Go, and Go runtime changes 01:43 🛡️ *Basics of subroutines* - Can suspend themselves, run other subroutines, terminate and yield control back - Eager means expressions evaluated immediately, closed means returns after evaluation 03:08 💼 *Defining coroutines* - Generalized subroutines that can suspend mid-execution and yield output to caller - Like functions that can return multiple times and keep state - Allows message passing without intermediate steps 04:18 🤔 *Comparing binary trees with coroutines* - Visit function traverses tree recursively, yields values back to caller - Callers resume visit concurrently to compare nodes - Context switching between coroutines calling visit 05:58 ⏳ *History: 1958 compiler example* - Symbol reducer writes tokens on tape, yields to name lookup - Direct passing via coroutines instead of expensive hardware - Negative cost abstraction: increasing abstraction while reducing cost 07:45 🤔 *Why coroutines not more prolific* - Lack of uniform view and precise definitions - Advent of ALGOL 60 and stack variables provided alternative 10:44 💭 *Implementing coroutines on call stack* - Mimics expensive multithreading instead of cheap abstraction - No consistent runtime model across languages 12:59 ⚖️ *Classifying and defining full coroutines* - Key properties: asymmetric, first-class, stackful - Full coroutines more powerful than Python/Kotlin coroutines 16:16 💡 *Asymmetric sufficient, symmetric hard* - Can build symmetric from asymmetric - Asymmetric easier to write and maintain 18:04 🏗️ *Building coroutine API in Go* - Go concurrency doesn't directly support coroutines - Can leverage goroutines, channels, functions 23:35 🤔 *Are these real coroutines? * - Yes, provide concurrency without parallelism - But just goroutines with resume/yield using channels 25:13 🛡️ *Handling errors* - Check running status, propagate panics - Cancel function to stop coroutine gracefully 28:25 ⚡ *Optimized runtime* - Fuse send/receive pairs - Direct switches without channels - 10X faster than channel implementation 30:02 🏁 *Conclusions* - Covered basics, history, classifications - Showed need in Go and implementation - Runtime optimizations significant speedup Made with HARPA AI

For me, the major bloopers are allowing naked returns and weak enums. Had my share of bugs mostly due to those two things.

I am really struggling to understand who is supposed to be the target audience. For a personal story, there was too much unrelated talking about Go. Not really a different point of view at learning Go. Not really a solid intro to Go as the experience is lacking... It would have been better to choose one category and focus on that. Hopefully covering something useful that is not a common knowledge.

What's your thoughts on using a workflow pattern instead of stitching logic together in your service like shown here?

How do you create output for machines vs human. I.e a machine might want to pipe the results of your command into another program but a human wants to see progress bar?

This was both enjoyable and educational! Very well crafted presentation 🎉

The thing is, "we are boring on purpose" gets really old after a decade. Now it looks more like an excuse for intellectual masturbation or just laziness.. I really don't think it has much to do with backwards compatibility either, a lot of cool things can be done while still maintaining backwards compatibility. Theres been so much innovation in the languages world over the past decade. I'll even agree that most are bad ideas or not compatible with go but there are a few good ideas there and even some that a compatible with go.. if not copying, they should at least inspire some action or innovation..

Thank you!

I kind of expected a bit more about command line format and e.g. why the built-in flags library should/should not be used instead of just "I use these 3rd party libraries". Also my eyes hurt from the light theme :). Otherwise it is quite nice that there is a demo for inspiration...

What a waste of time

26:54 Indeed, go's module system is it's one of the worst sides of it. It's way more better how node.js and rust handles that, when i struggle to understand go's module system i've experienced very big frustration.

Nice to see Rob being honest but I expected this talk to be about the Go type system. It's less than optimal. It misses Enums built-in.

I'm glad he mentioned "Go 2" is no longer going to exist.

Nice presentation - and also very accessible!

It would have been better if there were various real-world code examples, where there was an issue. So instead of describing generic issue, it would be a concrete example from past experience...

When seeing "Gopher" and and greybeard like "Rob Pike" in the title, I thought of the old Minnesota link-hierarchy server.

Go's biggest sin is being only moderately better than Java. It's no wonder C++ still plays a big role at Google, because Java already took over where C++ would have otherwise been used. The remaining cases where C++ is still used would not be written in Go for the same reasons it wouldn't be written in Java. I do have to say that Go is quite a pleasant language to use when it comes to working with binary formats. Just the right amount of succinctness and type checking.

Is there any plan to fix what they got wrong?

it was really interesting) thanks a lot!