"If it cannot be read and completely understood in a month, it's broken beyond repair."
My new mantra in #FreeSoftware development.
@Shamar
Do you grant exceptions to enormous projects, or is considering them broken a feature? :>
No exception.
Enormous projects produce enormous risks (when not enormous threats).
It's time to move beyond the stone ages of #Informatics.
@Shamar
Do you have any compilers you like? They seem to be kind of big and complicated by necessity, and I am wondering whether there are some simple ones that are still useful.
I used to trust #GCC.
I spent a huge amount of my free time over the last 2 years to port it to my operating system (a Plan 9 fork).
In fact, Jehanne has been the first Plan 9 fork to run a modern GCC (9.2.0) and compile C++ programs correctly.
Then, with the removal of #RMS by the GCC Steering Committee, I realized they cannot be trusted: https://gcc.gnu.org/pipermail/gcc/2021-April/235285.html
Indeed they are discussing to leave #GNU in these days.
Now I'm exploring the alternatives.
So far, #TinyCC looks promising: https://bellard.org/tcc/
Other alternatives are listed here http://suckless.org/rocks/ but some requires either linker or assembler.
And while I obviously ported GNU binutils too, I prefer to avoid this toolchain since they are all showing they do not give a shit about free software, but about "#IBM, #Google, #Facebook, #ARM, or other big supporters" https://gcc.gnu.org/pipermail/gcc/2021-April/235367.html
A serious alternative could be the 9front compiler suite that I dismissed years ago because I was still naive (dumb).
Also, it's urgent to design better programming languages, and for "better" I mean simpler both for humans and for compilers/interpreters. So that all people will be able to read the software they use.
But the point remains: if it cannot be completely read and understood in at most a month by a single professional programmer, it's broken beyond repair and need to be replaced.
@Shamar I was mostly interested in the simplicity aspect, I think most compilers I know would not satisfy the "one month" requirement. Politics aside, do you think gcc can be understood within a month?
Strong agree on better programming languages being needed, but the ones I consider good for creating programs that follow the simplicity ideology are not that simple themselves, and definitely don't have simple compilers. I expect there might be some very hard to resolve conflict between these requirements.
GCC does not satisfy the "one month" requirement: that's why we need better compilers (and languages)
But this IS a political issue!
If you cap complexity, you reduce costs and this way you reduce the power corporation can extort to users.
If you can rewrite anything you run in a month, no company is going to betray your trust.
As for the "simplicity ideology with complex compilers" you are talking about, I think you are confusing simplicity and easiness.
Simplicity is very different from easiness: simplicity provides freedom, easiness produce lock-in. But more often than not, simple tools requires more mental effort than easy one.
IMHO simplicity should always be preferred in Free Software.
That makes sense, I was worried there for a moment that I was vastly overestimating how complicated gcc is.
I know that Free Software is inherently political, I only wanted to skip over the personal politics surrounding RMS right now, and couldn't think of a better word for that.
I haven't heard this argument about the political implications of simplicity, I usually value it for its directly practical results of avoiding bugs. The argument sounds correct and quite interesting.
Oh, I'm pretty sure I'm not confusing these two. In my experience the languages which are best for writing simple programs are, among other properties, quite strongly typed. These languages are arguably more complex than weakly typed ones, and their compilers are _definitely_ more complex, type checking is a provably (heh) hard problem. So I understand the simplicity/easiness distinction, although I guess I might have a slightly different view on which languages are best for writing programs with a simple design.
