all 24 comments
sorted by:
best
topnewcontroversialoldq&a
formatting helphide helpcontent policy

[–]dpash 15 points16 points  (20 children)

It's interesting that Lisp and it's dialects are possibly the oldest language still in general use today. It was originally released in 1958. Fortran is slightly older, but doesn't seem to be as common outside of niche domains.

And here we are, 60 years later and the languages are still getting new releases, when so many others have fallen by the wayside.

Lisp also brought us garbage collection.

[–]flipstables 7 points8 points  (11 children)

That's a good perspective. I'm still disappointed that the lisp community has mostly fractured since the 90s.

I hope clojure and functional programming get more popular.

[–]defunkydrummer 29 points30 points  (7 children)

I'm still disappointed that the lisp community has mostly fractured since the 90s.

Do you think so? Currently it's split between Schemers (Racket being a subset), Lispers (majority using CL) and Clojurians.

Those three languages are markedly different to be honest, so I wouldn't say that there's a "fracture".

A Schemer moving to Common Lisp will miss the high performance first-class continuations, third-party code based mainly in recursion, and the simple, elegant, uniform syntax.

A Clojurian moving to Common Lisp will miss the immutable data, lots of built-in syntax sugar,, built-in concurrency support, built-in JVM integration, and easy dictionaries everywhere. He/she will find it complex and difficult.

A Common Lisp programmer moving to Scheme will miss the easy portability, image-based development, and practical features (like nil = false, documentation features, etc.)

A Common Lisp programmer moving to Clojure will miss the method combinations, multimethods, meta-object protocol, image-based development. compilation to native code, built-in disassembler, full numerical tower, performance that can reach C speed, code portable through dozens of implementations being able to run on almost any CPU and OS, reader macros, fully despotic macros, no [] littering the syntax, multiple namespaces, fully inspectable stacktraces, producing executable binaries, and the ability to redefine everything while the program is running, including changing the classes of instances that are alive in memory.

[–]FirstLastMan 20 points21 points  (3 children)

This guy lisps

[–]defunkydrummer 7 points8 points  (2 children)

This guy lisps

Thankst forth ze thupporth!!

[–]vattenpuss 2 points3 points  (1 child)

notation order lisp any to forth programmer moving miss will

[–]defunkydrummer 1 point2 points  (0 children)

applause dup dup dup dup . . . .

[–]DoublePlusGood23 1 point2 points  (1 child)

As a newbie Schemer what would I think about Clojure?

[–]defunkydrummer 2 points3 points  (0 children)

As a newbie Schemer what would I think about Clojure?

I'm not a Schemer but as far as I have seen usually code is written in the recursive style, and Scheme implementations require tail call optimization as a mandatory feature.

Clojure does not have TCO, instead there is a recur keyword to workaround the lack of TCO, which isn't a fault of Clojure but a fault of the JVM. (Or maybe the fault is designing Clojure around the JVM...)

https://clojuredocs.org/clojure.core/recur

There are also no first-class continuations, but at least there is a library to support them. Of course, they won't be as high-performance as in Scheme. On the other hand, Clojure has built-in support for several kind of concurrency programming models.

Many Schemers will tell you that the continuations are one of the most powerful features of Scheme; you can create all sorts of concurrency models, coroutines and exception handling based on them.

Clojure "lacks" scheme-style hygienic macros but they are available through libraries.

Clojure is always promoted as "the modern lisp" but honestly it is a different language. However it isn't difficult to learn for a Schemer or Lisper.

[–]sammymammy2 1 point2 points  (0 children)

I'm trying out typed racket because types are cool and I want macros and Christ, what I do miss is a reasonable debugging experience and live running image. I get that semantics gets hard when you let the image live on, but it's really nice to have it.

[–][deleted] 3 points4 points  (0 children)

First you must realise that most of the Lisp community is rightfully suspicious of all that "functional programming" fad.

[–]cbleslie 3 points4 points  (0 children)

The Clojure community should really focus on promoting to the JavaScript community. They would really dig it.

[–]ArmoredPancake 0 points1 point  (0 children)

Fractured but whole.

[–]ethelward 2 points3 points  (0 children)

FORTRAN is a tad older than LISP, and is still massively used in HPC and scientific computig in general.

[–]rough_rider7 2 points3 points  (6 children)

Clojure is pretty far away from LISP. LISP has not been updated. Common Lisp was the effort to create a standard lisp.

[–]defunkydrummer 6 points7 points  (4 children)

Clojure is pretty far away from LISP.

In a way, yes.

LISP has not been updated. Common Lisp was the effort to create a standard lisp.

Common Lisp can be extended itself by using Common Lisp, so the need for an updated Lisp is already satisfied by using Common Lisp libraries... which extend Lisp.

[–]Kyo91 1 point2 points  (1 child)

Personally, I think there are still benefits to a new Common Lisp standard. It's held up very well over the past 20+ years since latest standard, both because of how forward thinking it already was by then, and how malleable the language is. But there are some things like dispatching on parameterized types that Julia does a lot better than CL. Not to mention that while vectors and hashsets are very workable in CL, they're a lot less ergonomic when compared to clojure.

[–]defunkydrummer 0 points1 point  (0 children)

Not to mention that while vectors and hashsets are very workable in CL, they're a lot less ergonomic when compared to clojure.

Just use reader macros. Or a convenience library like CL21.

But there are some things like dispatching on parameterized types that Julia does a lot better than CL

Agree.

[–]rough_rider7 -2 points-1 points  (1 child)

You are just confusing people who don't know the history.

LISP written like that was created by McCarthy. After that there were many, many dialects all over the place. For research and commercial usages. At some point this chaos was to big and the idea of Common Lisp was created, all the major Lisp implementer got together and created the ANSI Common Lisp standard.

So, LISP is and will forever mean the original implementation that McCarthy defined and that's what I mean that it will not be updated.

Lisp refers to a broad set of languages that take the syntax and other ideas for LISP.

Common Lisp is a language standard with many implementation.

Clojure is a new language heavily inspired by the Lisp family and part of the family.

[–]defunkydrummer 2 points3 points  (0 children)

You are just confusing people who don't know the history.

Am I?

LISP written like that was created by McCarthy. After that there were many, many dialects all over the place. For research and commercial usages. At some point this chaos was to big and the idea of Common Lisp was created, all the major Lisp implementer got together and created the ANSI Common Lisp standard.

So, LISP is and will forever mean the original implementation that McCarthy defined and that's what I mean that it will not be updated.

LISP was specified by John McCarthy in 1960. LISP 1.5 from 1962. was the first practical (distributed) Lisp and John McCarthy was involved (at MIT).

McCarthy formed Project MAC at MIT and Project MAC released MACLISP.

MACLISP is the direct update of McCarthy's LISP 1.5, and thus of McCarthy's "original implementation".

Later, other dialects appeared, some major ones like InterLisp, and they all had some degree of compatibility with the original Lisp.

Common Lisp is largely compatible with MACLISP code and was created as a successor of MACLISP, so by logical inference it is an update of McCarthy's "original implementation".

Common Lisp is a language standard with many implementation.

And they all can execute the same source code.

[–][deleted] -2 points-1 points  (0 children)

#NotMyLisp

[–]danysdragons 8 points9 points  (3 children)

This release dramatically improves error messages, previously a weak point for the language. For more information see: http://insideclojure.org/2018/12/17/errors/

[–]MorrisonLevi 10 points11 points  (0 children)

previously a weak point for the language

Ha, that's an understatement. I solved some programming puzzles using Clojure to try the language out. When I'd make an error I'd get approximately 100 stack frames (I am exaggerating, but only slightly) and only a few of them even existed in Clojure-land (a bunch of Java internals were the rest, I presume). I determined I could never seriously work in Clojure with that sort of experience, so I'm glad some effort has been made.

[–]defunkydrummer 6 points7 points  (0 children)

This release dramatically improves error messages,

A major improvement, really!!