• 43 Posts
  • 359 Comments
Joined 2 years ago
Cake day: January 18th, 2024
  • IndustryStandard@lemmy.worldtoFediverse@lemmy.world•PieFed 1.4 is released - emoji, federated stackoverflow and AI content filtersEnglish
    141·
    5 days ago

    Because there is no real need for Piefed to create their own activity type besides it being slightly easier for their devs to do everything exactly the way they want.

    But this is very detrimental to the fediverse because it means that everyone would have to change their software to suit the needs of Piefed.

    This could be warranted if there was no way to do it with existing protocols. But as the other user stated above there is no real need for the way they are doing it. It is very hacky and prevents the rest of the fediverse from viewing this Piefed specific content unless they implement this unnecessary message type.

  • IndustryStandard@lemmy.worldtoFediverse memes@feddit.uk•Lemmy walked so PieFed could runEnglish
    5·
    26 days ago

    I thought Rust was faster for basically every metric?

    The entire advantage of Python is supposed to be ease of development, in exchange for slower code execution. It is especially bad in terms of multiprocessing, which Rust is great at.

    As I severely lack expertise on back-end development I asked for clarification to the forbidden oracle (AI) but it also told me that Rust is faster. I am not sure whether you feel like debunking an AI comment but if this is false I would love to hear why because from my current understanding Rust is always faster (for back-end development).

    AI response

    That statement is technically false, but it contains a grain of practical truth that often confuses people.

    Here is the breakdown of why that statement is misleading and where the misunderstanding comes from.

    The Verdict: False

    Rust is almost invariably faster than Python, even in IO-bound tasks.

    If you have a web server handling 10,000 concurrent connections that are all waiting on a database (pure IO-bound), the Rust server will use significantly less RAM and CPU to manage those “waiting” connections than the Python server.

    Why the statement is wrong (The Technical Reality)

    The argument assumes that “IO-bound” means the CPU does zero work. That isn’t true. Even in an IO-heavy application, the application server must do the following:

    1. Event Loop Management
      The server has to track which connections are waiting and which are ready to resume.

      • Rust’s async runtimes (like Tokio) are incredibly optimized and have near-zero runtime overhead.
      • Python’s asyncio loop has significant overhead because it is still running interpreted Python code to manage the tasks.

    2. Serialization/Deserialization
      When the database replies, the server receives raw bytes. It must turn those bytes into objects (JSON parsing, ORM model instantiation). This is CPU-bound work.

      • Rust does this near-instantly.
      • Python is notoriously slow at object instantiation.

    3. The GIL (Global Interpreter Lock)
      Even if your code is async, Python can only execute one bytecode instruction at a time per process.

      • If 100 requests come back from the DB at the exact same millisecond, Python has to process them one by one.
      • Rust can process them in parallel across all CPU cores.

    Where the statement is “Practically” True (The Grain of Truth)

    The person making that statement is likely conflating “faster” with “indistinguishable to a human.”

    If a database query takes 100ms:

    • Rust overhead: 0.1ms → total response ≈ 100.1ms
    • Python overhead: 5.0ms → total response ≈ 105.0ms

    To the human user, 100.1ms and 105ms feel exactly the same.

    In this specific context, you could argue that Python is “just as fast” as Rust because the bottleneck is the database, not the language. But it is incorrect to say Python is faster.

    The “Fediverse” Exception (Why it matters for PieFed)

    The statement “web servers are IO-bound” is often true for something like a simple blog.
    It is less true for the Fediverse.

    ActivityPub (the protocol PieFed and Lemmy use) involves two things that are heavily CPU-bound, not IO-bound:

    1. JSON Parsing
      Fediverse servers throw massive JSON blobs at each other constantly.

      • Python is slow at parsing JSON compared to Rust.

    2. Cryptography (RSA Signatures)
      Every time a server sends a message to another server, it must cryptographically sign it (HTTP Signatures). Every time it receives a message, it must verify the signature.

      • Rust handles crypto operations natively and extremely fast.
      • Python relies on C-extensions (like cryptography), which are fast, but the overhead of calling back and forth between Python and C for every single request adds up.

    Conclusion

    The statement is false.

    • Rust is faster at raw execution.
    • Rust is faster at handling high concurrency (even IO-bound).
    • Python is only “faster” in one metric: development velocity – you can write the code faster in Python, but the code itself will not run faster than Rust.