Conversation

Notices

1. Embed this notice
   eliseo (eliseo01@fe.disroot.org)'s status on Wednesday, 24-Dec-2025 06:09:49 JST eliseo
   Your software is not free and cannot be free if the stack required to compile it is proprietary, no matter what version of GPL you use.
   • Embed this notice
     Alexandre Oliva (lxo@snac.lx.oliva.nom.br)'s status on Wednesday, 24-Dec-2025 06:09:47 JST Alexandre Oliva

     in reply to
     erhm... maybe it's not a very important distinction, but being autistic, it matters to me 😉
     
     very long ago, Qt was still proprietary, but KDE was based on it. I learned then that, despite this dependence, KDE was Free Software, even though it couldn't be used in freedom. the difference is that nothing stops you from enjoying the essential freedoms to control the free portions, even if they aren't complete programs. the freedom problem exists, and it can be solved without changing the free portions: it suffices to develop more Free Software to fill the gap. GNU even started the GNU Harmony project, to have a Free implementation of Qt, and eventually Qt itself got released as Free Software.
     
     analogously (it's an imperfect analogy), a Free program that relies on a proprietary stack is Free nevertheless, but maybe it can't even be built in freedom. solving the problem requires developing a free stack (toolchain, libraries, runtimes), but once that's done, and/or the existing stack is liberated, the program will be just as free, but users and developers will be able to use and adapt and improve the program in freedom
     
   • Embed this notice
     Alexandre Oliva (lxo@snac.lx.oliva.nom.br)'s status on Wednesday, 24-Dec-2025 10:06:29 JST Alexandre Oliva

     in reply to

     • Iron Bug
     what stops you from running the program for any purpose is not anything inherent to the program itself, it's an undesirable artifact and consequence of third-party power over you through other programs or libraries. so the program is freedom-respecting
     
     an incomplete program can also be free software, even if it's not complete enough to compile or run. the ethical problem that makes it nonfree is when freedom is denied by someone else who has power over the software (and thus over the user), not when the program fails to compile or run.
     
     CC: @eliseo01@fe.disroot.org
     
   • Embed this notice
     Iron Bug (iron_bug@friendica.ironbug.org)'s status on Wednesday, 24-Dec-2025 10:06:30 JST Iron Bug

     in reply to

     • Alexandre Oliva
     @lxo @eliseo01 it evidently breaks the first and foremost freedom: freedom to use. software that cannot be compiled and used is principally useless.
   • Embed this notice
     Alexandre Oliva (lxo@snac.lx.oliva.nom.br)'s status on Wednesday, 24-Dec-2025 11:15:56 JST Alexandre Oliva

     in reply to

     • Iron Bug
     you're free to (as in nobody is stopping you from) complete(ing) it so that you can compile it and run it for any purpose. so the freedom is there.
     
     it's not different from having to learn a programming language to be able to study the source code of a program, or having to study an algorithm to be able to make a change a program, or having to hire internet or post services to distribute the program. nobody controls the program so as to prevent you from doing these things.
     
     CC: @iron_bug@friendica.ironbug.org @eliseo01@fe.disroot.org
     
   • Embed this notice
     Iron Bug (iron_bug@friendica.ironbug.org)'s status on Wednesday, 24-Dec-2025 11:15:58 JST Iron Bug

     in reply to

     • Iron Bug
     • Alexandre Oliva
     @lxo @eliseo01 one cannot run uncompiled code. so the peogram that is not compilable with free software is not free. it cannot be usedv by users.
   • Embed this notice
     翠星石 (suiseiseki@freesoftwareextremist.com)'s status on Wednesday, 24-Dec-2025 11:31:27 JST 翠星石

     in reply to

     • Alexandre Oliva
     @lxo @eliseo01 If any software relies on proprietary software to work, then it is effectively proprietary software.
     
     Although, with 99% free software, replacing the last 1% is very feasible, unlike replacing 50% or 100% proprietary software.
     GNU Too likes this.
   • Embed this notice
     Alexandre Oliva (lxo@snac.lx.oliva.nom.br)'s status on Thursday, 25-Dec-2025 03:08:37 JST Alexandre Oliva

     in reply to

     • Vad fan?
     I see where we're miscommunicating.
     
     I'm not saying it doesn't matter.
     
     what I'm saying is that it doesn't change the program's qualification as free software.
     
     it still can't be built and run in freedom, and that is a key consideration that any user should pay attention to.
     
     but that source code is free software also carries important implications that shouldn't be dismissed.
     
     the miscommunication arises, AFAICT, from an apparent assumption that there's a full overlap between qualifying as free software and being usable in freedom
     
     the distinction is IMHO important: consider an undisputably free program written in C, a language for which a number of free toolchains exist
     
     now, say you get a binary (along with sources) compiled using a nonfree compiler. the risk you pointed out affects this binary just as much, and therefore it's best to avoid using that binary. I didn't dispute that it should be avoided.
     
     my point is that, because the program (source code) is free software, you can (more or less easily) choose another compiler to build it and avoid that risk. so the fact that it is free software matters as well
     
     of course, when a free compiler doesn't exist and it has to be made, it goes all the way towards the "not easily". one may then have to write a compiler, or translate the program to a different language, and then finally be able to run the program in freedom. it's not easy, but there aren't any roadblocks either.
     
   • Embed this notice
     Vad fan? (vikingkong@misskey.vikingkong.xyz)'s status on Thursday, 25-Dec-2025 03:08:39 JST Vad fan?

     in reply to

     • Alexandre Oliva

     @lxo@snac.lx.oliva.nom.br
     What the program looks like:#include <stdio.h>
     int main() {
     printf("Hello, World!");
     return 0;
     }What the program does:
     
     A FOSS compiler — prints "Hello, world!"
     
     A hypothetic compiler made by some evil corporation — does something evil and maybe prints "Hello, world!" You never know.
     
     Of course, I'm exaggerating here, but it's possible.
     So... Your stack fucking matters.

   • Embed this notice
     Alexandre Oliva (lxo@snac.lx.oliva.nom.br)'s status on Thursday, 25-Dec-2025 07:16:02 JST Alexandre Oliva

     in reply to

     • Vad fan?
     I think I see what you mean, and if so I agree with the feeling, but what you actually wrote seems too strict. for example, if one were to use a proprietary text editor to make a change to the program (that's part of the workflow, right?), one may have just as much assurance that the modified program does what it's intended to do by verifying the change with a free diff tool. and the use of the proprietary text editor, though undesirable, doesn't render the program nonfree.
     
     now, using a translation tool whose output is not practically verifiable (transpiler, compiler, assembler etc) may affect the freedom status of the output in the ways you describe and others. but the oppressor is not that who controls the compiled program, but that who controls the translation tool.
     
     see, I'm not disputing the oppression, only attempting to frame it so that the response is directed to the oppressing party instead of to the victim
     
   • Embed this notice
     Vad fan? (vikingkong@misskey.vikingkong.xyz)'s status on Thursday, 25-Dec-2025 07:16:03 JST Vad fan?

     in reply to

     • Alexandre Oliva

     @lxo@snac.lx.oliva.nom.br My point is plain simple: if you use any proprietary components in your workflow, you just can't guarantee your program does exactly what it's intended to do.