3 ms·
"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 th
by jerf 10y ago
"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.
- nickpsecurity 10y agoI 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.
- sheepleherd 10y agoearly 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.
- hyperpape 10y agoJava 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.
- Someone 10y ago"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)#Examples 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'); }
- TheGrassyKnoll 10y ago"...Python has smoothly evolved..." Well, not exactly.
- cm2187 10y agoYou 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.
- raattgift 10y ago"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.
- lispm 10y agoThere 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.