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.

        • Derin@lemmy.beru.coEnglish
          3·
          9 months ago

          What’s annoying about it? Deploying a war to tomcat is one of the easiest things one can do.

          • twistypencil@lemmy.worldEnglish
            92·
            9 months ago

            If you are a Java shop, and you do tomcat, then cool, maybe you’ve worked out the mysteries if Java deployment and managing resources (ahem, memory), and upgrades etc over the life cycle of a project. But most people doing deployment don’t want a one off Java app as a snowflake in their intra, if they can help it because it requires more buy into the ecosystem than you want

    • Corngood@lemmy.mlEnglish
      6310·
      9 months ago

      Browsing the code makes me angry at how bloated Java projects are:

      package com.sublinks.sublinksapi.community.repositories;

import com.sublinks.sublinksapi.community.dto.Community;
import com.sublinks.sublinksapi.community.models.CommunitySearchCriteria;
import com.sublinks.sublinksapi.post.dto.Post;
import com.sublinks.sublinksapi.post.models.PostSearchCriteria;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import java.util.List;

public interface CommunitySearchRepository {

  List<Community> allCommunitiesBySearchCriteria(CommunitySearchCriteria communitySearchCriteria);

}

      Every file is 8 directories deep, has 20 imports, and one SQL statement embedded in a string literal. 😭

      • MeanEYE@lemmy.worldEnglish
        353·
        9 months ago

        Yup. Welcome to the world of Java where such things are not only silly but encouraged.

            • hansl@lemmy.worldEnglish
              102·
              9 months ago

              *Vaguely wave arms towards the few dozens languages that do imports right*

              I don’t mind Java personally, but let’s not pretend that its import syntax and semantics is at the better side of the spectrum here.

              Just look at… Go, Haskell, TypeScript, Rust, even D has a better module system.

              • Carighan Maconar@lemmy.worldEnglish
                4·
                9 months ago

                Isn’t Go just the requivalent of only doing asterisk-imports in Java, just without (and fair enough, Java has 0 need to do that 😂) repeating the import-keyword?

                • hansl@lemmy.worldEnglish
                  41·
                  9 months ago

                  There are multiple things in Go that make it better.

                  But just for giving a few thoughts about Java itself;

                  • being able to import a package and use it as a namespace would already go a long way
                  • being able to import multiple things from a package without listing separate line for each items
                  • not having to go from the root of the whole fucking world to import a package would be great
                  • having the ability to do relative imports to the module I’m writing would be great

                  These are like “module 101” things. Like, you’re right that the IDEs nowadays do most of that, but IDEs also get it wrong (“oh you meant a THAT package instead of that other one”) and reading the code without an IDE is still a thing (code reviews for example) which means the longer the import section (both vertically and horizontally) the harder it is to work with. And if you don’t look at all imports carefully you may miss a bug or a vulnerability.

                  Also, Java is the only language I know of that has such a span on the horizontal. The memes about needing a widescreen monitor for Java is actually not a joke; I never had to scroll horizontally in any other language. To me that’s just insanity.

                  Also, if you’re gonna make it the whole universe as the root of your package structure, we already have DNS and URI/URLs for that. Let me use that!

                  And don’t get me started as only-files-as-packages while simultaneously having maybe-you-have-multiple-root for your code… makes discovery of related files to the one you’re working with very hard. Then of course the over reliance on generated code generating imports that might or might not exist yet because you just cloned your project…

      • Carighan Maconar@lemmy.worldEnglish
        81·
        9 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·
          9 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·
          9 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·
            9 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·
              9 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.

          • Rooki@lemmy.worldEnglish
            52·
            9 months ago

            But you really dont see what the function wants or requires or returns ( except with typehints, but they dont work most of the time and then its not enforced in any way )

            • Derin@lemmy.beru.coEnglish
              5·
              9 months ago

              Larger, modern python projects always use type hints, for this specific reason.

              In the past you had PyDoc, which also scratched that itch.

              Barring that, contributing to a python project is very difficult without an IDE that performs type checks for you (which is unreliable).

              • Rooki@lemmy.worldEnglish
                01·
                9 months ago

                Correct! As i already contributing to a big ass python project at work. We will rewrite a Big Project from python to c# in under 1 month.

                • Derin@lemmy.beru.coEnglish
                  0·
                  9 months ago

                  Just you wait until your developers learn about the var keyword - it’s going to be Python 2.7 PTSD incidents all over again 😂

                  • Rooki@lemmy.worldEnglish
                    01·
                    9 months ago

                    Isnt that already default on all variables? Its like a var(in js)?

    • magic_lobster_party@kbin.social
      202·
      9 months ago

      Who cares? If it works, it works.

      The biggest strength of Java is that many programmers has years or even decades of experience in it.

          • hansl@lemmy.worldEnglish
            2·
            9 months ago

            PHP never went away. Wordpress, Mediawiki, Slack, Facebook, etc etc etc. IMO PHP is likely to have created the most wealth per line of code of all languages, including C (edit: since 2000). It’s completely under the radar.

        • remotelove@lemmy.caEnglish
          53·
          9 months ago

          Same thing with COBOL! So many devs with … Wait. Are any COBOL devs even alive still?

          • Cosmic Cleric@lemmy.worldEnglish
            01·
            9 months ago

            Same thing with COBOL! So many devs with … Wait. Are any COBOL devs even alive still?

            I promise you one thing, those that are still alive are making bank right now.

            • Carighan Maconar@lemmy.worldEnglish
              0·
              9 months ago

              Usually at banks, where they easily earn 2x+ of what I do working in Java. I happen to know one IRL, and their meetings with the boss are funny because it doesn’t really matter what number they put on the table, their boss cannot fire them. They could not replace them and they need 2+ COBOL devs in house.

              • Cosmic Cleric@lemmy.worldEnglish
                01·
                9 months ago

                I happen to know one IRL, and their meetings with the boss are funny because it doesn’t really matter what number they put on the table, their boss cannot fire them. They could not replace them and they need 2+ COBOL devs in house.

                I can concur, I’ve seen the same thing in real life myself. Definitely a blast watching the employee have the power.

      • twistypencil@lemmy.worldEnglish
        52·
        9 months ago

        I care, as someone who self hosts and have been doing so for 22 years. Java has always been the most annoying thing to maintain as a holster, especially on low resourced machines, like my raspi

        • Sentient Loom@sh.itjust.worksEnglish
          143·
          9 months ago

          Java is the first language I learned. I love how structured it is and how it forces you to work within the paradigm. I might never use it again, but it shaped how I think of programming.

          • BURN@lemmy.worldEnglish
            02·
            9 months ago

            That’s why I like Java too. The fact that it’s so strict means I have to think about projects in a certain way and can’t just wing my way through it like Python.