• Kogasa@programming.dev
    link
    fedilink
    arrow-up
    80
    arrow-down
    2
    ·
    1 year ago

    People ITT hating on null coalescing operators need to touch grass. Null coalescing and null conditional (string?.Trim()) are immensely useful and quite readable. One only has to be remotely conscious of edge cases where they can impair readability, which is true of every syntax feature

    • ferralcat@monyet.cc
      link
      fedilink
      arrow-up
      9
      arrow-down
      23
      ·
      1 year ago

      Languages with null in them at all anymore just irk me. It’s 2023. Why are we still giving ourselves footguns.

          • Feathercrown@lemmy.world
            link
            fedilink
            English
            arrow-up
            1
            ·
            9 months ago

            Oh yeah I forgot, first you have to make a blog post, then a devlog, then review the top 10 best features of JS es6 (9 years after it was released…). Then shitpost on social media network for the other half of the week, and boom! You’re officially a Master Programmer!

      • merthyr1831@lemmy.world
        link
        fedilink
        arrow-up
        16
        arrow-down
        1
        ·
        edit-2
        1 year ago

        Because languages need to be able to handle the very common edge cases where data sources don’t return complete data.

        Adding null coalescing to a null-safe language (like dart) is so much easier to read and infer the risk of handling null than older languages that just panic the moment null is introduced unexpectedly.

        • itslilith@lemmy.blahaj.zone
          link
          fedilink
          arrow-up
          7
          arrow-down
          1
          ·
          1 year ago

          For old languages, null coalescing is a great thing for readability. But in general null is a bad concept, and I don’t see a reason why new languages should use it. That, of course, doesn’t change the fact that we need to deal with the nulls we already have.

          • wizardbeard@lemmy.dbzer0.com
            link
            fedilink
            English
            arrow-up
            7
            arrow-down
            1
            ·
            1 year ago

            How are we supposed to deal with null values though? It’s an important concept that we can’t eliminate without losing information and context about our data.

            0 and “” (empty string/char) are very often not equivalent to null in my use cases and mean different things than it when I encounter them.

            You could use special arbitrary values to indicate invalid data, but at that point you’re just doing null with extra steps right?

            I’m really lost as to how the concept isn’t neccessary.

            • dukk@programming.dev
              link
              fedilink
              arrow-up
              5
              ·
              edit-2
              1 year ago

              I’ll point to how many functional languages handle it. You create a type Maybe a, where a can be whatever type you wish. The maybe type can either be Just x or Nothing, where x is a value of type a (usually the result). You can’t access the x value through Maybe: if you want to get the value inside the Maybe, you’ll have to handle both a case where we have a value(Just x) and don’t(Nothing). Alternatively, you could just pass this value through, “assuming” you have a value throughout, and return the result in another Maybe, where you’ll either return the result through a Just or a Nothing. These are just some ways we can use Maybe types to completely replace nulls. The biggest benefit is that it forces you to handle the case where Maybe is Nothing: with null, it’s easy to forget. Even in languages like Zig, the Maybe type is present, just hiding under a different guise.

              If this explanation didn’t really make sense, that’s fine, perhaps the Rust Book can explain it better. If you’re willing to get your hands dirty with a little bit of Rust, I find this guide to also be quite nice.

              TLDR: The Maybe monad is a much better alternative to nulls.

              • Feathercrown@lemmy.world
                link
                fedilink
                English
                arrow-up
                4
                ·
                1 year ago

                Isn’t a Maybe enum equivalent to just using a return value of, for example, int | null with type warnings?

                • itslilith@lemmy.blahaj.zone
                  link
                  fedilink
                  arrow-up
                  2
                  ·
                  1 year ago

                  Not quite, because the Maybe enum is neither int nor null, but it’s own, third thing. So before you can do any operations with the return value, you need to handle both cases that could occur

            • eeleech@lemm.ee
              link
              fedilink
              arrow-up
              3
              ·
              1 year ago

              One alternative are monadic types like result or maybe, that can contain either a value or an error/no value.

            • itslilith@lemmy.blahaj.zone
              link
              fedilink
              arrow-up
              2
              ·
              1 year ago

              you could take a look at what Rust is doing with the Option enum. Superficially it looks similar to using null, but it actually accomplishes something very different.

              A function that classically would return a value, say an int, but sometimes returns null instead, becomes a function that returns an Option. This forces explicit handling of the two cases, namely Some(value) or None. This way, it is next to impossible to try to do an operation on a value that does not exist.

        • AVincentInSpace@pawb.social
          link
          fedilink
          English
          arrow-up
          3
          ·
          edit-2
          1 year ago

          Who said anything about panicking the minute we encounter incomplete data? Just do what Rust does and, instead of having all types be able to be null, statically enforce that all variables have an initialized value and have a value have a separate type Option<T> which can either be Some(T) or None, and have the compiler not let you access the value inside unless you write code to handle the None case. There are standard library helper functions for common operations like null coalescing and, as you say, panicking when you encounter a null, but you have to explicitly tell the compiler you want to do that by calling myOption.unwrap()

          What makes this really cool is that you can have an Option<Option<T>> where Some(None) is not the same as None, so an iterator that signals end of list by returning None can have None elements in it.

          Say what you will about the functional programming people but they were spot on with this one. Having an Option monad in place of the ability for null is absolutely the way to go. I’d say it’s the future but Lisp and APL had this figured out in the 60s

      • Kogasa@programming.dev
        link
        fedilink
        arrow-up
        3
        ·
        1 year ago

        Because you can turn null into an Option monad with a small amount of syntax sugar and static analysis

  • PoastRotato@lemmy.world
    link
    fedilink
    arrow-up
    63
    arrow-down
    1
    ·
    1 year ago

    My coworker flips his shit every time I include a ternary operator in a PR. He also insists on refactoring any block of code longer than two lines into its own function, even when it’s only used once.

    He is not well liked.

    • bort@feddit.de
      link
      fedilink
      arrow-up
      34
      ·
      1 year ago

      He also insists on refactoring any block of code longer than two lines into its own function

      Thanks, uncle Bob.

      • qevlarr@lemmy.world
        link
        fedilink
        arrow-up
        20
        arrow-down
        2
        ·
        edit-2
        1 year ago

        His advice is great for newer programmers. They are taken literally by newer programmers, but the goal is not to force the dogma onto everyone. Maybe that should be more clear before the new people make a fool of themselves. They’ll learn why or how to apply these rules once they get more experience.

        I know the episode you’re referring to and the important part is to realize you can use functions names/signatures to convey and structure information about your code, not just as a way to reuse code. This is often misunderstood by newer programmers, self-taught programmers. Your code should be easy to understand so it’s up to us to make it well structured. Functions aren’t only to avoid duplicate code

    • SpicyLizards@reddthat.com
      link
      fedilink
      arrow-up
      17
      arrow-down
      2
      ·
      1 year ago

      Sounds delightful. I’m sure that nothing is explained at length repeatedly in a 35 minute meeting that could have been a message

    • wizardbeard@lemmy.dbzer0.com
      link
      fedilink
      English
      arrow-up
      3
      ·
      1 year ago

      Sounds like they learned programming from heavily object oriented languages.

      As far as ternary operators go, I personally find them less readable than the longer if else format, but with any reasonably modern IDE or git setup that should be just a simple pass of an auto-formatting tool to convert them to the project/team standard. No need for any team friction. That should be automatically handled before it goes to review.

      I’m not in a position with a PR process or anything like that (I’m a glorified scripter in over his head where we need a dev team for internal tools) but I struggle with over reliance on functions as well.

      To keep from going overboard I always try to evaluate how often the block of code will see re-use (want to eliminate copy/paste and the footgun of forgetting to update a copy somewhere), how useful it would be to maintainers to have that section abstracted away into a black box (so you only have to worry about the part of the code that’s not working instead of the whole damn thing when something breaks), and how likely that block of code may need to be completely replaced later (if it’s separated out into a function, it’s a discrete chunk where we only have to maintain the same input and output formatting and ideally the rest of the program just werks).

  • DudeDudenson@lemmings.world
    link
    fedilink
    arrow-up
    71
    arrow-down
    21
    ·
    1 year ago

    And no one on his team ever understood his code.

    Sometimes being declarative is better than being “smart”

    • PixxlMan@lemmy.world
      link
      fedilink
      arrow-up
      46
      arrow-down
      1
      ·
      1 year ago

      The last panel is infinitely more readable than parsing the whole chunk of logic above. Maybe you’re just not used to this language’s (I think this meme used C#) null operators.

    • herrvogel@lemmy.world
      link
      fedilink
      arrow-up
      36
      arrow-down
      4
      ·
      1 year ago

      Sure, if the rest of the team is first semester CS students doing their first group project. This is not an obscure 1337 h4x0r trick only known to programming gods writing COBOL code inside banking mainframes, it’s a simple operator.

    • merthyr1831@lemmy.world
      link
      fedilink
      arrow-up
      29
      arrow-down
      1
      ·
      1 year ago

      Sure, but null coalescing is a pretty common feature in modern languages. Once you know what ?? means you can apply it to a whole host of languages.

    • KairuByte@lemmy.dbzer0.com
      link
      fedilink
      arrow-up
      26
      arrow-down
      3
      ·
      1 year ago

      I’m confused on how this is difficult to understand. Put aside the fact that it’s just a regular operator that… I mean virtually everyone should know, how hard is it to google “what does ?? mean in [language]” which has the added benefit of learning a new operator that can clean up your code?

      • DonnerWolfBach@feddit.de
        link
        fedilink
        arrow-up
        6
        arrow-down
        2
        ·
        1 year ago

        Well yeah but imagine you had to do that on most lines of the code? It would become very distracting imho. If you are in a team with people that have a lot experience and or will learn more anyway this is fine. But if you are in a team with not very good programmers which “will never learn” because they have other stuff to do, you should be careful when using code like this. Though I would prefer in the former of course.

        • KairuByte@lemmy.dbzer0.com
          link
          fedilink
          arrow-up
          8
          arrow-down
          3
          ·
          1 year ago

          Honestly, and I mean this sincerely, if you’re on a team where the nullable coalesce is going to be confusing after the first handful of times encountered… look for a new job. It doesn’t bode well for their ability to do their jobs.

          This is like the guy at Walmart who needs hand holding each time they clean a machine, it’s a problem waiting to happen.

          • Zangoose@lemmy.world
            link
            fedilink
            English
            arrow-up
            2
            ·
            edit-2
            1 year ago

            Imo it’s context dependent. Obligatory “I’m only a college student/intern” out of the way.

            Whenever I’m working with a project with multiple languages (e.g. split frontend+backend, different connected services, etc.) operators like that can get blurry when they aren’t consistent between lancuages. Especially when one of those languages doesn’t have runtime type enforcement or has weird boolean behavior (looking at you JS/TS) which can lead to unintended behavior

            If everyone on the project is only working with that language, then your point is probably pretty close to the mark.

      • DudeDudenson@lemmings.world
        link
        fedilink
        arrow-up
        6
        arrow-down
        6
        ·
        1 year ago

        If condition then this else that vs this ?? that

        Which option do you think requires less time for a person to identify and understand?

        Sure if it’s just your own code do whatever comes natural to you but there’s a reason we don’t use these kind of logical operators in day to day speech is my point.

        Ive been a backend dev for 2 years now and I’ve never come across the ?? operator and every time I come across a ternary operator I have to Google in what order comes what.

        Not saying it doesn’t make the code more concise and less “noisy” but sometimes a simple if else statement just makes the code easier to mantain

        • KairuByte@lemmy.dbzer0.com
          link
          fedilink
          arrow-up
          8
          arrow-down
          1
          ·
          1 year ago

          It’s easier to mess up return a != null ? a : b than it is return a ?? b, and operators work from left to right.

    • saumanahaii@lemm.ee
      link
      fedilink
      arrow-up
      11
      ·
      1 year ago

      This is why I favor 3. It’s fairly concise while not being all that obscure. And even if you’re not 100% on that syntax, context provides decent intuition about what it does.

    • RagingRobot@lemmy.world
      link
      fedilink
      arrow-up
      5
      ·
      edit-2
      1 year ago

      This is why I usually don’t comment on stuff like this in PRs. If it’s readable and easy to understand it doesn’t need more abstractions. Even if it’s less code. What’s it save like a few bytes? That’s not as useful as the whole team instantly knowing how the code works when they see it lol

      I will say though if a jr dev came upon the last code they would just look it up and learn something so that’s a total valid path too. Just depends on your codebase and how your team works. I think it usually ends up being a mix with larger teams.

      • KairuByte@lemmy.dbzer0.com
        link
        fedilink
        arrow-up
        7
        ·
        1 year ago

        There’s more to it imho. The first three are more prone to mistakes than the last. You are much less likely to accidentally alter the logic intended in a simple null coalesce than you are in if statements.

        • RagingRobot@lemmy.world
          link
          fedilink
          arrow-up
          1
          arrow-down
          1
          ·
          1 year ago

          That’s fair but if you had proper test coverage there wouldn’t be much risk. Who has that though? Lol

          • KairuByte@lemmy.dbzer0.com
            link
            fedilink
            arrow-up
            4
            ·
            1 year ago

            None of my projects had time for reliable testing unfortunately. It was always “next sprint” or “when we have time” which never really came to fruition.

      • jhulten
        link
        fedilink
        arrow-up
        1
        arrow-down
        1
        ·
        1 year ago

        Yeah, I think there is a tipping point between terse and magic. I might grimace a little at the first one, have no comment on the middle two, and definitely comment on the last one. Wrote code like the person troubleshooting it is on-call, mildly hung over, and it’s 3am.

  • zero_gravitas@aussie.zone
    link
    fedilink
    English
    arrow-up
    49
    ·
    edit-2
    1 year ago

    Ruby:

    a || b

    (no return as last line is returned implicitly, no semicolon)

    EDIT: As pointed out in the comments, this is not strictly equivalent, as it will return b if a is false as well as if it’s nil (these are the only two falsy values in Ruby).

    • stebo02@sopuli.xyz
      link
      fedilink
      arrow-up
      22
      arrow-down
      1
      ·
      1 year ago

      Python:

      return a or b

      i like it because it reads like a sentence so it somewhat makes sense

      and you can make it more comprehensive if you want to:

      return a if a is not None else b

      • alehc@lemmy.world
        link
        fedilink
        arrow-up
        8
        arrow-down
        1
        ·
        1 year ago

        I personally dislike this because when you read “or” you expect some boolean result not a random object :/

      • rwhitisissle@lemmy.ml
        link
        fedilink
        arrow-up
        1
        arrow-down
        1
        ·
        1 year ago

        For newer python people, they see return a or b and typically think it returns a boolean if either is True. Nope. Returns a if a is truthy and then checks if b is truthy. If neither are truthy, it returns b.

        • Arthur Besse@lemmy.ml
          link
          fedilink
          arrow-up
          6
          ·
          edit-2
          1 year ago

          Returns a if a is truthy and then checks if b is truthy. If neither are truthy, it returns b.

          Not quite. If a is not truthy, then the expression a or b will always return b.

          So, there is never any reason to check the truthiness of b.

          you can paste this in your repl to confirm it does not.
          class C:
           def __repr__(self): return [k for k, v in globals().items() if v is self][0]
           def __bool__(self):
            print(f"{self}.__bool__() was called")
            return False
          
          a, b = C(), C()
          print(f"result: {a or b}")
          
          output
          a.__bool__() was called
          result: b
          
    • idunnololz@lemmy.world
      link
      fedilink
      arrow-up
      11
      ·
      1 year ago

      This doesn’t work for booleans because false is not null but also not truthy. One of things I hate about ruby is that it doesn’t have a native null coalescing operator.

      • zero_gravitas@aussie.zone
        link
        fedilink
        English
        arrow-up
        1
        ·
        1 year ago

        Yeah, you’re quite correct, it’s not exactly equivalent, I just went on auto-pilot because it’s used so much for that purpose 🤖

        It’s much closer to being a true null-coalescing operator than ‘OR’ operators in other languages though, because there’s only two values that are falsy in Ruby: nil and false. Some other languages treat 0 and "" (and no doubt other things), as falsy. So this is probably the reason Ruby has never added a true null-coalescing operator, there’s just much fewer cases where there’s a difference.

        It’s going to drive me mad now I’ve seen it, though 😆 That’s usually the case with language features, though, you don’t know what you’re missing until you see it in some other language!

    • palordrolap@kbin.social
      link
      fedilink
      arrow-up
      7
      ·
      edit-2
      1 year ago

      Perl has both $a || $b and $a // $b.

      The || version is older and has the value of $b if $a is any false value including undef (which is pretty much Perl’s null/nil).

      The // version has the value of $b iff $a is undef. Other “false” values carry through.

      Ruby took both “no return required” and “no final semicolon required” from Perl (if not a few other things), I think, but it seems that // was Perl later borrowing Ruby’s || semantics. Interesting.

      i.e. 0 || 1 is 1 in Perl but 0 in Ruby. Perl can 0 // 1 instead if the 0, which is a defined value, needs to pass through.

  • Knusper@feddit.de
    link
    fedilink
    arrow-up
    34
    arrow-down
    2
    ·
    1 year ago

    I enjoy this:

    return a.or(b);
    

    But yeah, that requires an Option type rather than null pointers…

    • mea_rah@lemmy.world
      link
      fedilink
      arrow-up
      6
      ·
      1 year ago

      Is that Rust? Assuming a is an Option (which would be close approximation of OP’s nullable type) and assuming b is not null, then this would be closer to the original idea:

      a.unwrap_or(b)
      

      It returns value of a if it’s not None rather than Option.

      • Knusper@feddit.de
        link
        fedilink
        arrow-up
        1
        ·
        1 year ago

        Ah, true. Thanks.

        Theoretically, it was supposed to be pseudo-code, secretly inspired by Rust, but I did get that one mixed up.

        And I am actually even a fan of the word unwrap there, because it follows a schema and you can have your IDE auto-complete all the things you can do with an Option.
        In many of these other languages, you just get weird collections of symbols which you basically have to memorize and which only cover rather specific uses.

    • FierySpectre@lemmy.world
      link
      fedilink
      arrow-up
      1
      ·
      1 year ago

      I tried picking up rust for the AoC, but any program I wrote ended up unreadable cuz of this unwrap_or. It just allows too much chaining. Then again other options for chaining operations aren’t much better, like match. Idk what I’m doing wrong or if rust never was meant to be readable.

        • Username@feddit.de
          link
          fedilink
          arrow-up
          5
          ·
          edit-2
          1 year ago

          I wanted to ask why it’s bad, what did you change?

          Btw. the example function get_default is badly chosen, because unwrap_or_default exists.

          • xor@lemmy.blahaj.zone
            link
            fedilink
            English
            arrow-up
            11
            ·
            1 year ago

            The original example was doing the unwrap_within an iterator doing some string parsing, so there was a lot of unrelated boilerplate around the actual unwrapping that made it really unclear, as well as usual unwrap_or_else to produce a constant value

            Ehhh, I was more using get_default as a placeholder for some function, as opposed to representing Default::default for the inner type specifically. I think it should be alright since only people familiar with rust would know about the default trait anyway. I did consider adding an unwrap_or_default example, but thought it was getting a bit off topic at that point.

      • Flipper@feddit.de
        link
        fedilink
        arrow-up
        11
        ·
        1 year ago

        Other languages: if a is null return b.

        Rust: here is an array of strings, we are going to parse the array to numbers. If that conversion fails we handle the exception and return the minimum integer value. We then save the result in a new vector. We also print it.

        I like rust, but I hate the example too. It’s needlessly complex. Should have just been a.unwrap_or(b).

        • mea_rah@lemmy.world
          link
          fedilink
          arrow-up
          3
          ·
          edit-2
          1 year ago

          The example even used unwrap_or_else where they should use unwrap_or. Then it uses std::i64::MIN as fallback value where they could use something like 0 that would be a better example and honestly make more sense there.

          let parsed_numbers = ["1", "not a number", "3"]
              .iter()
              .map(|n| n.parse().unwrap_or(0))
              .collect();
          
          // prints "[1, 0, 3]"
          println!("{:?}", parsed_numbers);
          

          Even without trimming this to something less convoluted, the same functionality (with different fallback value) could be written in more readable form.

          Obviously in the context of the page something like this would make way more sense:

          maybe_number.unwrap_or(0)
          

          Or perhaps more idiomatic version of the above:

          maybe_number.unwrap_or_default()
          
      • hansl@lemmy.world
        link
        fedilink
        arrow-up
        3
        ·
        1 year ago

        The Option type would have been a better example, and make it slightly less complicated.

        Option is an enum with two variants; None and Some(T). You can chain Options with operations, describing a Monad chain, which is kind of what this meme represent.

  • drolex@sopuli.xyz
    link
    fedilink
    arrow-up
    17
    arrow-down
    1
    ·
    1 year ago

    Loads of beginners in this thread. Here’s how it’s done in the industry.

    The code:

    return a;

    The test:

    a = rand()%100+1;

    It works, boss.

  • bamboo@lemm.ee
    link
    fedilink
    arrow-up
    17
    arrow-down
    1
    ·
    1 year ago

    I’m learning swift and I actually just discovered ?? today. Am I missing out in other languages?

  • maegul (he/they)@lemmy.ml
    link
    fedilink
    English
    arrow-up
    13
    arrow-down
    1
    ·
    edit-2
    1 year ago

    Python, checking in …

    return (a or b)
    

    Parentheses aren’t necessary, I just prefer them for readability.

    See python documentation on boolean operators for reference. Short story is a or b is an expression that evaluates to a if a is “truthy” else b. “Falsy” is empty strings/containers, 0 and None.

    • murtaza64@programming.dev
      link
      fedilink
      arrow-up
      3
      ·
      edit-2
      1 year ago

      You don’t need the and right? Can’t it just be return a or b

      This doesn’t work if a is falsy non-null actually

      • cerement@slrpnk.net
        link
        fedilink
        arrow-up
        1
        ·
        1 year ago

        it’s just return a and b or c is the closest Lua has to a ternary operator, but yes, for the above you could shorten it to return a or b (“or returns the first argument if true, otherwise second argument is returned”)

  • ABC123itsEASY@lemmy.world
    link
    fedilink
    arrow-up
    12
    arrow-down
    2
    ·
    1 year ago

    Yea uh is this actually equivalent? In all of those other cases you’re checking if a is null and in the last case my understanding is it is checking to see if a is falsely. In the case that a is 0, or undefined, or an empty array or any other kind of non null falsey value, then the behavior would be different.