I run a few groups, like @[email protected], mostly on Friendica. It’s okay, but Friendica resembles Facebook Groups more than Reddit. I also like the moderation options that Lemmy has.

Currently, I’m testing jerboa, which is an Android client for Lemmy. It’s in alpha, has a few hiccups, but it’s coming along nicely.

Personally, I hope the #RedditMigration spurs adoption of more Fediverse server software. And I hope Mastodon users continue to interact with Lemmy and Kbin.

All that said, as a mod of a Reddit community (r/Sizz) I somewhat regret giving Reddit all that content. They have nerve charging so much for API access!

Hopefully, we can build a better version of social media that focuses on protocols, not platforms.

  • CanadaPlus@lemmy.sdf.org
    link
    fedilink
    English
    arrow-up
    1
    ·
    edit-2
    1 year ago

    Hmm. Alright, what word would you use to differentiate C or Rust pointers/references from, say, Python? I haven’t actually made anything with Rust, but it sounds like you can store a reference in another structure like you can in C, but you can’t AFAIK in Python.

    • Danacus@lemmy.vanoverloop.xyz
      link
      fedilink
      English
      arrow-up
      1
      ·
      1 year ago

      You can store references in another structure, but you probably don’t want to do this most of the time, since it’s a major headache to get ownership and lifetimes right. You shouldn’t think of references as pointers, but you should think of them as “borrows”: you are temporarily borrowing something from the owner, but you can only do so if the owner exists. So you need to statically guarantee that for as long as you borrow it, the owner must be alive, which gets tricky when you store that borrow somewhere in some data structure. In practice, references or borrows will be short-lived, and most operations on data will be done by the owner of that data.

      Underneath, references are represented by pointers, but you shouldn’t think of them as pointers, but rather as something you have borrowed, so in that sense it’s different from C.

      Also, Python does use references everywhere, it’s just implicit, and depends on the type. Try storing a list in a class: you’ve just stored a reference to another structure. Most things (e.g. lists, objects) are passed and stored by reference, some types like integers are copied. In Rust, you can choose whether you want to pass by reference, copy or move ownership. At this point we’re still at a high level of abstraction, we don’t think so much about whether this will be pointers at the low level.

      But my main point is that whether you use pointers, references, or whether it’s implicit or explicit doesn’t make a language slow or fast, it just defines how programs are written. Rust is very fast because it’s compiled to machine code and doesn’t do garbage collection or have any other overhead from a “runtime”. Python is relatively slow because it’s interpreted. You could argue that more manual control over references/pointers can make a language faster, but it’s not the main contributing factor.

      • CanadaPlus@lemmy.sdf.org
        link
        fedilink
        English
        arrow-up
        1
        ·
        edit-2
        1 year ago

        I guess I could just say “Rust isn’t garbage collected” but I feel like that would be meaningless to someone who doesn’t think about compilation. I gravitated to manual pointer/reference control because that’s the part you can actually see in the code, and it’s pretty closely connected to the lack of garbage collection.

      • CanadaPlus@lemmy.sdf.org
        link
        fedilink
        English
        arrow-up
        0
        ·
        edit-2
        1 year ago

        While I have your ear, “who” exactly are the owners in Rust? So far I’ve come to understand it from the aliasing XOR mutability perspective, so I don’t really understand the more common terminology.

        • Danacus@lemmy.vanoverloop.xyz
          link
          fedilink
          English
          arrow-up
          1
          ·
          1 year ago

          When you create an instance of a struct and assign it to a variable or field of another struct, that variable becomes the owner of that value. When you assign it to some other variable or pass it to a function that takes ownership, ownership will move. Otherwise, you will borrow. But there will always only be one owner for each value. That way you know exactly when to free up memory: whenever the owner is dropped.

          • CanadaPlus@lemmy.sdf.org
            link
            fedilink
            English
            arrow-up
            1
            ·
            edit-2
            1 year ago

            So then when you say “most operations on data will be done by the owner of that data”, do you mean ownership-taking functions? In my head a variable is like a bin, so it’s odd to think of it doing any “operations” other than holding.

            • Danacus@lemmy.vanoverloop.xyz
              link
              fedilink
              English
              arrow-up
              0
              ·
              1 year ago

              No, I phrased that poorly. What I meant is that if you have a struct that has some field (it owns that data), your operations on that data will be methods of that struct, and not some other struct that happens to have a reference to that struct. The latter is something people tend to do in OO languages like Java. In Rust, if a function accesses data, you usually “freshly” borrow from the owner of that data and pass it as argument to that function instead of relying on some “hidden” references somewhere in hidden in an object. Borrows will almost always be short-lived.

              I don’t know if any of this makes sense, I’m sorry for the bad explanation. It might make more sense if you play with Rust yourself.