Thought experiment: imagine a language model where you can describe exactly how you want software to behave, and it produces a binary that does that. You don't get the source code, but it works 100% of the time. As long as you can install this binary on whatever device you have, does this achieve the goals of free software?
@mjg59 assuming that either you also publish the instructions you gave for that binary so I can see them, or that "make a thing which does exactly what Matt Garrett's thing does" is an instruction I can give the model and get back software which is a clone of yours, then yes. Having the source code isn't the point; being able to make the changes I want and nobody being able to stop me from doing so is the point. If I have a magic wand, I don't need source code.
@mjg59 (this assumes that the model itself can't be taken away, of course. If it can be taken away or restricted in use in future, then I'm in two minds about whether this meets the goals of free software, because a year from now if I want to make changes to my or your software, I can't if I can no longer use the model.)
@mjg59 that is: the idea behind having the source is that if I want to change the program ten years from now, even if the compiler is not easily available, I can in theory also build that compiler from source, or write my own, and therefore I can still run the program. If the compiler (in this case, the model) isn't available and I also cannot create it because I don't know how it worked, then having the source code for the program isn't very helpful.
@mjg59 this is a question of philosophy, I think. Is "be my ideal word processor" adequate source code? If you've got a compiler that can compile that correctly, yes. If you haven't, no. Is the Python source for that word processor adequate source code? I think yes even if you don't have a Python interpreter because you can see how it works, not just that it works. This feels like I'm talking myself into a different position than the one I intuitively thought.
@sil I think this is an extremely interesting answer! From the FSF definition we assert that the source code alone is sufficient to understand, but in this hypothetical english→binary compiler we don't necessarily believe the english is sufficient because we don't know what happens next. Why doesn't this apply in existing languages?
@mjg59 I think there's, as you say, an implicit assumption that "source code" is low-level enough that you can understand how the program does what it does. What your theoretical model does is undermine that idea, because the source code expresses a wish rather than an algorithm; there's no explanation of how it's accomplished, which historically people have always assumed that source code has to do. The model is more like a genie that brings you what you wish for; you're dependent on it.
@sil @mjg59 looks like a clarification is required for the word "exactly" in the original toot. IMO, programming language is a way to write what you want a program to do. Natural language can be used for that too.
If you start writing your abstract wishes and still get what you want, you have a model filling the gaps. Is it even possible without a per-person model that knows you very well?
@sil I feel like this falls back to the idea that C represents an abstract idea of the hardware, when in fact it doesn't do that and how your C code turns into native instructions is very opaque
@sil The compiler being itself free software has not traditionally been part of the definition of free software
@mjg59 agreed entirely! and I'm in favour of that. But that's because it didn't really need to be; all previous compilable languages had the property that even if you didn't have the compiler, you could work out how the compiler *worked*, and therefore in a pinch could write your own. (A lot of work, but doable.) But with this, you don't know how to build the compiler, and the source code is not enough by itself to build the program.
@sil That's a strong argument, but what if we had a deterministically trained LLM with only free software inputs?
@mjg59 @sil
Also, the new trained replacement model doesn't have to produce the identical output.
After all, different compilers don't either. LLVM and GCC produce different assembler; and, in countless corner cases, even semantically different programs.
We still consider them equivalent and viable replacements for each other.
@mjg59 I think if you know how to produce the model (or something equivalent to the model) then this is all fine, right? At that point, "make the word processor of my dreams" is perfectly adequate source code for a programme because you know how to make the compiler that can compile it; nobody can take that compiler away from you, so all is good. That's my intuition anyway!
@mjg59 Within the context of this magical compiler, the source code I feed in is free software and the binary that comes out is free software, but it is an unsustainable situation and should only be accepted as an interim solution if a free implementation of the compiler is in our foreseeable future.