On the other hand, we are so accustomed to take writing as the highest form of language that it seems insanely obscure and confusing to call a PL not a language because they do obviously have all sorts of things we expect from a language: words, punctuation, rules, etc.

The important thing to consider is not the lifespan of specific programming languages, but rather to look at the evolution of the linguistic structure involved in that language. From a PL perspective of looking at type systems etc, sure progress is quite rapid. But if you look at the linguistic structure involved, progress is much slower. When it comes to linguistic structure, all those C-like languages are the same, all those Java-like languages are the same, all those ML-like languages are the same. The nature of grammatical primitives and the shape of how those primitives can be combined, these things change very slowly.

In exactly the same way, we don’t look at the lifespans of individual speakers. Nor even the absolute duration in which some language has a living speaker. Languages evolve at different rates. With a small community that’s entrenched in the “right” way to do things, evolution is slow. With a large community that’s more willing to adapt, evolution can be quite rapid. The Great Vowel Shift happened in the span of one human lifetime! But rapid change like that is rather rare in general. A pidgin can remain a pidgin for generations so long as noone teaches it to their children as a primary language of communication. Absolute duration means very little when it comes to the evolution of languages.

It’s important to be clear here. I am not talking about the evolution of individual languages and their dispersion into language families. I am talking about the evolution of the *linguistic structure* which forms the foundation of what it is that’s evolving and dispersing. In the course of a generation, pidgins which lack most of the crucial linguistic structures required to be called a “real language” can be converted into creoles which possess all those structures. In that same timespan we don’t see individual programming language families evolving from string-based scripting languages to term-based programming languages, nor individual language families evolving from procedural imperativism to applicative functionalism. Instead we see language families dying out and being replaced by new ones which incorporate these new forms of linguistic structure. But even still, the whole linguistic community is very slow to change. In the physics simulating community Fortran is the lingua franca and C++ is still considered something of an upstart. The mainstream software industry is still using languages like C++, Ada, Java, and Python which are all effectively the same when it comes to linguistic structure.

C-style languages which lack applicative structure, lack any coherent namespace resolution system, lack linguistic support for polymorphism, etc, these kind of languages have been around for quite a bit longer than a human generation. All the greats who started computer science off before there were computers, they all used languages like this. C++ namespaces, which are rather ad-hoc and incoherent as namespaces go, weren’t even accepted in the original versions of the language spec. By the time Java came around we started to see modern versions of namespaces, but how many years passed between those old languages and the first version of Java? Hoare logic was already 25 years old when Java was released, and Hoare logic wasn’t exactly breaking new ground in the syntax of its object language.

Cobol is all but dead for new development, and it’s not even 60 yet. And Java, which is currently the world’s most popular language by many measures, isn’t even 20 years old. (Not even 16, depending on how you count…)

I mean, I understand (and share) your impatience, but computer languages haven’t really even got to the point that they’ve really stayed strong for more than one human lifetime yet. Fortran and Lisp will probably be the first; though the modern versions of the languages are far removed from the originals.

English, on the other hand, has changed much more slowly over centuries. If you could go back 500 years to 16th century England, you could still communicate pretty effectively, though it would require some effort at first.

It’s not clear to me what the future of PLs hold; on the one hand languages are now expected to be much bigger and tackle much harder problems, although we have better hardware, better techniques, and better software tools to help offset the difficulty. Certainly the rate of new language formation doesn’t seem to have gone down any.

A key difference is that natural language is primarily for bidirectional communication, whereas programming language tends towards unidirectional communication. I mean, it’s much easier to write code than it is to read it, and a very significant quantity of code never _really_ gets read by another human, even if it’s open source. (And, most code that does get read only gets read a small number of times.) And I think that enables programming languages to evolve relatively quickly.

I’d be hesitant to call the old languages like assembler, Fortran, or Cobol “languages” in the colloquial sense and not a technical or metaphorical sense. But more modern languages like Haskell and Perl resemble natural language far more than they’re given credit for. One of the problematic issues here is that there are some very old discourses at stake here, both for and against the idea of programming/computer/mathematical languages as languages; and unfortunately, I think some of the past advocates for the idea have done more damage to its reputation than the critics (because those advocates are typically more interested in mathematizing natural language than in languagifying mathematical formalisms).