It’s by amount of pull requests, so the length of class names and other Java boilerplate doesn’t count.

And even more, the Lemmy codebase doesn’t really have any important developers besides the two main devs: https://github.com/LemmyNet/lemmy/graphs/contributors.

Even looking at the contributions to something like Mbin, which has been around for much shorter, you already see 6 people with more than 50 commits, while Lemmy has one

https://github.com/MbinOrg/mbin/graphs/contributors

“I’m right, and if anyone disagrees, it’s because they’re brainwashed”

There’s literally no possible way to argue against this type of logic.

Irrelevant

fmab is another regular anime that’s overshilled.

Very impressive! The only thing I can remember well are places.

Null is terrible.

A lot of languages have it available as a valid return value for most things, implicitly. This also means you have to do extra checking or something like this will blow up with an exception:

// java example
// can throw exception
String address = person.getAddress().toUpperCase();

// safe
String address = "";
if (person.getAddress() != null) {
    person.getAddress().toUpperCase();
}

There are a ton of solutions out there. Many languages have added null-coalescing and null-conditional operators – which are a shorthand for things like the above solutions. Some languages have removed the implicit nulls (like Kotlin), requiring them to be explicitly marked in their type. Some languages have a wrapper around nullable values, an Option type. Some languages remove null entirely from the language (I believe Rust falls into this, using an option type in place of).

Not having null isn’t particularly common yet, and isn’t something languages can just change due to breaking backwards compatibility. However, languages have been adding features over time to make nulls less painful, and most have some subset of the above as options to help.

I do think Option types are fantastic solutions, making you deal with the issue that a none/empty type can exist in a particular place. Java has had them for basically 10 years now (since Java 8).

// optional example

Class Person {
    private String address;
    
    //prefer this if a null could ever be returned
    public Optional getAddress() {
        return Optional.ofNullable(address);
    }
    
    // not this
    public String getAddress() {
        return address;
    }

When consuming, it makes you have to handle the null case, which you can do a variety of ways.

// set a default
String address = person.getAddress().orElse("default value");

// explicitly throw an exception instead of an implicit NullPointerException as before
String address = person.getAddress().orElseThrow(SomeException::new);

// use in a closure only if it exists
person.getAddress().ifPresent(addr -> logger.debug("Address {}", addr));

// first example, map to modify, and returning default if no value
String address = person.getAddress().map(String::toUpperCase).orElse("");

i guess. i would think there are better avenues looking for devs though

Some things that seem hard to argue with:

• A mod panel with things like ‘add moderator’ (maybe this could be attached to the new moderator view?)
• Targeted reports (choose who receives it; admin/moderator)
• Moderation actions on jerboa
• Moderator edits. There’s a fine line here and I can understand why you wouldn’t want total edit capabilities but it’d be nice to at least be able to do things like mark as nsfw and add content warnings. This sort of feature should also probably target megathreads
• Private communities (I know local only communities are in the works but there’s a whole mess of other criteria that would be useful)

My own personal wishlist:

• Karma requirements
• First class wikis
• Hashtags (I actually think a super simple stopgap solution here is to just have them link to the appropriate search page)
• Flairs

There’s some other stuff that I have seen PRs for and I do understand y’all are working hard. I appreciate the work you’ve done so far and the communities you’ve helped build. The Internet is undoubtedly a better place for it.

The ones on the Sublinks roadmap are interesting, for instance the warning system: https://github.com/orgs/sublinks/projects/1/views/7

Create a way to create a warning system for users. For example, a user gets a warning for posting a broken link multiple times. We don’t want to ban them for that. Or a admin gives a user a Warning with a reason. Create a rules system for auto actions like banning for some time or forever. Consider adding types of warnings. This should also track bans from communities for admin-level auto actions. The profile page shows strikes similar to Mastodon for Mods/Admins only and the user that owns the profile. Examples, warnings in each community, and bans. Rules will be applied to counts of warning types or total warnings over time. 3 warnings within a month is a ban for a month, for example.

There was also this list from a few months ago: https://discuss.online/post/12787?scrollToComments=true