C is one of my favorite programming languages, but writing C code is always a
little strange. When we use C, we sort of "pretend" the core C philosophies are
good. We ignore the issues with declaration-follows-use, textual macros,
`#include`, goto, type declaration, and implicit casting. These ideas have been
proven flawed by history, but they are still solid enough that we can build good
software on top. But why not use other languages?

If you write Rust, your code will only ever run in rustc. The language is
constantly evolving, so even if you write a compiler now (which would be very
difficult), it would be outdated within a year. These days, this is normal; each
language has one implementation, controlled by the owners of the language. But I
think this is really strange. Imagine if a programming language could only be
used with a specific editor. Developers would be frustrated about the lack of
control. This is probably why no visual programming lanugages have succeeded.

C is small and easy to implement. There are many different compilers, and many
of them are [small] [enough] you can [modify] them. (See: [[very open systems]])

C is simple because it avoids convoluted industrial language features, like
inheritance, [colored functions], or garbage collection, and it also lacks small
systems langauge conveniences, like tagged unions, generics, and modules.
Because all types must be declared up-front (i.e. via headers), it's one of the
only langauges that can be compiled in a single pass. That's why `#include`,
type declarations, and textual macros make sense. C's design is less about
cleanliness and more about providing syntax for common machine code patterns. As
Richard Gabriel put it:

> Old programs read like quiet conversations between a well-spoken researcher
> and a well-studied mechanical colleague, not as a debate with a compiler.
> Who'd have guessed sophistication bought such noise?
>           - Guy Steele & Richard Gabriel, 50 in 50 Keynote, YOW 2010 Melbourne

There's a sense of feature starvation in C. Code is never 'too clever' - there
isn't enough in the language to be clever with. This ethos seeps into the rest
of the ecosystem. If you fully understand a language, you can work *with* it,
not against it: you can adapt it to yourself, or your environment, or you can
use it in completely new ways (See: [Liberating the Smalltalk in C]).

At least, that's the great C that sits entirely in my head. It can sit in your
head too. But it doesn't quite exist. In the real world, languages are made by
committees, governed by imperfect proceses and fallible humans. In the real
world, we have C89, C99, C11, C17, and C23, which have accumulated a greater
volume of historical mistakes for each revision. Today's versions of C *cannot*
be reasonably compiled in a single pass - not because of any large new features,
but because of odd edge-cases and backwards compaibilty buildup. C's philosophy
is great for simple compilers, but C's implementation is not.

But you can still write in the great C. Many people still write in C99 and use
C99 compilers and libraries. Some C programmers are actively hostile to the "C
committee", and don't use their newest features. That's pretty unique in a
culture that constantly praises and debates new features. C is one of the only
languages nobody owns. There's power in that.