FreeGameDev

Given all that has happened to free software and the FSF, it is safe to say there are many people who feel we are no longer "free enough" when it comes to our software-- that we are actually becoming less free.

Some people have told me they think revising the Free Software Definition is in order. I don't. But I think creating a "second tier" of lesser principles, in support of the Four Freedoms, is worth exploring.

It is difficult to amend the Four Freedoms (outlining the freedom to use, study, change and share the software freely) without diminishing them. Almost anything you could "preserve" on the same level as the existing four, might actually compete with or reduce them.

There are perhaps some principles intrinsic to most free software-- things we can't always promise (modularity for one) that when abandoned completely, cost us.

Here is some feedback I've gotten so far-- I'm here to ask for more if anybody on this forum has feelings about this. Most of all I'm looking for ideas on what could be added.

These will possibly be called the "Four Pillars" because they support the Four Freedoms.

One that immediately came to mind is a way to prevent “Tyranny of the Majority”. This is possible by not having things like systemd be a hard dependency.

I'm still looking for the best principle to make that work, with a level of wording comparable to the Four.

Init and other segments should be loosely coupled not a tight grip, users should have the freedom to swap in or out what they want, you are free to break or fix your own system.

I feel like this is still talking about modularity, but that's alright.

Also, no new segment should break established norms/conventions. Similar to #systemd again, if something worked before and your new program breaks things the problem is your program not the broken things. This is Linus’ famous “don’t break userspace…”.

This one is going to be very tricky to shape into something more universal and also beneficial, but I hope to explore it further.

Then there is preventing “Tyranny of the Minority” this is caused when a small but vocal group aggressively usurps positions, influence, power etc…

These are just ideas that were shared with me already. Thoughts?

Deleted.

Another very important freedom is the freedom to access the source code of server-side programs you interact with. Notably, GPL doesn't provide that. Only AGPL.

And sadly the AGPL is not as popular as the GPL is. It is a very difficult problem to solve.

Lyberta {l Wrote}:Another very important freedom is the freedom to access the source code of server-side programs you interact with. Notably, GPL doesn't provide that. Only AGPL.

The Four Freedoms covers why access to source code is necessary, and while GPL does not provide all 4 freedoms on a server-side program, AGPL does, correct. Specifically I'm looking for things which may traditionally be intrinsic/implicit to the free software ecosystem (modularity is one) but which when abandoned, create problems for freedom.

It isn't necessary for everything to be modular, though the closer we get to zero things which have that quality, the more of a problem we tend to have. We had that debate in another thread, and I'm not a purist about that quality-- I am a proponent.

I think the freedom we need the most is freedom from malicious features. Most popular software comes from "Open Source" camp and it is filled with telemetry and other types of spyware.

That really is a perfect example of what I'm looking for. What I want to know is this-- ok, say Mozilla for example, puts malicious features in something that is free software. One person says "this is a problem, now we have to weed all this garbage out" and another says "this isn't a problem, the license says you can remove the garbage yourself, so freedom is satisfied." What principle would improve this situation and others like it if adhered to-- I mean we can fix it, technically, but what would support making it more trivial to fix (if the telemetry were a module that could simply be deleted, that would be lovely.) If we had a rule about not spying on users, that would be lovely-- but more difficult to perfect.

I think your issue comes more from specific software, but really I doubt you have a beef with software writing to an API. If these programs didn't exist, we wouldn't nearly as far as long as we are now. I must agree with Lyberta here - there's no harm in standardisation. I think Linux and its Unix roots are crap and archaic in many ways (RMS noted he didn't actually like Unix, it was just popular at the time he wrote GNU), as is Windows, but it's really the software that runs on them that makes them great.

I'm using a very broad definition here, and that includes Unix tools (the GNU's, BSD's etc) that handle file operations like cp, rm and so on. Nearly EVERY program that runs on Unix, Linux and the like uses these in some way, likewise with shell scripts.

You are happy to accept the Unix hegemony, possibly Windows too if you believe in cross platform, but in practice you must agree it would be absurd to expect it to run on all the operating systems no-one cares about.

With that in mind, it seems like you're proposing everything is a statically linked file that does everything in house. Doesn't that seem like a regression to you?

Evropi {l Wrote}:You are happy to accept the Unix hegemony, possibly Windows too if you believe in cross platform, but in practice you must agree it would be absurd to expect it to run on all the operating systems no-one cares about.

With that in mind, it seems like you're proposing everything is a statically linked file that does everything in house. Doesn't that seem like a regression to you?

If you're addressing me, I don't know how you got these things from what I said. If you're addressing someone else, sorry for the confusion, carry on. I didn't want to simply ignore your post, but it appears to speak to something someone else said, perhaps.

I agree, modularisation is a double edged sword and can lead to a lot of bad side effects. It can also make it easier to swap out a vital component with a closed-source one and for sure over time creates these magic black boxes that no one really understands but still depends on.

This brings me to another idea, which I think will be vital for the legacy of the Free Software movement. Think about the difficulties to work with legacy code... this is just going to get worse as software becomes more and more vital to civilisation's infrastructure. I am sure in a few decades there will be "software archaeologists" and people that try to reverse engineer machine learning black-boxes with extreme difficulty.

So I think one of the addendum should be something like, making sure that you yourself can understand the code in a few years isn't sufficient, make sure that it is maintainable by generations of people to come. I think this implies an conscious effort to reduce the complexity of code without falling back on black-boxes with APIs, but how exactly to do this best is probably the big question of software design principles these days.

Julius {l Wrote}:I agree, modularisation is a double edged sword and can lead to a lot of bad side effects. It can also make it easier to swap out a vital component with a closed-source one and for sure over time creates these magic black boxes that no one really understands but still depends on.

I agree thats a legitimate concern, though I dont think you can have freedom without sufficient "hooks" or api for non-free software. Where we differ the most is that I think the risk is always worth it, because it's up to the user to choose free over non-free, not their os.

Think about the difficulties to work with legacy code...

So I think one of the addendum should be something like, making sure that you yourself can understand the code in a few years isn't sufficient, make sure that it is maintainable by generations of people to come. I think this implies an conscious effort to reduce the complexity of code

I feel very strongly about that, it's one of my passions when it comes to coding and its something I try to share with anybody I teach.

So to say I agree is an understatement, and it reminds me of something the founder of dyne.org and leader of Devuan said recently.

The trick I guess is coming to some kind of semi-consensus on how to reduce complexity. Which is worth a topic of its own, but I'd be happy to talk about it here or have you elaborate on it further, though for your reasons and more I wish more people felt the same way.

Perhaps you could mention something you already do to make that happen-- theres probably something, and it might provide a hint as to how to achieve such a goal. Like a solid definition isnt required, even a place to start is worthwhile.

It very much was a response to the topic, and Julius put it forth much better. Because of the issue of legacy code, this would be unworkable.

A piece of software's complexity or compatibility isn't at all relevant to the question of software freedom. Trying to force it into a license would be of no value in terms of ensuring freedom - as long as what lies beneath the software is also free.

I was making the point that this is already happening, because you're ultimately still writing for a specific operating system, a specific runtime, and their peculiarities.

Evropi {l Wrote}:It very much was a response to the topic

I didn't dispute that it was on-topic, I just didn't understand what part of what I said it was a response to.

A piece of software's complexity or compatibility isn't at all relevant to the question of software freedom.

I can't agree with that. Microsoft has had well documented plans to use "de-commoditised protocols" and strategic incompatibility to hurt free software. It works. OOXML is just one real life example. It takes longer to achieve that under a free license, or a mix of free and non-free, but they did it countless times to non-free competitors and it only took them 20 years to find a way to apply to free software.

You can quibble about theory and be 100% correct, but you would have to ignore reality and facts to say one has no relevance to the other. They are related in fact and in practice. But perhaps not in theory.

Trying to force it into a license would be of no value in terms of ensuring freedom

I very much agree with you on that!

There is nothing wrong with the licenses we already have, as far as I'm concerned. The licenses do whatever licenses can do, perfectly well.

I was making the point that this is already happening, because you're ultimately still writing for a specific operating system, a specific runtime, and their peculiarities.

Just because it's the main point of attack, doesnt mean the same problem does not exist elsewhere.

Fair enough, I am starting to see your point more.

OOXML is a good example of what you speak of as it's an open standard, but Microsoft is terrible at following it themselves. Due to MS Office's dominance, it means others have to just write tests until they work in a given version of it. I suppose it's kind of like HTML and having to break the XML standard more and more since the 90s, mostly because people didn't know how to write valid XML!

The problematic part is that you gave the example of systemd, which is an entirely free piece of software, and that's why I had a more sceptical reaction initially. I also don't perceive it as tyranny of the majority, because distributions like Void still exist, and elogind or consolekit2 is usually enough. It's all thoroughly documented, so you can make minimal implementations (see also MinGW vs full Cygwin on Windows for a very similar example).

On the other hand, in defence of Microsoft's approach (I can't believe I'm doing this...), consider SQL. I'm not sure who actually decides what goes into the SQL standard, but it's safe to say the standard is pretty bad. So pretty much every SQL database implements their own custom stuff in addition to the standard, as well as the standard itself (if they can be bothered).

PostgreSQL actually lists the reasons they chose not to follow the standard when they break it. They're considered very compliant, but practical realities have to take precedence, and we can't rely on a poor and legacy standard to take things forward. A lot of software (incl. free software) is locked into a single DB format due to this problem, but honestly, we're probably better off without it as these deficiencies have caused the standard to improve over the years.

It's a much better argument now that I have the full picture, but I'm not sure of the solution. It seems like it's very case-by-case, so you can't put up a principle to follow without impairing valid uses of breaking away from a de facto/actual standard and doing your own thing.

Evropi {l Wrote}:It's a much better argument now that I have the full picture, but I'm not sure of the solution. It seems like it's very case-by-case, so you can't put up a principle to follow without impairing valid uses of breaking away from a de facto/actual standard and doing your own thing.

I did cede that from the very beginning. The Four Freedoms (from the standpoint of the FSD) are non-negotiable; if you don't have them, it isn't free software.

These "four pillars" are things that can't be strictly guaranteed without, as you said, impairing valid uses (valid from any standpoint I can think of, mine, yours, or of those who are pushing this along) but they also can't be thrown out the window without leaving freedom diminished.

I wouldn't be pushing such a tenuous companion to the FSD, except that it's better than the alternative-- trying to shoehorn it directly in. In Devuanland this could start being called a Fifth Freedom. As long as it's tongue in cheek it's ok, like a Fifth Beatle, my only objection to it is actually the same as yours: it's case-by-case, it's very tricky to come up with a "principle" around what's more of a sweet spot.

One thing I'm trying to come up with is a hard rule that almost directly results in such a balance. What reasonable principle would most reliably result in the right amount of modularity as a general likelihood, without demanding it when no person would even benefit? It might not exist, but formalising it might not be the solution anyway. I'm happy to say that this project has kicked off a few other good ideas, which are being explored as well. If those ideas are better, this pillars idea would likely become a relic. The pillars would still exist, hypothetically, but nobody would care (or need to.) They didn't need to before, when they were implicit-- only as they are gradually neglected.

and thus boughtonp spoke:

Here would be my fifth: replace - the freedom to not run the software, to be free to avoid vendor lock-in through appropriate modularization/encapsulation and minimized dependencies - meaning any free software can be replaced with a user's preferred alternatives.

i think that could actually work!

Seems to me this is all more of a technical discussion, rather than a legal or even moral one. Little point in being prescriptive in terms of software design as far as free software is concerned.

Technopeasant {l Wrote}:Seems to me this is all more of a technical discussion, rather than a legal or even moral one.

That might depend who you ask. Open Source has spent 20 years reframing Free Software in terms of technical discussions. There's a great deal of momentum there, how can I be sure that isn't why you think this is a technical discussion?

Little point in being prescriptive in terms of software design as far as free software is concerned.

In most instances I would agree, which is why I was trying to put it in MORE philosophical terms.

But then someone came through with a sort of technical/philosophical hybrid that I suspect really isn't as prescriptive as you must think it is, and I thought it worked pretty well. Still, I am trying to get everybody's opinion. I did want to point out that I've heard that particular dismissal lots of times and there could be other reasons for it.

So bitter "I don't like Systemd" addendums aside, what about the often raised concerns that Free Software shouldn't only be free but also ethical etc.?

I think most attempts at that so far either restricted the freedom aspect too much, or backfired pretty badly. But still the overall concern is kind of valid, as I think many people would not like their database application to be used to organize the next genocide or something like that.

While it is probably out of the reach of a license to prevent such an extreme case as the above (although the Nazis were quite strict at following rules...), some sort of addendum that the same time doesn't restrict the 4 freedoms is worth thinking about. Not only from a ethical perspective, but also to avoid having people resort to licenses that do restrict the 4 freedoms.

I think some sort of reciprocacy is probably the right solution to this. Similar to how the copyleft model doesn't restrict your freedom, it just mandates that you don't restrict the freedom of others either (this is of course debatable).

Julius {l Wrote}:what about the often raised concerns that Free Software shouldn't only be free but also ethical etc.?

It seems pretty clear that you can only fit so many ethics lessons into a license. If we moved that battle to free software licensing, the whole thing would fall apart.

For example, the goal of free software is for all software to be free. Whether it's a crime or not, (and I'm not sure it always is) the DOD uses software. I'm against non-commercial licenses, not only because they're limiting (that's a good reason to avoid them IMO) but also because they're needlessly confusing. Putting ethics in the license would make every download a quandry.

Freedom 0 is "for any purpose" and this would end that, but free software licenses (AFAIK) are triggered by redistribution (specifically "conveying" in GPL3, which perhaps is a subset of redistribution) not by use. So this would also change that to a shrinkwrap kind of deal.

But getting back to my first point, the DOD doesn't have to honour copyright or patents in its goals, they aren't held to either. So all you're doing with the idea is saying "if you want to do something unethical, you should use Windows or a Mac for that." And they don't think you should use Windows or
a Mac for anything, because if you use Windows or a Mac for something unethical, now you have TWO problems (the unethical act plus non-free software.)

If you hit someone with a stick for no reason, it doesn't make the stick unethical, you are the one behaving unethically. If a stick doesn't come with a license restricting its use, that should not be interpreted as condoning unethical uses. Neither is Freedom 0.

Let's move from licenses to law to show how common-sense this is-- imagine a law that says "don't do anything unethical." Far from forcing society to be ethical, it would (if strictly enforced, that is) plunge society into chaos. It isn't well-defined, and a law that isn't well-defined is a TERRIBLE law. So when these amateurs come in and talk about putting such things into the license, where it won't do a lot of good, what they're creating is a very pointless chaos that prevents the licenses from being enforced reasonably-- and thus prevents the licenses from doing any good.

This isn't a defense of bad ethics, it's an argument about what licenses are good for and what they're useless for. Wrong tool for the job.

It's worth noting that both the authors of the Free Software Definition (Stallman) and the Debian Free Software Guidelines and Open Source Definition (Perens) already felt this way 20 years ago, and Perens deliberately put this right into the OSD. (Which he explained recently.) He considered this and deliberately wrote the "Fields of Endeavour" part of the OSD the same way Stallman put in Freedom 0. And Perens noted this again, recently.

Again, if you want to do something unethical with software, and you are told "you have to use non-free software for that"-- now you have two problems. With one exception I can think of: If the unethical act is to create free software-- then of course you have to use non-free software for that.

It is here that it's good to note that using non-free software isn't necessarily an unethical act. Users take it personally when Stallman says that Free software is about ethics. "I'll use whatever software I want" shows they're reacting to something he didn't say.

He considers it unethical to deny users freedom when creating software. The ethical mandate is aimed at software developers, not users in general. While it helps to use free software, because it instructs developers that they'll have to make their software free if they want it to be used be more people, the onus is still on the developer, not the user. It isn't the user that denies freedom to the user, it's the non-free developer.

I think most attempts at that so far either restricted the freedom aspect too much, or backfired pretty badly. But still the overall concern is kind of valid, as I think many people would not like their database application to be used to organize the next genocide or something like that.

The Free Software Definition, despite being political and some would use the world ideological, consists of things that can be helped with software licenses. The Four Freedoms are all things that can be granted by license language.

Broader ethical issues are more complex and would never be possible in a license. It takes the entire legal system just to try to make more things ethical using rules, and it is already overburdened. I think that point more or less proves two things:

1. If you don't want a license as hopelessly complex as the entire legal system itself, don't use the license to try to mandate complex ethical issues.

2. The better way to address ethics by far, is separately from licenses.

While it is probably out of the reach of a license to prevent such an extreme case as the above

Definitely out of the reach

some sort of addendum that the same time doesn't restrict the 4 freedoms is worth thinking about.

It would end the Four Freedoms. I had a similar (milder, though relevant) concern about adding a Fifth Freedom through a sort of Wave Cancellation principle. That isn't just a wild metaphorical notion, it's a known fact that appending a license or set of rules can unintentionally cancel out other parts, in ways that are not obvious (particularly to non-lawyers.) It's one of the primary hazards of writing your own license.

Not only from a ethical perspective, but also to avoid having people resort to licenses that do restrict the 4 freedoms.

Unless I misunderstand you, I think it would have the opposite effect of forcing people to resort to licenses that restrict the 4 Freedoms.

I think some sort of reciprocacy is probably the right solution to this. Similar to how the copyleft model doesn't restrict your freedom, it just mandates that you don't restrict the freedom of others either (this is of course debatable).

You wouldn't want to make a Free software license that is trivial to revoke, it would lead to legal trolling. It is possible to revoke the GPL if certain aspects are not followed, but that is treated by everyone responsible for creating and upholding the license as a last resort, and one worth avoiding if at all possible.

Using the wrong tool for the job isn't a support of better ethics, it's a support of doing something important in a way that is bound to not work well.

I'm not disputing the good intentions of many of the people who have such ideas, though I am fairly certain there are also some people with intentions that are less good, who are making use of those well-intentioned people to disrupt free software. Some of them at least, should know better and likely do.

The people most likely to push this agenda with the press for example, are those who already have Defense contracts-- such as Microsoft. Adding completely unenforceable clauses to Free software licenses would make fear of the license as bad as it was under Steve Ballmer, and people would flock to Free software's very DOD-Friendly competitors-- BSD (started with Defense money) and Microsoft.

They wouldn't flock to non-free software because they disagreed with the ethical issues-- they would flock because they were worried they might inadvertently fail to comply with the license, and for companies that would be too much of a legal and financial liability to risk.

It would be a very good, and very effective attack on Free software to try to make free licenses do a job they can't possibly accomplish.

freemedia2018 {l Wrote}:and thus boughtonp spoke:

Here would be my fifth: replace - the freedom to not run the software, to be free to avoid vendor lock-in through appropriate modularization/encapsulation and minimized dependencies - meaning any free software can be replaced with a user's preferred alternatives.

i think that could actually work!

This reminds me of the problem with https://en.wikipedia.org/wiki/Tivoization

GunChleoc {l Wrote}:This reminds me of the problem with https://en.wikipedia.org/wiki/Tivoization

Tivoisation demonstrates that license code can have vulnerabilities, exploits and patches, much like software. GPL3 is the patched version.

The attack was multi-prong however, as a Microsoft front group (I've named them already, I can't think of the name at the moment) successfully lobbied Torvalds to stand against GPL3. That meant that although GPL2 was successfully patched, the "patch" wouldn't apply to the kernel, and Tivoisation with an "unpatched" kernel and permissive-licensed GNU replacement could go on denying the same freedoms that Tivoisation does. The Free Software Foundation has not been successful against such multi-prong attacks. http://techrights.org/wiki/index.php/Li ... ivoisation

Yeah, seems like the entire "ethical" issue is a open wound, but there really are people you think it is necessary.to add non-free clauses to the GPL to prevent military usage etc. I think this is well intended, but we agree that this backfires quite badly.

However I disagree that there is some sort of conspiracy to push companies to use BSD style licenses. Those that are concerned by the GPL are mostly lost causes anyways.

Never the less, you don't seem to have gotten my original suggestion: Like Copyleft effectivly solves most of the concerns people have that want to put their works under a non-commercial license (at least if you explain it properly), so could there be a similar way to address the people with ethical concerns without resorting to a similar bad solution as a non-commercial addition.

Julius {l Wrote}:However I disagree that there is some sort of conspiracy to push companies to use BSD style licenses. Those that are concerned by the GPL are mostly lost causes anyways.

I would call it a tendency, not a conspiracy. I don't think Apple is being pushed that way, I think they are behaving that way.

I nearly lean "Open Source" on the permissive/copyleft issue. Nearly, but not quite. For me, the broader goal (of copyright-- the only real justification for it existing in the first place) is to create a thriving Public Domain. This predates the Constitution and goes back to the Statute of Anne that demonstrated the type of thinking that was in vogue when the Framers were figuring out how and why to do monopolies.

All that aside, Torvalds says going GPL was the best decision he ever made, which really flies in the face of those preaching permissive-- including BSD. I think BSD is a technically superior kernel. For broader practicality, I think the Linux kernel is more useful. Each one has strengths over the other. But I think Linux gets its strengths from requiring people changing it to share those changes. I suspect even Torvalds (not a big Free software guy) understands this and he doesn't deny it.

Never the less, you don't seem to have gotten my original suggestion: Like Copyleft effectivly solves most of the concerns people have that want to put their works under a non-commercial license (at least if you explain it properly), so could there be a similar way to address the people with ethical concerns without resorting to a similar bad solution as a non-commercial addition.

Mmm... I agree with you that for example, Share-Alike is better than Non-Commercial and has similar advantages. You could be right, hypothetically, that there is some similar way to address people with ethical concerns. I think this is getting farther from the topic, but it's your forum and it doesn't bother me-- I'm generally an "explore all the angles" sort of guy, we can explore these angles if you want to. I like to annotate the drift at least, a bit like a disclaimer.

I disagree that it is getting farther from the topic. Yes the non-commercial example is more related to Creative Commons licensing, as there the non-commercial concern is voiced often. However the ethical concern is much more often and justifiably raised for software licenses, especially Free Software licenses and at projects under Free Software licenses. This is justifiably because the potential ethical harm is just higher with software that runs the world's infrastructure and because Free Software styles it self as a more ethical movement than OSI etc.

So to start with an example: what about ML models created with FOSS software used for surveilance purposes? Right now AFAIK these "outputs" are in no way effected by the software licensing and there is no requirement to make it public for study and reuse etc. This is both an ethical issue and goes very much against the spirit of the Free Software movement.
But I well understand that the first instinct to extend copyleft onto program outputs would have a lot of bad unintended effects and severly restrict the use of FOSS software, so that isn't really the way to go. But what about programatic outputs only? E.g. if a shader code gets processed by a FOSS program and the output is still a piece of software (like a ML model is also to some extend), maybe that could also be "infected"? On the other hand that is also what every compiler does, so maybe not such a good idea... Just brainstorming

Edit: OK lets say if data gets processed by a FOSS program and the output isn't just modified data but rather a program in itself. Then clearly in essence the FOSS software isn't just an inert catalyst but rather becomes part of the output in some sense, even if not strictly speaking. I think this can be quite well understood when looking at an image editor: you can use GIMP or Photoshop to produce identical processed photo outputs, but the machine learning program very much determines the specific characteristics of the output model and can not just substitued by another one to produce identical outputs. At least I think so, not a ML expert

Julius {l Wrote}:I disagree that it is getting farther from the topic.

Fair enough.

Yes the non-commercial example is more related to Creative Commons licensing, as there the non-commercial concern is voiced often. However the ethical concern is much more often and justifiably raised for software licenses, especially Free Software licenses and at projects under Free Software licenses. This is justifiably because the potential ethical harm is just higher with software that runs the world's infrastructure and because Free Software styles it self as a more ethical movement than OSI etc.

I mean I'm not disputing the validity here, just the strength of the connection. I'm still trying to find it. And maybe that's not your fault.

what about ML models created with FOSS software used for surveilance purposes? Right now AFAIK these "outputs" are in no way effected by the software licensing and there is no requirement to make it public for study and reuse etc. This is both an ethical issue and goes very much against the spirit of the Free Software movement.

I would say it's a different issue that doesn't directly affect free software. That's not to dismiss it or in any way discount or dismiss its importance-- it's probably quite important, but I'm going to at least entertain the notion that it can be important and still be a separate issue. The reason I'm connecting the issue I am actually connecting to free software is that it is used to attack free software directly. And not on a whim-- it looks more like a plan that has existed for 20 years straight. So there's the connection between my two topics.

I think what you're trying to do, and I'm sure I sound completely unsympathetic to this-- you'll be closer to the truth assuming pedantry than apathy here-- you're trying to recreate the Bill of Rights in digital form. And I applaud it. I think we need digital rights. These rights may go beyond what is needed to make our software free. Or, by a stretch of the imagination, perhaps I can think of a way you could be right. Please, again, I am perfectly serious. This is not a cute way of saying I doubt it. You really could be right, but I'm not with you on this yet.

Digital rights matter whether they're freedoms directly related to free software or tangentially related. Some of this sounds tangentially related to me.

But I well understand that the first instinct to extend copyleft onto program outputs would have a lot of bad unintended effects and severly restrict the use of FOSS software, so that isn't really the way to go.

Well, let's go from the other side for a moment-- what if a GPL program generates program code as output? If that's what you're saying, it's a fascinating question. I'd love to ask the experts and find out what they think. I haven't thought about it a lot, of course.

But what about programatic outputs only? E.g. if a shader code gets processed by a FOSS program and the output is still a piece of software (like a ML model is also to some extend), maybe that could also be "infected"? On the other hand that is also what every compiler does, so maybe not such a good idea... Just brainstorming :)

You could use the compiler as a precedent, yes.

Edit: OK lets say if data gets processed by a FOSS program and the output isn't just modified data but rather a program in itself. Then clearly in essence the FOSS software isn't just an inert catalyst but rather becomes part of the output in some sense, even if not strictly speaking.

You mean like a compiler that modifies itself so the output becomes part of the compiler? You know either you ask some great questions, or I imagine you do. You may have written a copyleft koan there.

I think this can be quite well understood when looking at an image editor: you can use GIMP or Photoshop to produce identical processed photo outputs, but the machine learning program very much determines the specific characteristics of the output model and can not just substitued by another one to produce identical outputs. At least I think so, not a ML expert

Since we are back to talking about data, I'm not sure.

For what it's worth, I don't believe the line between program and data are the same for Richard Stallman and I. For him there is greater separation. I ultimately think all data can be looked at as software.

But when you're trying to figure out what to copyleft, perhaps it is better to pretend there is a distinction whether or not you fully believe in one.

It would be nice if we had sane copyright terms. That would make these philosophical questions a lot easier, I think. Sorry if I haven't answered your question yet. I don't have an answer.

No I mean something different. And yes I agree with Stallman that data and programs are very much different. Data are like ingredients in cooking, while programs are recipes, i.e. instructions on how to cook.

Now this is the old distinction on which the GPL was build. However one could say that machine learning is introducing a new concept there. Basically a ML program looks at the ingredients (a lot of them) and derives a general recipe how to cook tasty food from a set of ingredients. So basically it turns data into programs.

So far the consensus is that the license of ML algorithm that does that is irrelevant and that the license of the data determines the license of the output. However that is questionable as the output does not really contain any of the data, just a kind of meta description of it. At the very least the input data is of similar importance to the output as the ML algorithm is.

Thus if a ML algorithm is Free Software it should not be irrelevant to the licensing of the output model.

I've recently added an important value to the four freedoms, and that is being suckless/minimal/Unix philosophy, because it is an important ethical property. SW should only do exactly as much as is needed, should require as little as possible resources to run, maintenance, time to understand the source, effort to modify etc. The opposite is wasteful, unethical and makes humans slaves to machines (instead of vice versa). So my aim is now free software (required) which is also suckless (extremely preferred).

That said, free SW can be used to take some kinds of freedom away, which directly follows from freedom zero, and it does happen in practice. The four conditions are therefore just a specific important condition necessary in order for the SW to be ethical, i.e. free SW is a superset of ethical SW. I think the effort of exactly defining the set of ethical SW is futile as much as trying to capture the complexity of morality with law. The only way to guarantee ethical SW is to make it your goal (instead of e.g. profit).