Giver of skulls

Verified icon

  • 0 Posts
  • 15 Comments
Joined 101 years ago
cake
Cake day: June 6th, 1923

help-circle


  • The language selection box is a standard multi-select control, as implemented by your browser. On desktop that means it’s likely a flat list with multiple items you can select, on mobile you’ll probably get a popup with checkboxes. These controls used to be ubiquitous, but given the amount of questions they seem to prompt, I suppose they fell out of favor since mobile phones became more popular.

    Assuming you’re on desktop, the list is controlled like file selection in Windows explorer (and probably others) is controlled. Clicking an item in the list selects just that item. Holding down the control key allows multiple items to be selected. Holding down shift allows selecting a range, starting from an already selected item.

    See this article for some screenshots if this is still unclear. Multi selection will work in other programs as well!

    Unlike Windows Explorer, ctrl+A doesn’t work. To select all, click the first item in the list, scroll all the way down, and shift+click the last item in the list.



  • https://lemmy.ml/c/maliciouscompliance doesn’t exist. You probably meant https://lemmy.ml/c/maliciouscompliance@lemmy.world

    The subscriber count is server-local (only counts the users from your server). I suppose it could theoretically be synchronized to be global, but it’s not implemented right now.

    The source code for the aggregate community statistics can be found here, I believe: up.sql

    create or replace function site_aggregates_activity(i text)
    returns int
    language plpgsql
    as
    $$
    declare
       count_ integer;
    begin
      select count(*) 
      into count_
      from (
        select c.creator_id from comment c
        inner join user_ u on c.creator_id = u.id
        where c.published > ('now'::timestamp - i::interval) 
        and u.local = true
        union
        select p.creator_id from post p
        inner join user_ u on p.creator_id = u.id
        where p.published > ('now'::timestamp - i::interval)
        and u.local = true
      ) a;
      return count_;
    end;
    $$;
    

    Notice the u.local = true, ensuring that only local users get counted in the statistics.





  • My instance has grown to a few hundred megabytes in size for the messages (almost all coming in from other servers) and then there are the files.

    That’s for about 422k entries in the database, so I’m pretty sure all the communities I’m following are the cause. At that point, I don’t think it’d matter if I hosted five people on my server or five thousand; their posts are probably going to end up on my server anyway.

    And besides, I don’t need a long term copy of all that data. I can probably purge data every week to keep the database to a few hundred megabytes or so.

    Going by this post a $12 VPS with 500GB of storage should do just fine for years if you don’t accept too many files. All of Wikipedia is about 20GB of text, but image files will probably be your biggest issue.

    There’s a risk of user rush, but Lemmy’s design allows for manual approval of all user accounts. If you don’t want to run the risk of exceeding your bounds (or dealing with moderation fallout) then only allowing you and your friends would be a perfect middle ground.



  • There’s a cache on other instances that contains (some) posts and comments the instance received previously, but everything is bound to break when fetching new comments and posts fails. I wouldn’t rely on it.

    Lemmy/Mastodon/kbin/other ActivityPub servers are federated rather than fully distributed. That’s where the name Fediverse comes from (it’s not, like some people think, invented by some federal government). That means servers maintain accounts and data, but can interoperate between each other. This is different from, say, BitTorrent, which can operate almost entirely without servers (through the DHT) and still maintain data.

    Lemmy, kbin, Mastodon, and other Fediverse servers work very much in the same way email worked back in the day, when it comes to servers. You can exchange messages between Gmail and Outlook in the same way you can exchange posts between Lemmy and Mastodon, and back when message lists were a thing you could subscribe/post to lists on other servers as well.

    If Gmail dies without notice, you can still read the emails you’ve received for as long as they’re kept on your server (back in the old days of 1-10MB mailboxes that wasn’t very long!) but you can’t do much else with it.

    Lemmy’s local storage isn’t really meant for safeguarding data. It’ll probably keep messages from other servers for some time, but don’t expect to interact with them well, or to recover your account.

    Even in Mastodon, which does support account migration, toots disappear when the original server dies. Moving accounts works by redirecting other instances to the new location, with old toots left at the old place. If a server does after moving, the old toots disappear but the new toots stay up and your followers will automatically follow your new account. If the server dies without moving your account, everything is gone.

    There have been some improvements since the invention of email, though. For example, if an email domain goes down, anyone can register the expired domain and host a new server, pretending to be the people on the old server and receiving mail destined for their now dead email address.

    With (correctly implemented) ActivityPub clients (like Lemmy/kbin/Mastodon), this is impossible without a backup of the database, because every account has a secret key that’s used to verify data (posts, comments, follow requests). So, even if Lemmy.ml goes down and some asshole buys it to send spam from “trusted” accounts, they won’t be able to!

    I don’t think there are fully distributed social networks out there today. Even nostr, a Twitter alternative with a basis in blockchain, has the issue that if a “relay” you used to post content goes down, that post disappears. The problem is that all of that data needs to be kept somewhere, and there’s a lot of content to keep. Every message would need to be mirrored a few times because you don’t want to lose your messages when you drop your phone, but you probably also don’t want to store random people’s messages and have a server on your phone drain the battery serving them back to the network!

    Your best bet to protect your account is to self-host. That means setting up your own server that you manage, with your own backups and your own rules and accounts. This isn’t exactly a one click thing, you’ll need some Linux server knowledge, but it’s what me and many other techy Lemmy/kbin people do.


  • It doesn’t prevent duplication, but:

    Matrix has this concept called “spaces” in which you can put chat rooms, that can also be nested. In a way, a Lemmy community is not unlike a Matrix space, where every thread is a chat room.

    The neat thing is that you can create a space that contains spaces and chat rooms of your choice and either share it with others or keep it to yourself. For example, some open source project use spaces you can join to allow Slack/Discord like messaging (and not just a chatroom) but I personally use private spaces to group my bridged chats.

    This doesn’t solve the duplication problem, of course. For that, you can use websites like https://browse.feddit.de/. Maybe some (alternative) frontend/app can integrate with that to suggest finding communities rather than creating duplicates.

    However, duplicates are important. Not just in case instances go down and disappear, but also because not every server federates with every other server. You can’t centralize the system on a single community and tell everyone on a big server “sorry, you guys have all been blocked, no more talking about topic for you”.

    Some duplicates are fine, and grouping them rather than artificially uniting them seems like the best solution to me.