in search of ++C
in C, and in many other C-like languages, the unary operator
++ has both a postfix version
and a prefix version. both uses of the operator increment
the operand, but when you use the whole expression as a
value (for example, (a++) + 2),
there exists an important difference. when ++
is postfix, the statement as a whole has the value of the operand
before it was incremented, and if it's prefix, then the
statement has the value of the operand after it was incremented.
as an example, if a variable x is
initially set to 0, then the expression
x++ equals 0,
while ++x equals 1.
C++
the reason for this poor explanation is to set up the a messy metaphor
that I'm basing this blog post on: C++, when taken literally, doesn't
have a greater value than C. you could say that C++ went off in the
wrong direction from C; instead of fixing the problems that C had,
all C++ did was tack on new features in a way that made it a very
imperfect "improvement" upon C. in the rest of this post, I'm going
metaphorically say that ++ represents "false improvement" upon C (as
with C++), while a prefix ++ represents "true improvement."
++(C++)
if there's a ++(C++), it's definitely rust, for pretty obvious reasons.
I don't personally like rust for many reasons, including that it's
already getting too large and incomprehensible in the same way that C++
has gotten over the past N years. I also think it's a problem that
rust's philosophy doesn't prioritize simplicity and readability, instead
opting for the naive decision to make programmers subordinate to the
language. there's a bad habit lots of programmers seem to have where
they implicitly treat complexity as good, because having difficult
languages allows a hierarchy of ${difficult language} programmers to
exist.
++C
what we need (instead of rust) is a language that makes a real improvement
upon the foundation of C++. instead of opting for C++'s fetish for
complexity, complicated specs, and trendy features, "++C" would carefully
fix the problems of C, adding some new features but cutting away many
others. right now, go and zig are probably the closest to this idea of
"++C", but I think in the future there can still be even better languages
made that try to be "++C".