On Sat, 08 Jul 2023 22:53:07 -0400 Richard Stallman <r...@gnu.org> wrote: > This issue is not about distinguishing emulators from interpreters, or > any such classification of programs. Because it is not about making > rules to apply to those classifications. It is not about rigid rules > at all.
> The issue here is: given a specific free program that can
> (occssionally, or theoretically) be used to run some free software,
> but in practice is nearly always used to run nonfree software, which
> of these approaches should we choose about that program? WhichThe
> issue is also how to stay consistent.
Despite its attempt to block nonfree firmwares, linux-libre is a
software that occasionally run only free software but that most of the
times run nonfree software because not everybody uses RYF
certified hardware or at least hardware that doesn't make linux-libre
run nonfree software[1].
The difference with software like ScummVM, Qemu, Wine etc, is that
linux-libre is using software that is already in the machine. But it's
also possible for distributions to try to find that software from
installations of nonfree distros in the same machine and break the
expectations of users.
So if we don't make classifications, and if we apply the same rules to
all software, we will most likely end up pushing distributions to argue
more and more with their users and contributors to try to justify these
rules.
If we don't apply the same rules to all software, then distributions
will again have to justify themselves anyway as a rule would apply to
software A and not to software B.
That justification would typically be done in bugreports, mailing
lists, etc when people try understand why some software is being
removed or not removed.
And anyway most/all the FSDG distributions are collaborative, so people
need shared understanding of how to deal with cases like ScummVM or
linux-libre anyway and be somewhat on the same page.
So if we come up with something clear and not ambiguous, the cost
of arguing goes down significantly: distributions would just need to
point users and contributors to a very clear justification that speak
for itself.
That's also why I'm trying to advocate for things that are easy to deal
with from the distribution point of view.
What I'm advocating for is not ideal as there is still some corner
cases[2] but the corner cases are less likely to popup, and we might
avoid them completely.
And doing nothing is not an option because if distributions practically
speaking steer users too much toward nonfree software (for instance by
packaging software that is only meant to run nonfree software), then it
would normalize willingly running nonfree software within these
distributions, and we want to avoid that.
> All of these approaches are legitimate and ethical according to our
> philosophy. But each can be more or less beneficial to the cause.
>
> 1. treat it like any other free program -- pay it no special
> attention.
>
> 2. Urge free distros to reject it, becsuse in practice distributing
> it to users only legitimizes the nonfree programs that depend on it.
>
> 3. Tell free distros to reject it, for that same reason.
>
> 4. Tell free distros they can redistribute it provided they remove all
> information about finding the nonfree programs it can run.
- (1) probably cannot work as it could normalize the steering of users
toward nonfree software in practice.
- With (2) and (3), if there are valid 100% free software use case,
there will be a big cost in arguing, trying to find rules
that can work at least within a distribution, etc.
It also can has the potential of nasty collateral damage like
preventing collaboration to enable these 100% free software use cases
in FSDG compliant ways.
- (4) looks fine but it could be more strong as we can remove
programs that are not known to be able to run 100% free software, we
can modify the packaging to limit the steering toward nonfree
software, etc.
> Right now we are thinking about the ScummVM case. I do NOT expect we
> will want to treat all such cases alike. I expect that in thinking
> about various cases, we will find reasons for treating various cases
> in various ways.
Yes but how would we differentiate between linux-libre and ScummVM in a
robust way?
Here we could state that ScummVM doesn't reuse nonfree software like
linux-libre and that the software being reused by linux-libre is inside
the hardware. But then people could also argue that reusing the
firmwares of the OS shipped by the hardware is also fine, etc, and it
could in turn normalize the reuse of nonfree software that is in
another OS / distribution.
And here I fear that this is too complex so if we manage to define
something it will likely contains bugs, and we shift to another criteria
it would have other bugs, and so on.
And if we have too much complexity, it will probably enable workarounds
and endless discussions anyway.
So I think that here too something more simple is better.
> > as i noted earlier, it depends how "generically" they are viewed
> > - in the strictest sense, it would apply to every runtime and
> > language interpreter, such as java, dotnet, python,
> > gnu-smalltalk, etc - anything which can be characterized as a VM
>
> I don't think that "being a VM" is a pertinent factor anyway.
>
> even those which would be the safest to recommend, such as QEMU,
> can run non-free software as well as anything
Indeed. We need to treat "being a VM" as an implementation detail. For
instance many other type of software can also run programs
(interpreters, compatibility layers like Wine, etc).
So if we need to classify software somehow we could insist on what
features it implements instead (can run other programs).
Though we would also need to foresee the impact of guidelines/rules
that would apply to cases like that because it could have unintended
consequences as well. For instance a web browser would be in the same
category than ScummVM (programs that run other programs within them).
So It makes it hard to predict all the consequences of some rule within
a distribution.
> That is too terse for me to follow. What _exactly_ is the stance
> you are arguing against? And plesae state the facts that you're
> basing your argument on, because I know very little about QEMU.
I can't speak for bill-auger, but Qemu emulates full computers. So it
can run nonfree OS as well as FSDG distributions.
Qemu is often not used directly, but through graphical interfaces or
other wrappers that simplify its usage. As I understand, all these
simplified interfaces allow to run what you want inside Qemu, including
nonfree OS.
> The one thing I can is that (1) any platform for running software can
> run nonfree software, and therefore (2) the fact that platform P can
> run nonfree software is not pertinent to any judgments about P.
Right.
However one of the questions (that is divisive) being raised in this
thread is if we start deciding by weighting the pertinence of the free
and nonfree software use cases.
If we base the criteria on the number of users to weight the use cases,
then beside the difficulty to count users, we might have issues with
software like linux-libre.
Remains the perceived usefulness of use cases, but that is also
subjective and that subjectivity can depend on the background of
people, their interest, etc.
So for all these reasons I'd like to have something simple that can
easily be reasoned with by distributions contributors and users.
So far the simplest criteria I found is to understand if we have at
least 1 valid use case that works with 100% free software.
That criteria enable to remove ScummVM while keeping browsers, Qemu,
linux-libre, etc.
And it probably has very minimal collateral damage, and if it does some,
that damage would probably be worth the gain of not steering users
too much toward nonfree software.
And distributions can take steps to help preventing steering users
toward nonfree software by modifying package description, hiding
programs like ScummVM as dependencies of other packaged software, and
even blocking the run of nonfree software when there is no collateral
damage and that it's easy to maintain (Programs like ScummVM looks like
a perfect fit here).
References:
-----------
[1] That nonfree software is run when people either use ATI / AMD /
Nvidia GPUs or use nonfree boot software (like nonfree BIOS or
UEFI).
With nonfree BIOS / UEFI export some ACPI tables that contain both
code (in form of bytecode) and data, and linux-libre runs that code.
With ATI / AMD / Nvidia GPUs, linux-libre also runs nonfree code
that either comes from the GPU or the BIOS/UEFI. That nonfree code
is also bytecode and it's called AtomBIOS for ATI/AMD GPUs. That
code is run to initialize the GPU.
[2] One corner case would be if someone takes one of the GPU drivers
mentioned above and package it as a standalone driver.
In that case if we takes "can run 100% free software" as a
criteria, linux-libre as a whole could be fine but that standalone
driver is not fine anymore, even if they are almost the same.
So there is still a question of granularity here but such cases are
probably not that important as they might not popup at all.
Denis.
pgpx03Yo9aDfu.pgp
Description: OpenPGP digital signature
