• ennemi [he/him]
      ·
      edit-2
      1 year ago

      If only there was some way the compiler could detect unused variable declarations, and may be emit some sort of "warning", which would be sort of like an "error", but wouldn't cause the build to fail, and could be treated as an error in CI pipelines

      • CoderKat@lemm.ee
        ·
        edit-2
        1 year ago

        Let's not pretend people acknowledge warnings, though. It's a popular meme that projects will have hundreds of warnings and that devs will ignore them all.

        There's a perfectly valid use case for opinionated languages that don't let you get away with that. It's also similar to how go has gofmt to enforce a consistent formatting.

        Honestly, I've been using Go for years and this unused variable error rarely comes up. When it does, it's trivial to resolve. But the error has saved me from bugs more often than it has wasted my time. Most commonly when you declare a new variable in a narrower scope when you intended to assign to the variable of the same name (since Go has separate declare vs assign operators).

        • ennemi [he/him]
          ·
          edit-2
          1 year ago

          You can, if you want, opt into warnings causing your build to fail. This is commonly done in larger projects. If your merge request builds with warnings, it does not get merged.

          In other words, it's not a bad idea to want to flag unused variables and prevent them from ending up in source control. It's a bad idea for the compiler to also pretend it's a linter, and for this behaviour to be forced on, which ironically breaks the Unix philosophy principle of doing one thing and doing it well.

          Mind you, this is an extremely minor pain point, but frankly this is like most Go design choices wherein the idea isn't bad, but there exists a much better way to solve the problem.

      • iammike@programming.dev
        ·
        1 year ago

        Some people simply ignore warnings, that's the main issue. Trust me, I saw this way too often.

        If you cannot compile it than you have to fix it, otherwise just mark unused variables as 'not an error' via _ = someunusedvar.

    • arc@lemm.ee
      ·
      1 year ago

      Swift and Rust have a far more elegant solution. Swift has a pseudo throw / try-catch, while Rust has a Result<> and if you want to throw it up the chain you can use a ? notation instead of cluttering the code with error checking.

      • barsoap@lemm.ee
        ·
        1 year ago

        The exception handling question mark, spelled ? and abbreviated and pronounced eh?, is a half-arsed copy of monadic error handling. Rust devs really wanted the syntax without introducing HKTs, and admittedly you can't do foo()?.bar()?.baz()? in Haskell so it's only theoretical purity which is half-arsed, not ergonomics.

        • m_f@midwest.social
          ·
          1 year ago

          It's not a half-arsed copy, it's borrowing a limited subset of HKT for a language with very different goals. Haskell can afford a lot of luxuries that Rust can't.

          • barsoap@lemm.ee
            ·
            1 year ago

            It's a specialised syntax transformation that has nothing to do with HKTs, or the type system in general. Also HKTs aren't off the table it's just that their theory isn't exactly trivial in face of the rest of Rust's type system but we already have GATs.

            It actually wouldn't be hard writing a macro implementing do-notation that desugars to and_then calls on a particular type to get some kind of generic code (though of course monomorphised), but of course that would be circumventing the type system.

            Anyhow my point stands that how Rust currently does it is imitating all that Haskell goodness on a practical everyday coding level but without having (yet) to solve the hard problem of how to do it without special-cased syntax sugar. With proper monads we e.g. wouldn't need to have separate syntax for async and ?

        • arc@lemm.ee
          ·
          1 year ago

          You can say it's half-arsed if you like, but it's still vastly more convenient to write than if err != nil all over the place

      • ennemi [he/him]
        ·
        edit-2
        1 year ago

        The language was designed to be as simple as possible, as to not confuse the developers at Google. I know this sounds like something I made up in bad faith, but it's really not.

        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. – Rob Pike

        "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. – Rob Pike

        The infamous if err != nil blocks are a consequence of building the language around tuples (as opposed to, say, sum types like in Rust) and treating errors as values like in C. Rob Pike attempts to explain why it's not a big deal here.

      • silent_water [she/her]
        ·
        1 year ago

        a desperate fear of modular code that provides sound and safe abstractions over common patterns. that the language failed to learn from Java and was eventually forced to add generics anyway - a lesson from 2004 - says everything worth saying about the language.

  • CodeBlooded@programming.dev
    ·
    edit-2
    1 year ago

    If this language feature is annoying to you, you are the problem. You 👏are 👏 the 👏 reason 👏 it 👏 exists.

    I worked in places where the developers loaded their code full of unused variables and dead code. It costs a lot of time reasoning about it during pull request and it costs a lot of time arguing with coworkers who swear that they’re going to need that code in there next week (they never need that code).

    This is a very attractive feature for a programming language in my opinion.

    PS: I’m still denying your pull request if you try to comment the code instead.

    ❗️EDIT: A lot of y’all have never been to programming hell and it shows. 🪖 I’m telling you, I’ve fixed bayonets in the trenches of dynamically typed Python, I’ve braved the rice paddies of CICD YAML mines, I’ve queried alongside SQL Team Six; I’ve seen things in production, things you’ll probably never see… things you should never see. It’s easy to be against an opinionated compiler having such a feature, but when you watch a prod deployment blow up on a Friday afternoon without an easy option to rollback AND hours later you find the bug after you were stalled by dead code, it changes you. Then… then you start to appreciate opinionated features like this one. 🫡

    • m_f@midwest.social
      ·
      1 year ago

      That's 👏 what 👏 CI 👏 is 👏 for

      Warn in dev, enforce stuff like this in CI and block PRs that don't pass. Go is just being silly here, which is not surprising given that Rob Pike said

      Syntax highlighting is juvenile. When I was a child, I was taught arithmetic using colored rods. I grew up and today I use monochromatic numerals.

      The Go developers need to get over themselves.

      • WhyEssEff [she/her]
        ·
        1 year ago

        reading my code after being up for 18 hours and having my eyes glaze over trying to parse the structure of my monochromatic code but then I remember Rob Pike said syntax highlighting is juvenile so I throw my head against that wall for another 3 hours

        • WhyEssEff [she/her]
          ·
          edit-2
          1 year ago

          Prescription glasses are juvenile. When I was a child, I was prescribed visual aid to help my nearsightedness. I grew up and today I raw-dog the road.

      • FlumPHP@programming.dev
        ·
        1 year ago

        What's a situation where you need an unused variable? I'm onboard with go and goland being a bit aggressive with this type of thing, but I can't think of the case where I need to be able to commit an unused variable.

        • m_f@midwest.social
          ·
          1 year ago

          You probably wouldn't be committing this, unless you're backing up a heavily WIP branch. The issue is that if you're developing locally and need to make a temporary change, you might comment something out, which then requires commenting another now-unused variable, which then requires commenting out yet another variable, and so on. Go isn't helping you here, it's wasting your time for no good reason. Just emit a warning and allow CI to be configured to reject warnings.

        • hare_ware@pawb.social
          ·
          1 year ago

          I will need it two minutes tops. If I don't use it by then, I'll delete it, especially if it gives a warning like Rust does. But this? It just gets in the way.

        • jormaig@programming.dev
          ·
          1 year ago

          Have you looked at the post? Use case: you are testing something or playing around and you want to try something. That's supper common

      • spookedbyroaches@lemm.ee
        ·
        1 year ago

        I agree that golang is being dumb when you don't even have the option to tell it that this is a testing env or something. But the thing about syntax highlighting is not the same. One is about handholding the developer so much that it makes it even more difficult to develop, and the other is a completely optional feature that is so uselful and non intrusive that even wizardly editors like emacs use it.

    • Urik@lemmy.ca
      ·
      edit-2
      1 year ago

      That's a problem with your workplace, not the language nor OP.
      You could have a build setting for personal development where unused variables are not checked, and then a build setting for your CI system that will look for them. It gives you freedom to develop the way you want without being annoyed when you remove something just to test something, but will not merge your PR unless the stricter rules are met.

      • LittleLordLimerick@lemm.ee
        ·
        1 year ago

        Why in the world would you want to develop something that doesn't follow the coding rules required by your org, just so you can go back and fix everything before submitting a PR? That's just extra work.

      • CodeBlooded@programming.dev
        ·
        1 year ago

        I concur, it is a problem with that workplace. (In this case, OP is just sharing a funny meme. I wouldn’t suggest this meme means they’re a problem. I could have made this meme and I love the feature.)

        Developing on a team at a company is like the “Wild West.” What’s considered to be acceptable will not only vary from workplace to workplace, but it can also fluctuate as developers and managers come and Go. Each of them have their own unique personality with their own outlook on what “quality” code looks like. (And many of them do not care about code quality whatsoever. They just need to survive 1-2 years there, make management happy with speedy deliveries, and then they can move on to the next company with a 30% pay bump.)

        Having experienced working with developers who frequently filled with code base with unused code while having no control over who will leave or join as a contributor to the code base, I think features like this make for a more sane development experience when you’re developing with a team of seemingly random people that you never personally invited to contribute to the code base.

        will not merge your PR unless the stricter rules are met.

        This doesn’t fly when you work in big corporate and the boss doesn’t care about the code meeting stricter rules. “A working prototype? No it’s not- that’s an MVP! Deploy it to production now and move onto the next project!

  • Marxism-Fennekinism@lemmy.ml
    ·
    edit-2
    1 year ago

    Sometimes I think Go was specifically made for Google to dictate its own preferences on the rest of us like some kind of power play. It enforces one single style of programming too much.

    • space_comrade [he/him]
      ·
      1 year ago

      From what I've heard from Google employees Google is really stringent with their coding standards and they usually limit what you can do with the language. Like for C++ they don't even use half the fancy features C++ offers you because it's hard to reason about them.

      I guess that policy makes sense but I feel like it takes out all the fun out of the job.

      • Sloogs@lemmy.dbzer0.com
        ·
        edit-2
        1 year ago

        Just about any place I know that uses C++ also does that with C++ so that's nothing unusual for C++ specifically. It's too big of a language to reason about very well if you don't, so you've gotta find a subset that works.

        • skeletorsass [she/her]
          ·
          1 year ago

          Too many patterns. If you do not do this every author will have a different use of the language and you will have to read a book of documentation each time you change files.

    • philm@programming.dev
      ·
      1 year ago

      Is this a hard error? Like it doesn't compile at all?

      Isn't there something like #[allow(unused)] in Rust you can put over the declaration?

      • Nato Boram@lemm.ee
        ·
        1 year ago

        "Other people" are what's wrong with me. People don't use linters/formatters/type annotations when it's optional and produce dogshite code as a result. Having the compiler itself enforce some level of human decency is a godsend.