Announcement

Collapse
No announcement yet.

Go 1.18 Released With Generics, Fully Integrated Fuzzing, ~20% Performance Improvements

Collapse
X
 
  • Filter
  • Time
  • Show
Clear All
new posts

  • #31
    Originally posted by Luke_Wolf View Post

    Rust and other similar ML derived languages' Result<T> and Option<T> are just the right way to do it vs Exceptions or the C or Go way of error handling. It expresses to the caller that an Error may occur or that a result may not exist (which is different from an error) and forces you to handle the case when it comes up. No weird excessive handling, no jumping around in code.

    Also when it comes to Generics in modern actively developed languages: Those who fail to implement Generics from the start of a language are doomed to implement it poorly in the future
    How is returning a tuple different from returning a Result<T> or Optional<T>?

    Comment


    • #32
      Originally posted by Ironmask View Post

      ... And many companies have had to rewrite their Go services in Rust because Go underperforms so badly that they can't keep up with their workload anymore.
      So, no, it's not a matter of taste, it's a matter of wasting time, money and, most importantly, energy.
      Go is a plight on the world just like Java and Python are, bogging down systems and wasting energy while people rush to get funding and resources to invent ways out of the hole they dug themselves in by making the mistake of naively choosing those technologies.
      You want to write a toy as a hobbyist, go ahead, use whatever esoteric language you want. But don't think it's just a matter of personal taste if you're talking about creating actual business software. Simply assuming people are just "bitter" or "not having fun" is extremely ignorant.
      Go was never meant to be high performance, Go was about fast time to market. Once you're there and you find out you need more performance, you're free to rewrite critical parts in whatever language you fancy.

      Comment


      • #33
        Originally posted by kenjitamura View Post
        As someone who learned programming concepts with Go as the first language...
        Agree. Go is a good first or second language ... i.e. a language for people who still don't know how to program very well.
        Because it is so simple.

        But the problem is, that it is not a good language for people who already do have programming experience and have grown accustomed to language features that other languages have and Go doesn't.
        With these people, even after 2 years of programming in Go, every other conversation starts with "I'm searching for some sane way of how I could do in Go something that I used to do easily in XXX language before"

        Comment


        • #34
          Originally posted by pkese View Post

          Agree. Go is a good first or second language ... i.e. a language for people who still don't know how to program very well.
          Because it is so simple.

          But the problem is, that it is not a good language for people who already do have programming experience and have grown accustomed to language features that other languages have and Go doesn't.
          With these people, even after 2 years of programming in Go, every other conversation starts with "I'm searching for some sane way of how I could do in Go something that I used to do easily in XXX language before"
          Bullshit. I have over 15 years of development experience and I and other senior developers around me enjoy Go simply because it heavily reduces the mental burden and allows us to concentrate on solving business problems. We don't have to constantly research about the new features that get introduced every few month (because Go keeps that to a minimum), the documentation is great and the low amount of variety in language features causes all libraries we work with to be understandable. There isn't suddenly a library where the author thought "hey, let's do this 100% functional" or "why not use inheritance all the way to the bottom".

          Same cannot be said about Java, C++, Rust, etc. Every library you encounter there follows completely different patterns and paradigms. Good look understanding them. You also can't write the simplest of services or tools without pulling in a shitload of dependencies. Hell, in Java or C++ I wouldn't even write and execute unit tests without a third party lib. In Rust that particular point is better, but writing anything more than Hello World still requires third party libs and then it's completely random if the libs use or don't use macros, use or don't use functional programming aspects, and how much of the available syntax sugar they apply.

          So I stand by my opinion that Go serves its purpose. So do the other languages; everyone is free to choose what they prefer.

          Comment


          • #35
            Originally posted by pkese View Post
            Agree. Go is a good first or second language ... i.e. a language for people who still don't know how to program very well.
            Because it is so simple.

            But the problem is, that it is not a good language for people who already do have programming experience and have grown accustomed to language features that other languages have and Go doesn't.
            I beg to disagree. I've been a software programmer for over 15 years (and started programming way earlier than that). I've seen languages with all sorts of features, yet I still appreciate Go's simplicity and rather rich runtime.
            It's still a tool you must use for the right purpose, but if you don't stop to bitch about missing this and missing that, Go is a surprisingly productive beast.

            Originally posted by pkese View Post
            With these people, even after 2 years of programming in Go, every other conversation starts with "I'm searching for some sane way of how I could do in Go something that I used to do easily in XXX language before"
            This is a toxic mindset, stay away from these developers. That's the type of developer that have learned one language and will not really learn anything ever again. They just take a superficial look at alternatives, try to use them the one and only way they know of and conclude the alternative is not up to par.
            When learning a new language, you have to take Yoda's advice and "unlearn what you have learned". Treat it as your first language, understand why it does things the way it does. Only after you have done all that can you start comparing.

            Comment


            • #36
              Originally posted by bug77 View Post

              How is returning a tuple different from returning a Result<T> or Optional<T>?
              Rust has other differences in error handling that is better ergonomically (? operator) or more powerful (thiserror, anyhow etc). Go is not bad, just very verbose.

              Comment


              • #37
                Originally posted by pkese View Post

                But the problem is, that it is not a good language for people who already do have programming experience and have grown accustomed to language features that other languages have and Go doesn't.
                This is certainly too broad a statement, there are programmers for instance in Scale which has a ton of the more "advanced features" and moved away to Go precisely because these features have a high cost to them. Now there might be domains where the features are worth the cost but this is certainly not the case for everyone. It is perfectly good language for a lot of the domains that it is highly used already, it is popular there for very good reasons.

                Comment


                • #38
                  Originally posted by bug77 View Post

                  How is returning a tuple different from returning a Result<T> or Optional<T>?
                  Because:
                  1. It gets embedded into the type system.
                  2. The program doesn't type if you don't check both cases.

                  With a tuple you can still ignore the second value by accident. With a Result<T> or Optional<T>, if you really want to ignore it, you need to do so explicitly.

                  Originally posted by cynic View Post
                  it IS error prone because one can simply "forget" checking errors and this is exactly because errors are NOT explicit.
                  Doesn't the compiler err if you assign a value and don't use it?

                  Comment


                  • #39
                    Originally posted by sinepgib View Post

                    Doesn't the compiler err if you assign a value and don't use it?
                    Yes, if you foo = bar(zoo), you can ignore the error in Go accidentally but if you do. foo, err = bar(zoo) and then you don't use it, the compile will warn. There are two issues with that, 1) err is often reused as a variable, so you may accidentally not check an earlier assigned error, lots of people get into the habit of using _ for the second variable which bypasses the compiler check, this is in part of how repetitive this gets, sometimes you want to do this temporarily, focus on the core logic and get back to handling error but then never get around to doing it.

                    Comment


                    • #40
                      Originally posted by aksdb View Post

                      Thanks. That's exactly the point. Unfortunately with every language the same shit happens over and over ... "but language X has Y, why don't you?! please implement it!". Then we end up with the next language X. Great. In the end no one uses it because it's just the same as the existing language but with a smaller community, less support and less contributions.

                      I want alternatives, not copies. Go is a great alternative. So is Rust. So is Haskell. They all serve their purposes.
                      No you don't. The honest truth is that developers don't want the mental overhead of having to deal with multiple languages, however they tolerate it because that's the reality of the situation. Every developer would prefer if all applications were written in his favorite programming language, regardless of whether it's because it's the only one he's learned and thus is clinging to or if he actually does have strong preferences on languages.

                      This is why languages which are not designed to be general purpose get abused into eventually becoming general purpose languages, such as Javascript, despite being completely unfit for that. What that means is that if new languages are introduced by large companies and then adopted solely for the sake of being the child of said company such as Go, and the language has not learned from the past important principles like generics being perhaps the single most important feature of any language (even if you aren't directly writing generic code, for the code you're relying upon) then it forces harmful programming practices which other developers will be forced to deal with the consequences of with this having been obvious for decades. It becomes especially difficult when everything in a domain is written in a particular language Scala is honestly a terrible language that is a giant ball of duct tape and chewing gum barely holding everything together, but it's probably going to dominate the big data space for another decade still because of Apache Spark.

                      If you don't want convergence then your only choice is to limit and get others to make the purposeful choice of limiting what they write in what particular language rather than believing that YourFavoriteLanguage works great for everything, when that is only really arguably true of languages that started from the stance of being general purpose.

                      Comment

                      Working...
                      X