Not like this Gosisters

Not like this Gosisters

  1. 4 weeks ago
    Anonymous

    Did they use a Zero (0) instead of a capital O to begin the word Ordered ( 0rdered)? lol
    I hate homosexuals that attempt to teach code debugging by intentionally fucking up code they share.

    • 4 weeks ago
      Anonymous

      >intentionally
      you wish, they had multiple fuck ups by using lowercase letters and people not being able to use core methods of the language, with time module afaik. The language is so well designed Puke himself cannot use it properly.

    • 4 weeks ago
      Anonymous

      That’s probably just the font
      This is not a teaching example btw, it’s part of the golang stdlib

    • 4 weeks ago
      Anonymous

      what's your issue, moron?

      no, you fucking imbecile

      • 4 weeks ago
        Anonymous

        >what's your issue, moron?
        spotted the retard

        • 4 weeks ago
          Anonymous

          >he doesn't know
          OH no ono

          • 4 weeks ago
            Anonymous

            Nice meme, retard. The issue is that your own type can't be part of this interface.

            • 4 weeks ago
              Anonymous

              the operators < <= >= > aren't defined on your types, so your whinging is moot. cry all you want about go being different from haskell or C++; no one gives a shite.

              • 4 weeks ago
                Anonymous

                Wait, you can't implement operators for your own types?
                Everytime I learn something about Go, my opinion of it and the mental capabilities of its creators lessens.

              • 4 weeks ago
                Anonymous

                your programming language is shit if you can't redefine '+' to send the contents of your SSD to a shady server in the congo

              • 4 weeks ago
                Anonymous

                A programming language is shit if I can't do the same thing with it as the standard library can.

                The irony.

                The irony.

              • 4 weeks ago
                Anonymous

                What do you mean?

              • 4 weeks ago
                Anonymous

                >I can't do the same thing with it as the standard library can
                pardon?

              • 4 weeks ago
                Anonymous

                Just read it again. You can't mumble in writing.

              • 4 weeks ago
                Anonymous

                What are you even trying to say? That doesn't make any sense.

              • 4 weeks ago
                Anonymous

                It doea. The standard libray can implement operators for its types, you can't for your own.
                It's Java all over again.

              • 4 weeks ago
                Anonymous

                The spec defines what the operators do, they're not dynamic dispatch. What are you even talking about. Are you having a stroke?

              • 4 weeks ago
                Anonymous

                >dynamic dispatch
                wtf are you talking about? Do you even know what this is? Probably not lol.

              • 4 weeks ago
                Anonymous

                Do you even know your own languages?
                https://en.wikipedia.org/wiki/Dynamic_dispatch

              • 4 weeks ago
                Anonymous

                >he had to lookup dynamic dispatch on wikipedia
                lmao

              • 4 weeks ago
                Anonymous

                >I don't know what this is
                >>here's a link
                >lmao
                I don't get it.

              • 4 weeks ago
                Anonymous

                I know what it is and it has nothing to do with operators. That's why I questioned whether you know what it is.

                disgusting spastic

                >concedes the argument
                Took you long enough to understand it.

              • 4 weeks ago
                Anonymous

                list languages in which you can (re)define operators
                list languages in which you cannot (re)define operators
                compare the numbers

              • 4 weeks ago
                Anonymous

                >I know what it is and it has nothing to do with operators. That's why I questioned whether you know what it is.
                You must have misread the part where I wrote "they're /not/ dynamic dispatch".
                Judging by your posts I'm guessing you're just after attention and not being serious.

                a generic quicksort, binary tree, etc
                Are all the Go detractors actual children still in high school? These kinds of exercise keep coming up in discussions but nobody ever seems to real world mention problems with actual code. Just hypothetical blackboard stuff which already has implementations or can be implemented in conventional Go just fine, now they can even be implemented generically and people still don't seem to understand how to design programs even with more options now.

                get your own opinions

                [...]
                >people still don't seem to understand how to design programs
                i think that might just be it. these sorts get weeded out by the go proposal process, which requires an actual, demonstrable, nontrivial use case where the proposal feature gives an obvious improvement.

                I'm terrified at how many people complain about error handling in Go. It implies that they don't handle errors in their own language.

              • 4 weeks ago
                Anonymous

                >You must have misread the part where I wrote "they're /not/ dynamic dispatch".
                I read that part and was confused because operator overloading has nothing to do with dynamic dispatch.
                So I concluded that you don't know what it is (as expected feom someone who uses Go).

              • 4 weeks ago
                Anonymous

                Methods on types work that way in lots of languages. Including Go and C++.
                Go doesn't allow you to define an operator function on a type, if it did, that's likely how they'd implement it.
                Do you have a point or was I right, you're seeking someone to talk with?

              • 4 weeks ago
                Anonymous

                >go does dynamic dispatch
                Holy shit, my opinion of it has lessened even more. Either way, operator overloading still has nothing to do with dynamic dispatch.
                You can overload operators in Python for example.
                C++ also supports operator overloading.

              • 4 weeks ago
                Anonymous

                people who use operator overloading, except for vectors and matrices, aren't human

              • 4 weeks ago
                Anonymous

                Go doesn't have vectors nor matrices. Guess what you have to do if you want to implement your own.

              • 4 weeks ago
                Anonymous

                define functions. shock horror!

              • 4 weeks ago
                Anonymous

                or i can just use a language with the basics already available and do actual work instead of reinventing wheels

              • 4 weeks ago
                Anonymous

                >or i can just use a language with the basics already available and do actual work instead of reinventing wheels
                Your language will be deprecated before your build is done.

              • 4 weeks ago
                Anonymous

                go is newer than most relevant languages and will be dead within another decade.

              • 4 weeks ago
                Anonymous

                operator overloading is no more or less work than defining any other method

                >1.add(2).multiply(3)
                nice language, retard

                w = vadd(u, vmul(v, s))
                who fucking cares

              • 4 weeks ago
                Anonymous

                >1.add(2).multiply(3)
                nice language, retard

              • 4 weeks ago
                Anonymous

                >I'm terrified at how many people complain about error handling in Go. It implies that they don't handle errors in their own language.
                Retard.

                If you deal with the error, you have roughly the same amount of code as in other langues, HOWEVER in 99% of the cases, all you ever do is
                if err != nil {
                return nil, err
                }
                So you have 3-5 extra lines of code (depending on how many newlines you use) that actually do nothing except what already happens in other languages with uncaught exceptions. After every fucking function call that can somehow throw an error.

              • 4 weeks ago
                Anonymous

                https://go.dev/blog/errors-are-values

              • 4 weeks ago
                Anonymous

                >it's the same as other languages therefore it's bad
                Good talk. Thanks. Learn to abstract better I guess.

                Because I like to stay in the highest level of abstraction. This is how you write good software.

                I don't really see how it's much different. You'd abstract those types the same ways.

              • 4 weeks ago
                Anonymous

                >You'd abstract those types the same ways.
                What if I want to keep my comparison value private? Maybe I don't want some chuckle fuck dev deciding to alter it part way through an algorithm. In, say, Rust I'd just derive a partial ordering on the struct that would allow anyone say something like ThisStruct < ThatStruct without actually exposing any of the underlying details. Unless I've miss understood, I can't do that in Go.

              • 4 weeks ago
                Anonymous

                Less

              • 4 weeks ago
                Anonymous

                Without a concrete example it's hard to come up with an ideal solution but it sounds like you'd just use an interface.
                With generics you could simply switch on the type.
                If it's a builtin, use <, if it's a user type call instance.LessThan().
                Or just do the latter in all cases. Or something else entirely.

              • 4 weeks ago
                Anonymous

                >go
                >ideal solution

              • 4 weeks ago
                Anonymous
              • 4 weeks ago
                Anonymous

                triggered xD

              • 4 weeks ago
                Anonymous

                "Go" back to /r/programminghumor.

              • 4 weeks ago
                Anonymous

                The irony.

              • 4 weeks ago
                Anonymous

                >Implement a generic quicksort, binary tree, etc
                >Can only use it with ints, floats and strings
                Golang fail

              • 4 weeks ago
                Anonymous

                There already is sorting function for any types since forever ago. You should try to learn instead of baiting

              • 4 weeks ago
                Anonymous

                Yeah you just have to use “Less” instead of < and re-explain how to swap elements in an array to the Go compiler every time you want to use a new type

                learn how to use first-class functions and closures you fucking imbecile

                [...]
                the standard library doesn't "implement operators" you stupid cunt
                jesus it's like every anti-gotard is a misinformed fucking mong

                Yeah just go through the codebase and change every anonymous function passed to every generic function instead of changing a single type. Go is a productive language guys

                a generic quicksort, binary tree, etc
                Are all the Go detractors actual children still in high school? These kinds of exercise keep coming up in discussions but nobody ever seems to real world mention problems with actual code. Just hypothetical blackboard stuff which already has implementations or can be implemented in conventional Go just fine, now they can even be implemented generically and people still don't seem to understand how to design programs even with more options now.

                >Nobody ever uses data structures other than arrays, slices and maps in the real world
                >Nobody ever needs to compare values types other than int, float and string

              • 4 weeks ago
                Anonymous

                >Yeah you just have to use “Less” instead of < and re-explain how to swap elements in an array to the Go compiler every time you want to use a new type
                any complaints that aren't utterly trivial, though?

                >Yeah just go through the codebase and change every anonymous function passed to every generic function instead of changing a single type. Go is a productive language guys
                what the fuck are you on about?

              • 4 weeks ago
                Anonymous

                ever uses data structures other than arrays, slices and maps in the real world
                ever needs to compare values types other than int, float and string
                They do and have for years now. How come they can implement them with interfaces and generics and you can't? Legitimate question. Sincerely, what problems are you experiencing. Give actual code and you might get actual advice if people are patient enough (I'm not).

              • 4 weeks ago
                Anonymous

                Any implementation in Go will be subpar.
                >Use Constraints.Ordered
                Limited to 3 types. Genius!
                >Roll your own Ordered interface
                You’ll have to manually implement it for other people’s types. The fact that this option is even on the table proves that Go is a shitlang
                >Use a more general constraint (e.g. T any)
                Makes type checking less effective
                >Provide functions manually
                Makes the codebase a lot more awkward to write, read, use and maintain

              • 4 weeks ago
                Anonymous

                What sort of rust/haskell fanatic worth his salt is scared of first-class functions?

              • 4 weeks ago
                Anonymous

                Those languages have traits/typeclasses (like interfaces but better)

              • 4 weeks ago
                Anonymous

                It works well for me in code I've written, but I can understand how your hypothetical problem would be annoying to deal with in my mind, so I concede.

              • 4 weeks ago
                Anonymous

                >have quasi-traits that allow you to supply your own types to foreign code, as long as they support the interface
                >even if it's over-eager by the virtue of being implicit, it greatly increases interop and makes all kinds of libraries, especially the standard one, much more useful
                >finally introduce generics, even type constraints
                >throw the great system you had in the trash by introducing non-basic interfaces with type sets
                >they invert the control, types no longer implement the interface, not interface has to define every single type it's implemented by
                >they reuse the name interface even though they aren't actually interfaces, you can't implement them and you can't even have a variable of their type, or mix them with regular interfaces
                >all because the language is made by C cultists against making operators into functions/interfaces (don't even need to allow for overloading) and think "muh keyword count" somehow makes 2 different things using the same keywords more understandable
                what a blunder

                Yea
                sort.Slice takes a function that takes two ints which are the fucking indicies to the slice that is currently being fucking sorted because it's a giant hack for no generics (if there were you could just pass pointers to the type being sorted)
                so to make a reusable sorting function you need to make a higher order one that takes a function and returns a function taking int,int amazing
                or you can use sort.Interface and sort.Sort and define 3 methods and a type alias per type per sorting method
                and after all that there is no way to sort by key in std

              • 4 weeks ago
                Anonymous

                learn how to use first-class functions and closures you fucking imbecile

                It doea. The standard libray can implement operators for its types, you can't for your own.
                It's Java all over again.

                the standard library doesn't "implement operators" you stupid cunt
                jesus it's like every anti-gotard is a misinformed fucking mong

              • 4 weeks ago
                Anonymous

                >boohoo don't state inconvenient facts about my favorite language
                How often do I have to say it?
                Go has operators (like + and -, you might remenber them from whatever special education you receives)
                Go has integers
                You can use those operators with integers
                Now I know this was already a bit complex, so please take a pause and rest your brain before you cintinue reading.
                You can create your own types (like a BigInteger)
                You can't use operators with those, because ???
                It's literally Java, except even worse because Java has actually substantially improves since Java 8.

              • 4 weeks ago
                Anonymous

                >You can't use operators with those, because ???
                because, like most languages, operators are part of the syntax -- and, like most languages, go does not have redefinable syntax. this is not unusual, so singling out go seems strange.

              • 4 weeks ago
                Anonymous

                cope

              • 4 weeks ago
                Anonymous

                disgusting spastic

              • 4 weeks ago
                Anonymous

                >the standard library doesn't "implement operators"
                yes it does

              • 4 weeks ago
                Anonymous

                >yes it does
                Then you should easily be able to point out the standard library code that implements them. Go ahead and do that.

              • 4 weeks ago
                Anonymous

                my bad
                *yes it can
                >The standard libray can implement operators for its types
                >the standard library doesn't "implement operators" you stupid cunt
                go's doesn't, but it's possible

              • 4 weeks ago
                Anonymous

                Good Christ you're retarded

              • 4 weeks ago
                Anonymous

                a + on two 32bit ints for example can just tbhgar into a function present in standard library that is somehow associated with that combination of types
                now, most languages would just make that function a compiler built-in because nobody cares about true innards of adding 2 ints, the important part is establishing the connection between a type (or types), an operator, and a function.
                however, if your language also has inline assembly and conditional compilation there technically is nothing stopping you from keeping the logic behind that int addition entirely within the standard library

              • 4 weeks ago
                Anonymous

                Yes, thank you. Everyone is aware that some languages have operator overloading. Go (which is the language we are actually talking about) doesn't, nor does it have inline assembly. You have taken this way off the rails just to act like your original claim isn't as retarded as it obviously is.

              • 4 weeks ago
                Anonymous

                It's not my claim, it's you who forced me to explain it because you were posting vague shit like

                Good Christ you're retarded

                That anon's original point was
                >A programming language is shit if I can't do the same thing with it as the standard library can.
                and after asking him what he means like you're mentally challenged or something you respond with
                >the standard library doesn't "implement operators" you stupid cunt
                Yea, no shit. It doesn't implement it because it can't, because there is no mechanizm to associate types and operators with some code. That doesn't mean it's impossible to have it. You're arguing in bad faith and focusing on that it's technically not in standard lib. If sorting was moved into a compiler built-in would you argue that you shouldn't have ability to sort anyway?

              • 4 weeks ago
                Anonymous

                >everyone on LULZ other than me is the same person
                Aside from all the posts you're erroneously attributing to me, the anon's "original point" was a counter to

                your programming language is shit if you can't redefine '+' to send the contents of your SSD to a shady server in the congo

                's sarcastic attack on operator overloading, which was meant to be a defense of Go specifically, since it was insulted by

                Wait, you can't implement operators for your own types?
                Everytime I learn something about Go, my opinion of it and the mental capabilities of its creators lessens.

                and is the entire topic of the thread. If you can't carry context forward over the course of 3 posts, that's on you.

              • 4 weeks ago
                Anonymous

                a generic quicksort, binary tree, etc
                Are all the Go detractors actual children still in high school? These kinds of exercise keep coming up in discussions but nobody ever seems to real world mention problems with actual code. Just hypothetical blackboard stuff which already has implementations or can be implemented in conventional Go just fine, now they can even be implemented generically and people still don't seem to understand how to design programs even with more options now.

              • 4 weeks ago
                Anonymous

                >Implement a generic quicksort, binary tree, etc
                >Can only use it with ints, floats and strings
                Golang fail

                Lmao, seriously? So I can't just define an ordering on my structs? Fucking Golang.

              • 4 weeks ago
                Anonymous

                Why not use an array or stream if you want that?

              • 4 weeks ago
                Anonymous

                Because I like to stay in the highest level of abstraction. This is how you write good software.

              • 4 weeks ago
                Anonymous

                Name 10 languages where you can.

    • 4 weeks ago
      Anonymous

      Go doesn't support identifiers that start with 0. https://go.dev/ref/spec#Identifiers

      • 4 weeks ago
        Anonymous

        They're going to moan about that now.

        • 4 weeks ago
          Anonymous

          I don't know any langauge that supports that because it's going to be hand and error-prone to check whether something is identifier or a number in that case.

      • 4 weeks ago
        Anonymous

        Thank you, then

        That’s probably just the font
        This is not a teaching example btw, it’s part of the golang stdlib

        more than likely was correct.

        • 4 weeks ago
          Anonymous

          >he actually thought someone would make a mistake that bad and commit it after review
          Literally h0w.

          • 4 weeks ago
            Anonymous

            >|-|0//?
            It is easy to have no faith in people.

          • 4 weeks ago
            Anonymous

            >|-|0//?
            It is easy to have no faith in people.

            >mfw

            • 4 weeks ago
              Anonymous

              Martha was always very efficient. Her and Julia Child are the only women I have ever tried to learn from in regards to cooking.

      • 4 weeks ago
        Anonymous

        They're going to moan about that now.

        Considering they don't reserve ? I'm kind of mad it's not allowed in identifiers. I really liked seeing that when doing SICP for boolean functions.
        (IsConditionTrue? x y) I guess it looks less good in C-like languages.
        IsConditionTrue?(x, y)

    • 4 weeks ago
      Anonymous

      peak autism

  2. 4 weeks ago
    Anonymous

    Go is actually more retarded than C.
    Amazing achievement tbh.

  3. 4 weeks ago
    Anonymous

    I don't understand what you're trying to say.

  4. 4 weeks ago
    Anonymous

    https://fasterthanli.me/articles/i-want-off-mr-golangs-wild-ride

    • 4 weeks ago
      Anonymous

      get your own opinions

      a generic quicksort, binary tree, etc
      Are all the Go detractors actual children still in high school? These kinds of exercise keep coming up in discussions but nobody ever seems to real world mention problems with actual code. Just hypothetical blackboard stuff which already has implementations or can be implemented in conventional Go just fine, now they can even be implemented generically and people still don't seem to understand how to design programs even with more options now.

      >people still don't seem to understand how to design programs
      i think that might just be it. these sorts get weeded out by the go proposal process, which requires an actual, demonstrable, nontrivial use case where the proposal feature gives an obvious improvement.

  5. 4 weeks ago
    Anonymous

    I love watching people moan about Go, it's vindicating.

  6. 4 weeks ago
    Anonymous

    https://fasterthanli.me/articles/lies-we-tell-ourselves-to-keep-using-golang

    • 4 weeks ago
      Anonymous

      get your own opinions

  7. 4 weeks ago
    Anonymous

    The key point here is our programmers are Googlers, they’re not researchers. They’re typically, fairly young, fresh out of school, probably learned Java, maybe learned C or C++, probably learned Python. They’re not capable of understanding a brilliant language but we want to use them to build good software. So, the language that we give them has to be easy for them to understand and easy to adopt.

    It must be familiar, roughly C-like. Programmers working at Google are early in their careers and are most familiar with procedural languages, particularly from the C family. The need to get programmers productive quickly in a new language means that the language cannot be too radical.

    t. Rob Pike

  8. 4 weeks ago
    Anonymous

    >breaks your total order
    Psst, nothing personnel, kid.

    • 4 weeks ago
      Anonymous

      Not specifically a Go problem

      • 4 weeks ago
        Anonymous

        So?

      • 4 weeks ago
        Anonymous

        Yes. Go's problem however is that it doesn't distinguish between totally and partially ordered types. There are algorithms that only work properly with totally ordered sets.
        What does this constrain guarantees anyway? Just that the type uses comparison for some operation, or does it actually guarantees that these operators return boolean and are transitiva and assymetric? Because they surely aren't reflexive and strongly connected.

        • 4 weeks ago
          Anonymous

          In Go, it guarantees that the type is an int, a float, a string or a wrapper around a string.
          In other languages, it provides a valid comparison operation for the type. An exception was made for floating point numbers because most languages want to conform to IEEE 754 and don’t think to add partial orderings

          • 4 weeks ago
            Anonymous

            >In Go, it's useless
            I see

            • 4 weeks ago
              Anonymous

              >In Go, it guarantees that the type is an int, a float, a string or a wrapper around a string.
              It literally says they will add other types in the future. So it doesn't even guarantee that.

              Now you understand golang

            • 4 weeks ago
              Anonymous

              Go was designed by Unix weenies who are still mentally addled by DEC hardware quirks. Expecting them to understand basic type theory is unrealistic.

              • 4 weeks ago
                Anonymous

                Go has very little to do with type theory

          • 4 weeks ago
            Anonymous

            >In Go, it guarantees that the type is an int, a float, a string or a wrapper around a string.
            It literally says they will add other types in the future. So it doesn't even guarantee that.

  9. 4 weeks ago
    Anonymous

    as you can see, something is wrong with go-whiners

  10. 4 weeks ago
    Anonymous

    So Golang have union types now ?

  11. 4 weeks ago
    Anonymous

    >new types will be added here when we add orderable types
    So this list can grow to infinity

Your email address will not be published.