A Rebuttal of Some Articles Written by a Fanatic

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:
https://drewdevault.com/2020/01/04/Slow.html

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:
https://drewdevault.com/2019/03/25/Rust-is-not-a-good-C-replacement.html

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:
https://drewdevault.com/2020/03/03/Abiopause.html

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:

 In the world of software, the C programming language clearly stands out as the single most
 important and influential programming language.

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:
https://drewdevault.com/2019/02/18/Generics-arent-ready-for-Go.html

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:

 So it's my hope that Go will hold out until the right solution presents itself, and it hasn't yet.
 Rushing into it to appease the unwashed masses is a bad idea.

The following is a quote from one of the creators of this language, of the intended programmers:

 They're not capable of understanding a brilliant language but we want to use them to build good
 software.  So, the language that we give them has to be easy for them to understand and easy to
 adopt.

This language is made to use victims as unintelligent implementing machines and easily replace them.
.