I occasionally come across articles or other such things from a POSIX fanatic, and his latest at the time of writing was so ridiculous that I've now decided to rebut it and several of his other pieces.
The first article may be found here; the followup article is irrelevant for my purposes.
That ``ideal'' assembler language program presented is incorrect, as it ignores that the POSIX write system request can fail and must be tried in an adjusting loop. Now, there's probably an adjustment of settings, sizes, and configurations that have this program working on its very particular system, yet that doesn't properly solve the problem and showing an incomplete solution which will break with subtle changes and also not noting this is typical behaviour of a POSIX fanatic. I believe he knows his assembler language program is subtly incorrect, and so is being purposefully misleading.
Going further, this manner of micro-optimization is boring. A ``hello word'' program is still quite suited to the particulars of POSIX and C. Introduce an example which performs any manner of complex and interactive calculations and the C will soon show its many flaws compared to the others.
The second article may be found here.
It's telling that when considering stability, neither Ada nor Common Lisp are mentioned in any form. Following, it seems every mention of C being the most portable programming language entirely ignores the Forth programming language and the variety of hardware it runs on that C isn't at all suited to, because that hardware ``doesn't count'' or other asinine reasons. The C language has a mere pair of Free Software implementations which are used in almost all cases. This article ends arguing against concurrency and safety, because his preferred languages make these more arduous than necessary.
The third article may be found here; this is what inspired me to start this potential slapfight.
The first three paragraphs are waste, as if the author's preparing for a journalism job where you're paid by the word. This sentence is what was so at the height of his ridiculousness:
Given his other works, I know he shouldn't be so ignorant so as to ignore everything before 1972 and yet he does; this is another commonality with POSIX fanatics. Firstly, C is an ALGOL-like language, and, if any language, ALGOL may deserve the title of ``most influential''. Secondly, C persists due to POSIX, which demands C due to its poor design and abstraction.
I've seen this man argue that a Common Lisp implementation written almost entirely in Common Lisp is really just a product of C, because it contains some C for its lowest levels. The circular argument is typical: Look upon a system which only exposes functionality through C, observe that C is so poor it requires using a C compiler to properly interface with it, and then boast about how many programs contain some C. Even if the C were replaced with machine code, this breed of fool will move to cite the underlying operating system as the source of C or I figure eventually Internet nodes, if pushed. You'll notice that the best thing a C programmer ever has to say about the language is it's popular.
This also betrays a fundamental lack of understanding, when dealing with abstractions, purposeful or not. If I write a program in a standardized language, the implementation doesn't matter, and yet it will be insisted the implementation has somehow touched the program if this is advantageous. Truly, the reach of C, to these people, touches down to that lowest part of the machine, except the machine code, because that clearly doesn't count.
Moving on, the note on ABIs specified in C calls to mind my 2019-11-22 article criticizing UTF-8 and Unicode, in that C and POSIX are designed to be catered to in every way, and yet accomodate nothing.
All of Lisp, APL, Simula, ALGOL, Smalltalk, Forth, and many others existed before C. To believe the C language is in any way comparable to the Sun in this fashion is sheer idiocy. A properly designed system lacks this ``abiopause'' issue by specifying types, subprogram specifications, and other such things in a fashion suited to more than a single language; I understand VMS did so with its ``Common Language Environment''.
I don't disagree with all of this man's writings, but thought this would be reasonably fun to rebut.
The fourth article may be found here.
The article starts with accusing anyone who disagrees with him of not having read the article. This continues by dismissing criticism of the language, although this hasn't stopped him from giving such opinions on languages he doesn't actually know.
The language typically has poor or no listed reasons for lacking, unlike any well-designed language; one such lacking involved a monotonic time system, and it was only added after it caused issues in a large corporation. This is a good example of the flaws with this hideous language and its attitude.
I use Ada as an example of a language with more complex rules, but which works better for real-world purposes, as a system with a simpler internal world may just not address issues of reality at all.
The issue of reusable algorithms and data structures was solved reasonably well not long after being first encountered in computer programming, and many more good solutions have been created since. To seriously argue there's no good solution, and so this language is fine to lack any, is nothing short of asinine. A generics system as in Ada is a fine solution, and it has this as it exists to address real problems; a dynamic typing system as in Lisp is another, rather trivial solution to this issue.
He claims languages shouldn't strive to solve every problem, and I agree, but fails to recognize how this language isn't actually compelling for any specific problem, unlike APL. I believe these silly ALGOL-likes tend to differentiate themselves on purpose, as they've naught which is intrinsic to use for this.
It's unsurprising this fanatic enjoys this language, being a continuation of the POSIX, C, and UTF-8 nonsense. He writes the following:
The following is a quote from one of the creators of this language, of the intended programmers:
This language is made to use victims as unintelligent implementing machines and easily replace them.