> Now we have much more powerful things
Like what? Off the top of my head, Rust, Haskell and F# are probably the only ones that come close, and they're about as popular as the Lisps (i.e. not).
> you should have try to popularize lisp like 10-20 years ago.
Programmers want familiar syntax and infix notation while Lisps want homoiconicity. It's never going to happen.
It's funny because people fear and loathe Lisp's parenthesis, while after a month of using Lisp, you don't see parens anymore (they're mostly for the parser).
With parinfer, you stop looking at the parens in about an afternoon, I guess, and start reading indentation as in python. At some points, you look at opening parens as alignment markers, and from time to time you need to close something before what is inferred, but always in the same line, I.e., you want:
(Foo (bar) baz))
(Foo (bar baz)))
It was called Dylan, but then Apple canned the project.
Like Rebol/Red.
>Programmers want familiar syntax and infix notation
Programmers wanted batch punchcards processing over timesharing interactive terminals, programmers wanted legacy and compatibility over innovation and modernization. Programmers wanted ugly write-compile-run-test in 70s terminal emulator stuff over live interactive graphical in-place debuggers. Face it, programmers are stupid and can't learn new technologies.
Red does compare itself to LISP in many ways, true.
But Clojure, for example, is actually popular enough that places use it for real work, today.
Not only compares, it does extend many things which Lisp failed to do when it became unpopular.
>But Clojure, for example, is actually popular enough that places use it for real work, today
Yes, and this is very good, because it gives many people idea that programming may be much better than they used to. My position here is that Clojure is only the beginning.
You're stated opinion seems to be that Clojure is playing catch-up, not that it is the beginning of something better.
Also, as someone who uses Red & Clojure, I'm curious why you think it's more powerful?
I would compare Parse, Red's most notable feature, with core.match from Clojure.
Not really, it was about Zygomys, Clojure did it thing long time ago and proved it has something to offer, like STM in the core of language.
>I would compare Parse, Red's most notable feature, with core.match from Clojure.
I don't know the internals of core.match, but can it change rules in runtime like this?
red>> rule1: ['a]
== ['a]
red>> changer: [(append rule1 [| 'b])]
== [(append rule1 [| 'b])]
red>> parse [a a b b] [any rule1 [number! changer | ] any rule1]
== false
red>> parse [a a 1 b b] [any rule1 [number! changer | ] any rule1]
== true
Clojure is crazy about immutability, so it makes live modifying any variable painful.
However, core.match is usually used with a loop, so it should be possible with some nested lets.
Well, that was unexpected.
It's too late guys, you should have tried to popularize Forth like 20-30 years ago.
Why Forth? You just opened wiki Rebol article and first thing you saw was Forth, wasn't it?
wow, really, all of them? that is amazing. tell me more!
If all of them would do it, we wouldn't have this discussion now. Small amount, obviously, tries to make better stuff.
>tell me more!
First go and check out plan9, genera, smalltalk and rebol.
interesting! but how small? like maybe as small as amount of early lispers working on making better language? would that be a valid comparison?
> plan9, genera, smalltalk and rebol
done.
No idea, I keep discovering stuff from past 30 years which I never even heard about, I can't imagine how many new technologies appear in our time.
>done.
So, do you find things programmers are using in their daily work good?
i find programmers using full spectrum from horrible to amazing. the reasons some people stay on lower end of that spectrum range from psychological to business constraints. i think more interesting question is why is it that while considering yourself being somewhere in the upper end of the spectrum you decide to shit on lisp, which arguably is the starting point of everything you deem good.
I don't shit on lisp, I've been for lisp since I discovered it many years ago. I'm against new worthless implementations presenting lisp as language only capable to parasite on other platforms, without having it's own real thing.
To me lisp is an idea, which ironically found it's best implementation (from what I've seen so far) in Rebol.
could it be you haven't yet realized it's actually not worthless?
> only capable to parasite on other platforms
would you elaborate what exactly makes clojure a parasite on jvm?
could be, I didn't even run it, but the problem is your implementation limited by underlying platform and if it wasn't made with lisp in mind (and this is the case) result will have tons of limitations.
>would you elaborate what exactly makes clojure a parasite on jvm?
Maybe it's ok for JVM, but I can tell you what makes it less lisp (and the reason is parasitism): absence of tail recursion.
but that would only matter if those limitations outweighed the advantages of developing with lisp?
> absence of tail recursion
so from "clojure is worthless parasite on jvm" we're down to "clojure is a lisp which i haven't tried yet but it's on jvm so i think it lacks tail recursion"
good enough, peace.
Yes, and I doubt this Zygomys can reload code in runtime because of limitations of it's platform.
>so from "clojure is worthless parasite on jvm" we're down to "clojure is a lisp which i haven't tried yet but it's on jvm so i think it lacks tail recursion"
Nope, I wasn't talking about clojure.