The Threadiverse is growing again, this time offering an effort to build a new Lemmy replacement from scratch, with API compatibility.

Seems like an interesting effort. A developer is building an alternative Java-based backend to Lemmy’s Rust-based one, with the goal of building in a handful of different features. The dev is looking at using this compatibility to migrate their instance over to the new platform, while allowing the community to use their apps of choice.

  • Carighan Maconar@lemmy.worldEnglish
    81·
    6 months ago

    And what’s bad about that? As in, how is the verbosity a negative thing exactly? More so because virtually any tool can be configured to default-collapse these things if for your specific workflow you don’t require the information.

    At the same time, since everything is verbose, you can get very explicit information if you need it.

    • Corngood@lemmy.mlEnglish
      161·
      6 months ago

      Here’s an example:

      https://github.com/sublinks/sublinks-api/blob/main/src/main/java/com/sublinks/sublinksapi/community/listeners/CommunityLinkPersonCommunityCreatedListener.java

      IMO that’s a lot of code (and a whole dedicated file) just to (magically) hook a global event and increase the subscriber count when a link object is added.

      The worst part is that it’s all copy/pasted into a neighbouring file which does the reverse:

      https://github.com/sublinks/sublinks-api/blob/main/src/main/java/com/sublinks/sublinksapi/community/listeners/CommunityLinkPersonCommunityDeletedListener.java

      It’s not the end of the world or anything, I just think good code should surprise you with its simplicity. This surprises me with its complexity.

    • hansl@lemmy.worldEnglish
      41·
      6 months ago

      how is the verbosity a negative thing exactly

      Fun fact, studies have found that the number of bugs in a program is proportional to the number of lines of codes, across languages. More lines of codes, more bugs, even for the same math and edge cases. So a more verbose language tends to have more bugs.

      • Carighan Maconar@lemmy.worldEnglish
        7·
        6 months ago

        Interesting, but did this include web code and code only one person really ever works on?

        Because on the pure backend level, I have observed the reverse over my career. The shorter, the “smarter”, the “cooler” the code, the more buggy it is. Not based on the code itself, but based on the developer inevitably leaving the company at some point. Meaning that what matters all of is a sudden is how verbose, how documented and how explicit the code is, because the bugs come from someone else messing with it as they get to take it over. It’s a legacy problem in a lot of ways.

        Hence me saying that if solo projects are included, they probably tilt this massively as they’ll never really run into this problem. Like say, you just scan github or something. Of course most projects in there are solo, of course the more lines the more room for bugs.
        But in an environment where you’re not solo coding, the issue is not getting the code to run and having it have no programmed bugs, but to be able to have someone else understand what you did and wanted to do in a meaningful amount of time, especially as they have to mutate your code over years and decades. Or maybe it’s just that the bugs no longer are what “matters”, as fixing code bugs is cheap compared to the endless hours wasted from “clever” code being unmaintainable. 🤷

        • kameecoding@lemmy.worldEnglish
          4·
          6 months ago

          I have a similar experience, in that anytime I heard someone hating on the verbosity of Java it was never the good devs the ones who can write a code that’s readable a few months later.