If you’re posting from Desktop Linux, your comment utilized at least 10 liberally licensed libraries. And that’s before it got into the wire. GPL packages are a MINORITY, not a majority with exceptions.

There are a lot less GPL projects in your system than you might think. Your core system is already filled with liberally licensed libraries and programs. Case in point, since you talked about rust rewrites, original sudo is not GPL software.

Here’s a 249-page book “just” about atomics and locks in Rust. Does a book this large about only one aspect of Rust prove that it’s a terrible language? No

If that book was about a million ways of how to just use atomics in Rust, then yes, that would be potentially bad. But SURPRISE SURPRISE, it’s not. As you can see for yourself.

Not sure what you were getting at there. Even hard C++ copers don’t attempt to argue against the fact that C++ is huge, and not only that, it’s the biggest language around by an easy margin (this can be roughly and superficially measured by comparing spec sizes).

It’s not the size, but rather everything on top of it, and contributing to it, from general incoherence to bad design to countless misfeatures, that require non-trivial argumentation.

C++ and JS are objectively shit languages from the pool of used languages.

What you quoted is one of the many COPEs Bjarne used in his lifetime. Because unlike JS people. who admit that JS is shit that was originally hastily put together, Bjarne needs the C++ bureaucracy, and the facade of superiority (even if it only lives in his own mind), to keep going because he has nothing else to show for.

I asked an artificially unintelligent tool to find me the answer, and the closest hit (which doesn’t exactly match what I had in my foggy memory) is:

https://web.archive.org/web/20100301115820/http://boycottnovell.com/

The topics the blog posts cover are similar(ish) to what I remember in any case.

That was the end. I vaguely remember a site/blog which was active between the start [1][2] and that end. So it was more circa ~2007.

That period was my first years of full-time GNU/Linux usage, and I only started serious coding years later. In my mind at the time, their content was correct to hate on Microsoft (I always hated it myself, including when they did the bullshit “New Microsoft” rebranding attempt much later). But the site/blog content, I felt, verged into the obsessive and conspiratorial. And I can’t help but wonder how their content aged, and what would my current self think of it.

Anyone here old enough to remember the German (I think) site/blog that used to publish a lot of anti Novell/Suse content because of their ties with Microsoft?

I can’t remember its name, and couldn’t find it with a search.

Did you ask an LLM to write a comment full of cliches?

Thanks for pointing that out. It was a case of conflating the two G’s in “GNU General Public License”.

And what would that goalpost be?

This would be really exciting if Canonical weren’t using this in part because it helps them de-GPL their Linux distro.

I pointed out that A LOT of core dependencies installed in your system right now are not GNU (the GNU in GNU GPL), and never been. You thought I was talking about GNU the project, not realizing I was actually talking about the license, which proved my point from months ago that people who talk like you are completely clueless about the licenses used by packages in their systems.

The supposition that the GPL dependence ratio is both high and getting significantly lowered is doubly wrong (both parts).

The claim that these moves are de-GPLing ones is also wrong, as trivially proven by the fact that the pattern doesn’t even hold (Ubuntu moved to GPL chrony not long ago).

The “rug pull” theory, already invalidated by the falsity of the above suppositions, is independently incoherent, as explained in my previous comment from both a technical and a business/commercial/cost POV.

There are countless angles where an “I’m feeling smart corpos bad” wouldn’t be invalid. This is not one of them.

I’m very aware of the great work Chimera Linux is doing. But still, there are GNUisms hanging around, and binary dependence in particular is hard to shake off, and replacing a system libc can be very complicated, if only for the reason of distros needing to support a smooth upgrade path between versions*.

* I always had the idea of a hybrid “static core/dynamic world” distro packaging model in part to ease such complications.

That’s another fictional aspect. That a distro will simply subsume a random third party upstream for one non-gnu package (or 5 or 10), and change the whole distro model and go proprietary.

I will let you in on a secret, the “stable” distro model itself is largely a lie. So called “stable” distros, even well funded ones, can barely do the minimal in that aspect. The only exception is maybe Red Hat because they employ people who do a lot of upstream development. But even in that case, that only covers a small fraction of what they package.

Distros need good upstreams to avoid responsibility, especially when it comes to security updates, not because they want to subsume all of that responsibility at some unspecified point for some unspecified reason.

The fact that this gets brought up whenever one more non-gnu-licensed rust package (or 3 or 5) is getting adopted, when non-rust literal thousands are already there, including many core dependencies, is what gives this FUD-like argumentation disingenuous vibes (assuming originality and non-ignorance).

Even arguing that “it’s a clear pattern” wouldn’t work, as that also wouldn’t survive fact-checking scrutiny. For example, Ubuntu switched from the multi-licensed systemd to the GPL-only chrony for NTP purposes not that long ago. Where was that supposed “pattern” then?!

EDIT: btw, all “non GNU” mentions in my original comment are about the license. All use non copyleft ones (with the exception of MPL for a couple of packages).

The notion that a modern Linux desktop is GNU is pure fiction.

You posted this from Firefox or a chromium/BLINK based browser! => not GNU

You use X11 libs or libwayland => not GNU

mesa => not GNU

openssl or nss => not GNU (check your system libcurl for me, does your distro build it against gnutls?)

openssh => not GNU (obviously)

fontconfig, freetype, harfbuzz => not GNU (freetype is dual-licenced)

zlib, bzip2, brotli, zstd => not GNU (gzip is, zstd is dual-licensed)

libjpeg, libpng, libvpx, libaom => not GNU

(neo)vim, tmux => not GNU (who still uses screen?!)

and I could go on and on and on

Even when it comes to ntp implementations, OpenNTPD and NTPsec are not GNU. gpsd, one of the three projects mentioned by Canonical, is not GNU (the other two are).

(all software mentioned above sans browsers is written in C btw)

Even GCC is almost fully replaceable now. The only strong holdout is glibc (musl is no match, and doesn’t pretend to be anyway). And surprise surprise, it is not going to be replaced, not anytime soon anyway.

I do not want…

You can obviously want whatever you want. But this was not a part of the implied social contract in GH. And people are objecting to it becoming one, hence this thread.

GH always had “moderation tools”, so you can ban people or restrict access. They could have added a restriction level for “verified users”. But they are choosing not to.

And yes, people will be hosting/moving projects elsewhere. Many already did.

You’re missing the point. Every project has core team/developers. They (the passer-bys) are the most valuable by being the added value, the differentiators that close-source and the (neu) closed-platform open-source projects can’t have.

It is valid that a developer (or developers) of some projects may not want any kind of feedback, and just want to do their own thing. But the original “social coding” platform is not exactly the best fit for such projects.

That’s a weird outlook. I would postulate that (pseudo-)anonymous passer-bys are collectively probably the most valuable contributors to open-source. That one random well-researched easily-reproducible obvious-in-hindsight issue or patch that makes you go wtf.

Annoyance would come from people who would create a “community” construct in the first place, even if it didn’t exist or was needed, just to be a busyworking “member” of. And those types often wouldn’t mind identifying themselves, if not for everyone, for a host like GH.

Recently, I’ve been frequenting an “anonymous” old platform or two which are nowhere near their peak, and have a very high ratio of pure drivel, just in hopes of running into the random anonymous passer-bys of old mentioned above. Passer-bys who would never come near the M$/AI ID-requiring enshitified GH of today. And what do you know! I’ve seen issues (mostly performance ones) show-cased related to a couple of tools I contribute to, that neither I nor the upstream developers knew about.

Anyway, what I was actually hinting at is that online communication existed for a long time before ID-centric social media came into the scene. This even predates the web itself (newsgroups …), and it wasn’t exactly an unmanageable wild west. Most spaces in fact were much nicer than the ID-centric social media platforms of today.

What do you think the internet was like pre-Facebook?

Serious question, how old are you?

Let’s take Lemmy UIs as an example. In a world where this “RCE” is removed, all API calls and returned data would have to go through a “server client” first. I hope this won’t take you long to ponder if that’s an improvement or not 😉

The web is indeed shit. But dumber web means more “clouding”, or if it’s not “clouding”, and to borrow from your reductionist fatalism: Dumber web replaces a potential RCE with a definite MITM.

f-droid represents a distro model with a trust model and certain requirements including build ones. Think of it as the Debian of Android.

When f-droid support is mentioned, it’s not a question of mere APK availability. All APKs after all are available if you know where to look. And it just happens that f-droid compatible 3rd party repositories already exist without the strict requirements (e.g. IzzyOnDroid).

Beyond warring against any kind of third party build (don’t let me get started on forks), Signal uses google services dependencies, so it’s not just about the source of the binary APK. Note that whether these dependencies are hard, or “just!” a default, is not that relevant in my books (this is an active point of contention across many many apps).

This insistent attempt at defending this blessed supposedly secure messenger seems infinitely weirder than what any fanperson of any other app can muster! I put imaginary hypotheticals that don’t even understand the point of f-droid, like “it is perfectly capable of enshittification” into that bracket. The continuous attempt at painting a false binary of Signal and Telegram is even more pathetic.