"However, one might treat them as separate languages given LISP 1.0 is very different from Common LISP which isn't Scheme or Clojure."

Well, on the one hand that's true. But on the other hand, a lot of the living languages have that too. BASIC is 52 years old, sure, but no 52-year-old BASIC program would even compile in a modern BASIC, and I mean, it's not even close, not like a couple keywords or some chars here or there, but the entire structure of the language is fundamentally different now.

By that standard: C is still recognizably the same. I'd suggest C++ is a different language before and after templates, which cuts it down to 27 years, and if you wait for the STL to be usable before you say they "took", less than that, but I imagine a lot of the early C++ would still compile or nearly so. Python has smoothly evolved and I can't point to any one feature that was a hard transition, but it is a fairly different language today than it was in the 1-1.5.2 era, but a lot of the 1.5.2 would still run OK. Javascript has actually been relatively stable as a language, coming out of the gate with rather a lot of stuff already built in. Java has also been pretty stable as a language. I don't know enough about Fortran or COBOL.

Lisp is an amusing case where a lot of old Lisp is probably reasonably close to parseable but probably doesn't run at all beyond the basics.

I fully acknowledge there's some subjectivity to the judgments here, but I think part of the 100-year-language idea is that code in the 100 years language should still be usable 100 years later, directly. By that age measure we're shorter on viable languages, though we still have some.

"C is still recognizably the same."

I wouldn't state that so categorically:

    foo(x)
    {
        return x+x;
    }

or

    bar(x)
    float x;
    {
        return x+x;
    }

If you didn't live when that was C, I'm not sure you would recognize it as such. Certainly, I could claim it was B, C's precursor and get away with it with quite a few people. It doesn't look that different from the example at https://en.m.wikipedia.org/wiki/B_(programming_language)#Exa...:

    printn(n, b) {
        extrn putchar;
        auto a;

        if (a = n / b)
            printn(a, b); /* recursive */
        putchar(n % b + '0');
    }

"a lot of old Lisp is probably reasonably close to parseable"

I think you would be hard-pressed to find any old Lisp code that a modern READ cannot turn into a list which could trivially be transformed into a valid s-expr in that dialect.

The reverse is much less true, since modern Lisp-like languages allow many more characters, are often case-independent, and often have standard "decorations" (e.g. &REST or #:optional).

Common Lisp is so kitchen-sinky that you'd be hard pressed to find old Lisp code that was then reasonably portable that will be outright hard to port to a modern CL implementation. Most of it will probably run as-is, or with a thin macro package doing mechanical translations.

Unportable code is unportable code. If it was so tied to e.g. Allegro that it wouldn't run in any other CL environment, that's hardly the language's fault.

However, really early Lisp stressed the "S" part, and rarely did anything strongly system-specific.

There are some variants of Lisp which are not trivial to port to Common Lisp. Something like Standard Lisp is slightly difficult due to various reasons. Somehing like Interlisp is also difficult, because much of its functions and libraries work quite different from Maclisp/Common Lisp.

Java is interesting because it's always prioritized backwards compatibility, but the changes that have shown up recently or are in progress are pretty big: lambdas, value objects and type inference can all be argued to go against some important aspect of how the language was originally conceived.

You might argue it's changed the least, but only because all languages change a great deal.

I agree with all of this except maybe C. I don't have time to evaluate that in detail so no opinion. I especially like your definition of what constitutes 100 year old code or language. I think we can compromise between two definitions by differentiating between how old a language family/style is vs a specific variant or implementation of it. The LISP family and style is decades old but supported implementations are much younger.

You can say that of any language. Today's javascript has little to do with the pop-up opening nuisances of the 90s (even if it still also does that!).

And even today's Visual Basic has gone a long way from the VB6 that most people remember VB by.

early C++ compiling wouldn't be the problem you wouldn't uncover...

I worked on a large early C++ project and we had problems on the scale of a couple of years. Even if C++ wasn't changing, the compilers were.

"...Python has smoothly evolved..." Well, not exactly.

FORTRAN isn't the same language either. Much like LISP, it evolved over time. Things like line numbers and GOTO statements that made people hate the language are not really mandatory -- it is basically as structured as C these days.

Obligatory and relevant Hoare quote:

“I don't know what the language of the year 2000 will look like, but I know it will be called Fortran.” —Tony Hoare, winner of the 1980 Turing Award, in 1982.

Given how things turned out, he might have better said:

"I don't know what the language of the future will be called, but I know it will look like C."

In some ways Fortran is more advanced than C and even C++, e.g. had modules since Fortran 90, pure functions and so on ...

It is a very different language from the original Fortran.

It's been evolving a lot. They're at least honest about that as they put the year after the Fortran type.

Ha, good list. Never worked on it, but I've read that the Pick environment (OS + language + DB ...) is still used. It's quite old, ~50 years, according to:

https://en.wikipedia.org/wiki/Pick_operating_system

Regarding LISP, perhaps the perspective that does count LISP and its descendants as one ongoing evolution of a similar language family is the same perspective that will allow that lineage to last 100 years?

I feel that the systems that change over time have the best chance of weathering it.

1960s Lisp code can still run on Common Lisp with only minimal changes -- e.g. http://elizagen.org/. A reboot like Racket or Clojure has more chance of making it alive to 2060, but I wouldn't quite rule out early Lisp yet.

It could. That might normally be considered cheating but LISP is actually designed with philosophy of customizing language itself to problem domain. Thing is, the implementations and even language features of modern LISP's are nothing like McCarthy's simplistic language and interpreter. They couldn't succeed being that due to performance and usability issues.

So, I think it's more fair to talk about LISP languages as an ongoing family but still a cheat to treat a modern one as original LISP. Probably should date it from creation of dialect or similar one.

Certainly, but the borders aren't so obvious to me. Is any language going to last 100 years without changing so much it feels 'nothing like' it's origin point?

Even if it hasn't changed in name, it may have changed in spirit. Some languages that promote themselves under very different names are substantially more similar than other cases where new language versions are dramatically different.

What 'essence' makes it the 'same language'? An interesting problem.

COBOL or Pascal if you don't use modern features lol. Idk. It's an interesting question about how we count the changes against the language's lineage. I don't have an answer to that one. We need a debate about it on StackOverflow that moderators close as "not constructive." Those are the threads that usually have great insights into issues like this haha.

Thanks for mentioning algol and cobol! Its easy to forget these languages since they are mostly used on mainframes.

Algol used to be language you submitted things to the ACM in I think and is the systems programming language of the MCP, which my dad still programs in to this day!

It is interesting how many languages had an algol style syntax until C stole the show. I am not sure the world is better for it.

"is the systems programming language of the MCP, which my dad still programs in to this day!"

That's pretty neat. Everyone thinks Burroughs died but they just changed names. Make crazy money. System is quite dated, though, in features and interface. No denying that. ;)

"It is interesting how many languages had an algol style syntax until C stole the show. I am not sure the world is better for it."

I'm not sure on syntax. Decisions by top languages in terms of safety or reliability show ALGOL and Pascal families were right about those. You might like to look at Modula-3 and Component Pascal to see where things might have gone in a parallel universe.

https://en.wikipedia.org/wiki/Modula-3

http://blackboxframework.org/index.php?cID=why-program-in-co...

Note how power, yet simple, Component Pascal is by looking at the full language grammar in two pages of Wikipedia:

https://en.wikipedia.org/wiki/Component_Pascal