An even less popular programming language is your justification?

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.

>Red does compare itself to LISP in many ways, true.

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.

> Now we have much more powerful things, while you are still trying to catch up with lisps.

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.

>You're stated opinion seems to be that Clojure is playing catch-up

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

(the code is not idiomatic or good, it's just what I came up with to quickly demonstrate what I mean)

Well... Kind of.

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.

Ok, what I wanted to show is Red's parse is more than just pattern matching, since you can execute regular Red code in parsing rules, walk around the input and other things. You can check it's features here: http://www.red-lang.org/2013/11/041-introducing-parse.html

Variable, modifying... what the heck? You have a language that is crazy about mutability, it should make testing painful ;)

> Like Rebol/Red.

Well, that was unexpected.

It's too late guys, you should have tried to popularize Forth like 20-30 years ago.

>Forth

Why Forth? You just opened wiki Rebol article and first thing you saw was Forth, wasn't it?

I'm certainly not familiar with Rebol/Red, but every single time I've been introduced to them as "modern incarnations of Forth", and AFAICR they conserve right-to-left function application and the concept of dictionaries as dialects of the language, don't they?

Red is modern incarnation of Rebol, which is it's own unique language. It was influenced by Forth, true, but this is only influencing, Rebol has much more of it's own ideas than taken from others.

> Programmers wanted batch punchcards processing over timesharing interactive terminals, programmers wanted legacy and compatibility over innovation and modernization.

wow, really, all of them? that is amazing. tell me more!

>wow, really, all of them?

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.

> Small amount, obviously, tries to make better stuff.

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.

>but how small?

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?

> 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'm against new worthless implementations

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 it be you haven't yet realized it's actually not worthless?

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.

> tons of limitations

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.

>but that would only matter if those limitations outweighed the advantages of developing with lisp?

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.