- cross-posted to:
- fediverse@lemmy.ml
- cross-posted to:
- fediverse@lemmy.ml
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.
You must log in or register to comment.
a missed opportunity to name it Jemmy
I’m just here for the joke
EDIT: sentence structure
deleted by creator
an alternative Java-based backend
kill it with fire
an alternative Java-based backend to Lemmy’s Rust-based one
Going from a modern well-designed language to an old-and-busted, kitschy, memory-hogging, bloated language. This is literally a step backwards.
Rust, Go… hell, even Ruby-on-Rails or whatever Python is offering nowadays would be a better choice.
Or C#, it’s literally “Java, but good”.
The only time I would choose Java for a new project is if I had a hard dependency on something that only works with Java…
Nah, Java is alright. All the old complicated “enterprise” community and frameworks gave it a bad reputation. It was designed to be an easier, less bloated C++ (in terms of features/programming paradigms). It’s also executed fairly efficiently. Last time I checked, the same program written in C would typically take 2x the time to complete in Java; whereas it would take 200x the time to complete in Python. Here’s some recent benchmarks: https://benchmarksgame-team.pages.debian.net/benchmarksgame/fastest/python3-java.html
I haven’t had a chance to try Rust yet, but want to. Interestingly, Rust scores poorly on source-code complexity: https://benchmarksgame-team.pages.debian.net/benchmarksgame/how-programs-are-measured.html#source-code
Next step, is to remake Lemmy in JavaScript. Pure JavaScript, no typescript, only express, nothing else
rewrite it in perl with a flat file database.
Too bad it’s java
I see you woke up and chose violence.
I just self host and avoid Java like the plague due to how annoying it is to manage
3 billion devices can’t be wrong…
One dude writing a Java server app, compared to Google writing an operating system, pretty equal comparison lol
There’s nothing wrong with java
There is nothing inherently wrong with Java I would speculate, but it can be a royal pain in the ass to manage if you just need one application to work.
I know the basics of the language, but from what I have seen managing it, I don’t like it. Just from being in security, I constantly hit barriers with devs because of versioning issues. There is always some ancient app running on a version of Java that can’t be updated, for whatever reason. Version management is always a pain, but with Java? Goddamn.
I admit ignorance about the details of Java and how awesome it is for job security. There is no way in hell I could even debate anyone who has watched a single video on YouTube about Java. However, from what I have seen, it either works great or it fails explosively with billions of randomly allocated threads attempting to suck memory from every other server within 50 miles.
If it’s awesome to code with, cool. I am just a little salty from my experiences, as you can tell.
Legacy Java software is a massive pain in the ass. No arguments there. I’ve been migrating an app from Java 11->17 for the last 2 months and it’s a versioning mess. So many libraries deprecated and removed that don’t have easy replacements.
It’s great because things don’t break when they’re running, but the problem is upgrading.
Version management does seem to have become better with the last couple versions
(Confirmation bias, ENGAGE!)
We have a few of those projects coming up as well. Thankfully, I just get to poke at the apps to make sure the issues are resolved.
But yeah, one of my examples of rogue threads is a coding issue, not inherently a language issue. Even log4j issues can’t be completely blamed on Java “The Language”.
Oh yes there is
Well, it wears down your keyboard.
Lol how about one written in NodeJS? 😆
I bet there are forks already. NodeJS is quite popular really.
Brainfuck would be my choice if we are making things harder for ourselves.
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. 😭
Yup. Welcome to the world of Java where such things are not only silly but encouraged.
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.
Here’s an example:
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:
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.
Yeah but that’s more on the coder. Like you indirectly say, they could just as well have had a single listener for community update events, since they all share the data structure for such events (I would assume, haven’t looked around too much).
And to me as a professional java coder, I will say it’s just not complex. The scaffolding you mentally discard after a week of working with Java unless you’re looking for something related to do the scaffolding - and then it’s cool that it’s all explicitly there, this has helped me countless times in my career and is one of the big strengths of such verbose languages - and beyond that and some design choices I would not have made that way related to naming and organization, there’s not much code there to begin with. In modern Java you might just do this in a lambda supplied in the place where you hook the events, anyways.
I find that Java is overly Verbose, but it’s much better than the alternative of underly verbose.
Java really follows the single class for single functionality principle, so in theory it makes sense to have these located in different classes. It should probably be abstracted to a shared method, but it shouldn’t be in the same file.
At least to me this looks like simplicity, but I’ve been writing Java in some capacity since 2012.
It’s not just the visible complexity in this one file. The point of it is to keep a subscriber count in sync, but you have that code I referenced above, plus:
LinkPersonCommunityCreatedEventLinkPersonCommunityDeletedEventLinkPersonCommunityCreatedPublisherLinkPersonCommunityDeletedPublisherAnd then there are things like
LinkPersonCommunityUpdated[Event/Publisher]which don’t even seem to be used.This is all boilerplate IMO.
And all of that only (currently) serves keeping that subscriber count up to date.
And then there’s the hidden complexity of how things get wired up with spring.
And after all that it’s still fragile because that event is not tied to object creation:
@Transactional public void addLink(Person person, Community community, LinkPersonCommunityType type) { final LinkPersonCommunity newLink = LinkPersonCommunity.builder().community(community) .person(person).linkType(type).build(); person.getLinkPersonCommunity().add(newLink); community.getLinkPersonCommunity().add(newLink); linkPersonCommunityRepository.save(newLink); linkPersonCommunityCreatedPublisher.publish(newLink); }And there’s some code here:
final Set<LinkPersonCommunity> linkPersonCommunities = new LinkedHashSet<>(); linkPersonCommunities.add(LinkPersonCommunity.builder().community(community).person(person) .linkType(LinkPersonCommunityType.owner).build()); linkPersonCommunities.add(LinkPersonCommunity.builder().community(community).person(person) .linkType(LinkPersonCommunityType.follower).build()); communityService.createCommunity(community); linkPersonCommunityRepository.saveAllAndFlush(linkPersonCommunities);that is able to bypass the community link service and create links in the repository directly, which would presumably not trigger than event.
Maybe there’s a good reason for that, but it sure looks fragile to me.
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.
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. 🤷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.
Its still better than any python project lol
Really? I find python imports to work very similar to cpp in practice.
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 )
I love Java.
I’ve been hearing a lot of good things for a while. Lookin forward to it.
I’m hearing hype from the people making it… dunno why anyone else would have anything positive or negative to say yet
I didn’t know Lemmy was written in Rust.
Lemmy is how I learned about Rust.
This actually makes me want to contribute to lemmy.
Having a frontend rewrite seemed more critical than trying reimplementing the backend in a different language.
Remember, Lemmy had 4 years of development to iron out bugs, and this is essentially promising to make something in months that has a fully compatible backend to support all the third party apps, while adding features on top of what Lemmy has, and with a better front end with better mod tools to boot, with a complete rewrite of everything.
The scope of this project has planned for is already unviable. Suppose that Sublinks does reach feature parity to the current version of Lemmy, congratulations, the backend or mod tools is not something a regular user is going to notice or care about at all, all they will know is that suddenly, there are weird bugs that wasn’t there before, and that causes frustration.
And this project is going to get more developer traction because… Java?
I’d like to be proven wrong, but I’m very sceptical about the success of Sublinks, because it look like a project that was started out of tech arrogance to prove a point than out of a real need, I don’t work in tech, but the general trajectory of these kind of projects is that “enthusiasm from frustration” can only take you so far before the annoyance of dealing with mundane problems piles up, and the project fizzles out and ends with a whimper.
There are some projects that start because of “tech arrogance” as you describe the current situation. MariaDB, Git, LibreOffice are some of the most famous ones, but I’m sure there are more.
But does it have blockchain AI integration?
I like this, I will contribute to this, I think a lot of Java haters in this thread fail to realize just how massive Java is compared to everything else.
Rust might be the latest, hottest, bestest Java killer out there and it might be a completely superior language to Java, doesn’t matter, it’s dwarfed in terms of how many people actually use it for real projects, projects that should run for years and years. Even if Rust is the true Java killer, it’s gonna take a good few more years for it to kill java, measured in decades, there is just way too many projects and critical stuff out there that is running on Java, that means lots of jobs out there for java, still and still more.
This means there are a lot of senior Java programmers out there with lots of years of experience to contribute to this project.
Plus Lemmy itself having alternatives and choices is just a good thing.
Agreed. I mean COBOL is still a thing, and that’s a language that’s been dead for 30+ years.
Languages won’t grow if you ditch them for other ones. There’s lots of reasons to use rust, outside of the size of the project
I think you will find that the biggest reason to use a language is to get paid for it and there Java is very well positioned
That’s the reason for for hire devs yeah, but if you are starting a new project ( especially a community one like lemmy where the profit motive is different) choosing your tech stack is a complex decision
Based on all the other threads and cross posts it just seems like this software is being created because Jason Grim doesn’t like the lemmy devs or their politics. I guess that’s as good of a reason to fork as any. I’m happy with the way lemmy is and how its being created so I have been doing monthly donations to them for its development.
It’s not a fork though. It’s a complete rewrite in another programming language. That’s way more effort than a petty project.
The truth is, this might succeed based on developer reach. I love Rust, but I know it won’t have the reach (yet) that Java can, and more developers mean faster progress.
In the end, between this, Lemmy or another project which may be a fork of either, the success will be due to efforts of everyone involve at every stage. This wouldn’t exist without Lemmy, and Lemmy wouldn’t exist with ActivityPub.
I’m not sure I believe “faster” progress really means anything when two communists are creating a hobby software that isn’t really for business or necessarily targeting growth at all costs.
removed by mod
removed by mod
I guess my username won’t make sense anymore. But it sounds so good that it doesn’t need to make sense.
That’s okay, no one thinks my username makes sense when it absolutely does.
Idk why that reminded me of a very old Minecraft release where there was a bug where squids can actually fly.
Idk if I misremembered that or if it was an actually real thing.
I can’t find the fucking porn on Lemmy, so maybe this is a good thing.
lemm.ee doesn’t block it, so it’s not a problem with your instance. You don’t have to ask how I know
Lemmynsfw
So while there’s plenty of talk in here (even from the core lemmy devs) about how much it makes sense and how much value there is in starting a new project with a different tech stack that includes Java, compared to simply contributing back to the current project that has momentum … and while that’s an interesting and important conversation …
Realistically, developers will make what they want to with what they want to (to a fault IMO, especially within the broader mission of the fediverse, but that’s besides the point). This project will happen, people will contribute and it may succeed.
So, to focus on the positives and what can be made good about this …
It’s great that there’s some sort of settling on a standard here and trying to be a “drop in replacement”. Continued commitments to consistency and interoperability would be awesome. While collaboration may be naturally limited, there’d still definitely be scope for it …
- ideas and designs, obviously
- Database management and optimisation, which is likely a big one.
- On that … AFAICT, SL is using MySQL? Can’t help but wonder (without knowing the technical justifications here) whether it would make much more sense to stick with the same DB unless there’s a good reason for divergence.
- Front ends and the API, another big one but one where the two projects could conceivably work together.
I’m likely being very naive here, but I can see both projects coming under a single umbrella or compact which provide different backends and maybe DB setups or schemas but otherwise share a good amount in design and mission.
However unlikely that is … trying not to fragment the fediverse too much would be awesome and its pleasant to see some dedication here to that end.
