Відео

Thank you! I've found a lot of examples out there, but I was able to understand how that works just now

Thanks brother Have u made any playlist teaching complete go lang course If yes plz mention

lol, why don't you use Arc::clone() along with Arc:new()?

Mach doch Videos auf deutsch. Gute englische Kanäle gibts schon ohne Ende, professionelle deutsche besonders für Rust nicht so

It's fcked! 🤢

Thank you, i really love your content and your manner of explanation :)

Greeting from Brazil 👋🇧🇷 Excellent video, your didactic is really good. Thanks for your work!

I want to love go but it sucks :( , it doesnt have typesafe enums, readonly props, marker interfaces, explicit interface decl, discriminated unions, required fields, pattern matching, adhoc polymorphism...

Damn man, that was a direct hit. So clear and tqsm

12:03 Wow did not know that, thank you!

This cursor block shape is a nightmare

iota makes me uncomfortable. Someone changes the order indirectly, you get a subtle bug.

Thank you for sharing this concept. (As you know, nested blocks of code are against best practices and clean principles.)

Very good video, I didn't understood 5:50 (binary prefix, SI unit ...), can you provide some resources?

One thing to note, you can use += with mut String's but not &str's, mut or not. It doesn't make sense to me, and I feel it was the wrong direction for them to take the design, but I also don't think there are many languages which get strings correct. Another pain point, since strings are UTF-8 encoded, .len() doesn't report the correct number of characters in the string but instead reports the number of bytes, which is fine for allocation purposes, but nothing else. I don't know if anyone else would agree, but I think that strings should have been treated as first class objects and default to a string_view type of some kind. Of course, I also wouldn't design things around explicit borrowing and ownership rules, but I can't imagine any Rustacean will agree with that stance.

This gives me a lot to ponder. Is it more important to have a consistent error handling technique, like always use `r, err := foo(); if err != nil ...` or would it not make sense in certain circumstances to change the methodology when the return value is both the error and desired object? Consider the C way of doing things where the return value is a pointer to something and if the operation failed the pointer is NULL. So merely checking the return is how you determine if you can go on. `FILE *f; f = fopen( "some_file.txt", "rb" ); if ( !f ) ...` Also, if you call panic() in Go, do deferred operations still execute or do they get skipped?

Unless im missing something, its Honestly a bad design by Go designers. How would I know what interfaces a type implements off the bat ?

For case 2, when you want to return an error, it is possible to use Must, CheckErr but also add a deferred statement with recover at the beginning. If this statement is coupled with a named error argument, you can modify it and return the error. Is this a bad practice?

Honestly I think posting this video as-is was rather irresponsible. Too often you show Must() w/panic() and imply it is a good practice because of how it "simplifies the code." Viewers who don't watch the entire video or who are not good at noticing nuance, and who don't read the comments will likely see your praise of Must()+panic() and leave thinking it a practice they should emulate. On the contrary, there are very few use-cases where panic should ever be used, and certainly not in code intended for production use. IMO you really should add a very obvious disclaimer to the beginning of the video saying you "were just showing how Must() works, but please do not ever actually use it for anything other than personal use or for testing." #fwiw

I found your channel just days back and I can’t thank you enough for these videos!! This is great!! 😭

Why did we use generic types here?

Which extenshion you use for error intellicence which show issue in the front of error line

I truly think this Must function version with generics should be on the standard library. I always write it myself in almost all my projects.

I learnt something new thanks. I think it's a great video, as usual!. Disagreeing with things =/= bad video :)

Yeah yeah naaaaah, don't use Go if you don't want to handle errors as values. Must function is a very precise knife. To be used carefully. Error as values is the spirit of GO. If you don't accept it you will just be fighting the language

Love the golang kids crying that you must handle errors when using golang. This pattern is effectively an assert, and you use asserts in cases where you need to crash. For static content known at compile time, like a fucking regex, this decreases verbosity and increases the readability.

If you don't want to check erors don't use Go. Explicit errors are THE philosophy of Go.

Please don't use log.Fatal... Especially if your writing a module to be used by others. Some things to remember. Log.Fatal terminates the program immediately. Panic will run any defers and can be recovered.

I think errors as return values is one of the strong points of the language. That it tends to result in the ubiquitous `if err != nil` and that there is no ternary operator or other facility to deal with it in another way is another and long-standing discussion :-)

👉👉👉Panic() is NOT error handling. Golang handles exceptions through the Panic+Recover mechanism. PLZ Do not mix concepts.

Timers & Tickers? Game devs: "I now this one!"

Are you using zed editor 😅? Great video btw!

I get it, go has very verbose error handling to a point where it makes code harder to read. After doing some rust one feels the pain even more. But look this is go, and the good side of it is that any junior dev can look at the code and figure out what’s going on. And has less ways to screw error handling up when following some simple guidelines. One of them is “don’t panic”. So I think this makes things complicated by hiding logic away and it will either confuse someone or it’s likely that Must() will be used where it shouldn’t. So I’d advice to just keep things the go way or use another language. Otherwise there’s really no point because you get the worst and miss the benefits mixing it all up.

I usually like your content but I think this video is a bit off. panic in go is an anti pattern and really should be avoided at all costs. There is only 1 reason to use a panic and that is if the code is going to panic anyway then issue a panic with a helpful message; ie if you are about to dereference a nil pointer then it’s ok to panic with a meaningful message rather than allow a generic nil reference panic to occur which is harder to debug. I don’t think you have appreciated how bad using panics is. Use the error checking mechanism, that’s what it’s there for. Depending on panic and recover is just asking for trouble

Just be aware that wrapping your functions in other functions shouldn't be used in performance critical sections.

Sometimes it seems bad when insert same error check in multiple times within same block. But i read somewhere the best practice is that caller of the function should handle the errors. Hoping some improvement in the future.

I rather like the error checking in Go! If go just improved the syntax over if err != nil {} I honestly wouldn't have anything to complain about .

This is honestly a bad advice. wrapping your function calls with "Must" or "CheckError" isn't any cleaner. And "don't panic" is a go proverb. I agree with you that sometimes we just wanna bubble up the errors without necessarily handling them. For that I hope the Go team add some sugar ( like the Rust's "?" operator) to make it easy to do so.

I strongly disagree. It is my humble opinion that error handling in Go is excellent. I think that panic is not error handling and should not be used like an exception. Edit: Once again you continue to impress. This video is an excellent treatment of the topic. Everyone, please watch to the end as the entirety of this video is important.

Danke, du solltest den genialen Content auch in deutsch bringen, wir brauchen mehr deutsche GoLangDevs

I don't see these error checks as "redundant" if they are there then we can follow the "happy path" and "sad path" only when there is something not working aka throwing an error. This reduces the cognitive load on the reader and make the code easier to read. Any other option is basically hiding the information and the Golang is not about that. I bet that's why some people were opposing the generics in the first place.

Seitdem im Oktober Zed für Linux veröffentlicht wurde, nutze ich das nur noch in meinem Elektrotechnik-Studium, extremes Tool. Ich hoffe allerdings das in Zukunft noch Plattformio das ganze ach akzeptiert bzw. eine extension dafür erstellt und das z.B. Laravel mehr Extensions hinzufügt (neben PHP Intellisense)

Very professional content. Great presentation also. Bravo Flo

Hype is the word came to my mind.

That's a great example. I wonder if in real code bases people manually write out the validation like you did or if they're using a library like go validator. Coming from JS that looks like a lot of code for simple validation lol.

I'm new to Go and your video's help me a lot, thanks 🙏. Keep it up 💪

You should also have shown the inclusive syntax for slicing which uses ..= so that the end index is included. For example, let v = vec![0, 1, 2, 3, 4]; let s = &v[1..=3]; and you get [1, 2, 3]. I don't understand their rationale for this design choice since I think that .. should be an inclusive range, but I assume it's because they didn't think of using other symbols. For my own language, I opted to use .. for inclusive slicing, : for start and length slicing, and commas for selection. I don't know if it's too late to get someone working on Rust to incorporate this idea, but an example of its usage would be: v := [1, 2, 3, 4, 5, 6], inclusive_slice = v[1..3], start_plus_length = v[1:2], selections = v[1,3,5]; then the results would be [2,3,4], [2,3], [2,4,6].

what is the name of the font you are using, I love your videos by the way 💥