Lemmy feature request: Show my negative “karma” in my profile page. You can make it opt-in if you must.

  • 0 Posts
  • 77 Comments
Joined 1 year ago
cake
Cake day: June 6th, 2025

help-circle

  • If you didn’t automatically register that requiring spawning full OS processes to scale performance immediately disqualifies a language from a whole plethora of use-cases (which is what the intellectually deficient OP tried to argue against), then I’m not sure you’re qualified to opine on the matter (hint: spawning a thread per task is already too much overhead for many workloads). And I don’t mean any disrespect to you here. Your replies were far from the worst in this thread.

    Frankly this thread has been very illuminating. My perception of the average p.d user and their concrete knowledge was very inflated.

    And we didn’t even get to low level stuff yet. People are already failing at the macro level. Sad.


  • It’s not outdated, and maybe you didn’t get what I was talking about, but probably because I didn’t word it well. So let me quote someone else instead:

    While pure Python code should work unchanged, code written in other languages or using the CPython C API may not. The GIL was implicitly protecting a lot of thread-unsafe C, C++, Cython, Fortran, etc. code - and now it no longer does. Which may lead to all sorts of fun outcomes (crashes, intermittent incorrect behavior, etc.)

    This covers the layers below python, but still doesn’t fully cover the process wide restrictions (it’s not just about thread safety, global initialization and resources are very relevant too). It also doesn’t cover the exact same problem which also exists for any layer calling into python from above, which also relies/relied on the GIL for synchronization. This means that you can’t effectively, confidently, and safely scale python without scaling the number of python runtime instances, each in its own full OS process.

    The fact that multiprocessing became popular, instead of just scaling/parallelizing with threads, is itself an extension of the GIL/no-GIL circus. But its not the primary point here.

    So not only the proposition (which someone referenced in another sub-thread) to move everything into python is in and of itself a self-defeating argument, since it proves a language being a problem (through forcing language lock-in). But even within a language (python), not all problems are solvable still.

    Note that this is not all theoretical for me. In one of my previous projects, I had to call into a python library (which didn’t have an adequate alternative) from rust code (through pyo3). And I was forced to scale with multiple python runtimes, each getting one request/message at a time.


    And we still didn’t get to any low-level details yet 😉


  • What about the fact that runtime startup alone auto-disqualifies python for all short-lived process use-cases?

    Or the fact that you can’t do concurrency especially across the language barrier from another language without multiple python runtimes orchestrated with a queue and IPC because of possible process-wide global state and similar concerns/assumptions for any python library dependency that is not all native across its own dependency chain?

    “languages are just tools” and “use the right tool for the job” were already stupid catch phrases. Pretending languages don’t matter is a big further step into this shallow faux-intellectualism masquerading as wisdom.

    And we didn’t even get to low level stuff yet.






  • While the feel-good kid stories we all heard and believed were nice, Linux would have never gone big if it wasn’t for a billion dollars dedicated by IBM to development in the 90’s, and continued funded development from other companies like RH (which IBM ironically eventually bought).

    Most software installed in your system right now is not gnu-licensed btw. Fully functioning non-gnu distributions (sans the kernel) already exist too, with no tangible effect on the user experience for most.


  • This is a great comment. Not because it’s more stupid than the others, or because of the hilarious scenario envisioned. But because it transparently introduces the cognitive dissonance around liberal licenses, while still presenting as agreeable among the clueless.

    The best way to “sell” open source code is to license it non-liberally while retaining copyright fully, or retaining the right to re-license for 3rd parties. And guess what, the latter is what Canonical does with its GPL-licensed projects + their contributor agreement.

    In fact, you can go too copyleft to the point of becoming non-free (e.g. the SSPL).

    The reason why liberal licenses are framed as corpo-friendly is because corpos can just take, they don’t need to “buy” anything.

    Still the hilarious theories around “selling” coreutils, and the continued general ignorance about practically everything from the gantry here, gave me a good chuckle. Although its all starting to get derivative and repetitive.



  • Wow! What an observant smart thought.

    Well, except for the fact that code conversion doesn’t give you the permission to change licenses or remove copyright. And the small matter of fact that both projects mentioned are Canonical projects, where whatever code that is not directly copyrighted by Canonical, is contributed by someone who signed an agreement with this stipulation:

    (b) To the maximum extent permitted by the relevant law, You grant to Us a perpetual, worldwide, non-exclusive, transferable, royalty-free, irrevocable licence under the Copyright covering the Contribution, with the right to sublicense such rights through multiple tiers of sublicensees, to reproduce, modify, display, perform and distribute the Contribution as part of the Material; provided that this license is conditioned upon compliance with Section 2.3.

    “Us” being Canonical of course. So they could actually “re-license” the projects right now, without changing a single line of code.

    It’s always astonishing how condiment in their ignorance people are when it comes to these matters.







    • The way to the provider does account auth varies.
    • The API for getting e.g. server list info varies.
    • Configuration generation varies.
    • Implementation choices for the VPN protocols varies (e.g. which user-space wireguard implementation to use if the kernel one is not usable for some reason).
    • Some features would require some scripting/light programming if not implemented by the provider. Not only is that asking for a lot, but errors here can be catastrophic.
    • …etc

    All that, and we didn’t even talk about user experience 😉.

    Having said all that, if you’re not using a service that offers configuration generation, which allows you to use your own clients, you’re doing it wrong.

    I use one of the services from your list. And beyond private key generation, I do everything with simple scripts on desktop (or using “protocol” clients on mobile). This is trivial since the server list with its addresses and public keys is publicly available as JSON, even without auth. So putting that info and my private key(s) together, I can actually generate all the configs I want myself with ease.

    But that’s just me. And providers would go broke if they only catered to the likes of me.



  • While it is indeed amusing to think that perma-online often-wrong people are geniuses who perfected the execution of Cunningham’s Law. In reality, they couldn’t be further from that. And everything they write is second or third hand anyway, often sourced from the bottom-of-the-barrel corners of the internet.

    Watch them call me AI again because of the “while…they”, after the magnificent leap of detecting my supposed anti-immigrant sentiment (which is a dog-whistle for “fervent racist” of course).