(I think Go takes all mediocre language features together and makes an even more mediocre language TBH, take error handling for example, or generic programming (which I agree should be used sparingly, but is super useful if you need it))
Go does have generics nowadays, although they have some limitations (like pointer types being inefficient because reasons).
But yeah I'd tend to agree. Go's strength and explicit design goal is that it's relatively easy to learn and get started with, meaning it's fast to onboard new devs. It's very much a "get shit done" language.
Its weakness is – to paraphrase someone's criticism of Go – the core dev team's extreme unwillingness to adopt any programming language and tool chain designs and patterns invented after the 70's. Pike's rationale against generics was that in cases where you'd normally reach for generics you can either use interfaces (and especially interface{} which is like Go's void* and throws all type information out the window and is slower than proper types because reasons), or just copy and paste code. Because what you as a developer want to do is reimplement something like Find(needle SomeType, haystack []SomeType) for the Nth time in every project, or take a performance hit and lose all type information by using interface{}.
And don't even get me started on how long it took for Go to get proper dependency management and what the arguments against it were, Jesus fuck.
Go is currently the language I'm most fluent in after having written mostly Go for something like 8 years or even more (I remember when error was Error, pre 1.0 I think) and the one I'd be the most productive in, which is sort of unfortunate since I really don't like it as a language 😁 Learning Julia at the moment though, since I'm going back to the university to study some more computer science and maybe get into evolutionary algorithm research, and Julia is a neat language for lots of different number crunch-y tasks (no I won't touch Python, significant whitespace is a crime against common sense and fully dynamic typing gives me the heebie jeebies)
I've heard of Rust. It sounds noisy and even more verbose than Go, which is already a fairly verbose language. I haven't had any reason to learn Rust, so I haven't done so. The error handling is annoying but at this point I don't really notice it any more. And as interolivary said, Go has generics now.
Yeah this was my initial reaction way back when I first heard of Rust as well (sometime around 2015 or so I think). TBF it's definitely not on the same level as e.g. Haskell. But it's generally I would say less verbose than go (or at least has verboseness where it makes sense compared to go IMHO).
The generic system is also (way) less powerful compared to Rusts (The trait type system/type-classes is really a nice Haskell-inspired thing, that I don't want to miss anymore). Also the lack of sum types and proper pattern matching makes go more verbose IMHO.
*grumble*. I dabbled in Scala a few years back and I am really grumpy every time I remember that Go doesn't have sum types, pattern matching, and the closed union of types construction you can create with an abstract final class in Scala. I loved that last one and used the heck out of it. I would love to have a compiler-enforced guarantee that a set of types was closed and could not be extended.
... until you've heard of Rust :)
(I think Go takes all mediocre language features together and makes an even more mediocre language TBH, take error handling for example, or generic programming (which I agree should be used sparingly, but is super useful if you need it))
Go does have generics nowadays, although they have some limitations (like pointer types being inefficient because reasons).
But yeah I'd tend to agree. Go's strength and explicit design goal is that it's relatively easy to learn and get started with, meaning it's fast to onboard new devs. It's very much a "get shit done" language.
Its weakness is – to paraphrase someone's criticism of Go – the core dev team's extreme unwillingness to adopt any programming language and tool chain designs and patterns invented after the 70's. Pike's rationale against generics was that in cases where you'd normally reach for generics you can either use interfaces (and especially
interface{}which is like Go'svoid*and throws all type information out the window and is slower than proper types because reasons), or just copy and paste code. Because what you as a developer want to do is reimplement something likeFind(needle SomeType, haystack []SomeType)for the Nth time in every project, or take a performance hit and lose all type information by usinginterface{}.And don't even get me started on how long it took for Go to get proper dependency management and what the arguments against it were, Jesus fuck.
Go is currently the language I'm most fluent in after having written mostly Go for something like 8 years or even more (I remember when
errorwasError, pre 1.0 I think) and the one I'd be the most productive in, which is sort of unfortunate since I really don't like it as a language 😁 Learning Julia at the moment though, since I'm going back to the university to study some more computer science and maybe get into evolutionary algorithm research, and Julia is a neat language for lots of different number crunch-y tasks (no I won't touch Python, significant whitespace is a crime against common sense and fully dynamic typing gives me the heebie jeebies)I've heard of Rust. It sounds noisy and even more verbose than Go, which is already a fairly verbose language. I haven't had any reason to learn Rust, so I haven't done so. The error handling is annoying but at this point I don't really notice it any more. And as interolivary said, Go has generics now.
Yeah this was my initial reaction way back when I first heard of Rust as well (sometime around 2015 or so I think). TBF it's definitely not on the same level as e.g. Haskell. But it's generally I would say less verbose than go (or at least has verboseness where it makes sense compared to go IMHO).
A good article about this: https://matklad.github.io/2023/01/26/rusts-ugly-syntax.html
The generic system is also (way) less powerful compared to Rusts (The trait type system/type-classes is really a nice Haskell-inspired thing, that I don't want to miss anymore). Also the lack of sum types and proper pattern matching makes go more verbose IMHO.
*grumble*. I dabbled in Scala a few years back and I am really grumpy every time I remember that Go doesn't have sum types, pattern matching, and the closed union of types construction you can create with an abstract final class in Scala. I loved that last one and used the heck out of it. I would love to have a compiler-enforced guarantee that a set of types was closed and could not be extended.