Hacker News Reader

Comment by dysoco | Hacker News Reader

Well, the same happened to LISP languages. They never seem to get a lot of traction... until Clojure appeared.

I think that's part of what PommeDeTerre is asking; is there any oxygen left over for a JVM Scheme variant in a world with Scala and Clojure? (And an already-existing line of other languages trailing behind them.)

If this were just some other open source project, I'd say go nuts, but we've got a guy here who presumably could get a very good job volunteering to live on raman for 4-6 months to do this thing, so I think this question needs to be considered, even if the answer is ultimately "yes".

The reason you don't see many implementations of Scheme is that Java's calling conventions do not jive well with tail call optimization. This is the same reason that Clojure has the recur keyword: http://clojure.org/special_forms#Special Forms--(recur exprs*)

See also Scala's compiler, which detects and re-writes tail calls as stackless iterations (http://oldfashionedsoftware.com/2008/09/27/tail-recursion-ba...)

Wondering when the "Clojure has a big traction" meme will die already, or at least be qualified with "in HN discussions". I give it a year.

The Smalltalk equivalent of Clojure is Ruby.

Could you elaborate on how you see Ruby as a modern Smalltalk?

Seriously?

Ruby block syntax is straight up lifted from Smalltalk, not to mention much of the semantics and standard library. Ruby seems like what Smalltalk would be if it was built as a scripting language with file-based structure... and then dragged through the mud of Perl syntax. ;-)

No need to be condescending, I was genuinely curious.

At first glance, the two languages seem similar, but not as much as Clojure is to CL (or any other lisp).

It's hard to detect if a terse question is a request for information or a challenge. Back to the subject, Ruby's OO is much closer to Smalltalk's vision. Method dispatching in Java is essentially dereferencing a function pointer (found by traversing a class hierarchy) and adding a hidden argument (self.) In Ruby, you can override an object's method dispatching mechanism to be whatever you want it to be (although the default behavior is very similar to Java's.) This makes it a lot harder to optimize, (your JIT compiler can't simply inline those calls) but it opens all kinds of interesting meta-programming possibilities.

For anyone interested in the general topic of implementing a dynamic language on the jvm, Charles Nutter has a ton of good material around invoke dynamic and jruby.

As a CL developer with only a bit of dabbling in Smalltalk and Ruby, Smalltalk and Ruby seem much more similar than CL and Clojure.

In particular, Clojure's preference for vectors over lists in many situations, combined with its much stronger preference for immutable objects makes it highly distinct from CL.

The requirement for explicit trampolines to allow efficient tail-calls makes it distinct from any (non-toy) lisp I've ever used.

Sorry, I wasn't intending to be condescending. I thought you were making a joke.

Ruby block syntax may have been inspired by Smalltalk, but this is where the similarities end. Ruby block implementation is simply awful (an afterthought?), and no way near as powerful (and simple) as the equivalent in Smalltalk.

> Ruby block syntax is straight up lifted from Smalltalk

Uh... no it's not, it's lifted from C/Perl with a smattering of Pascal.

> not to mention much of the semantics and standard library.

The semantics are as much Perl as they are Smalltalk, if not more so. And many pieces of Smalltalk are missing (first-class blocks to start with, Ruby's blocks are a hack)

Ruby steals the concept of 'everything is an object' from Smalltalk. Compare http://edwinmeyer.com/Release_Integrated_RHG_09_10_2008/chap... with http://en.wikipedia.org/wiki/Smalltalk#Object-oriented_progr....

Also I hear that JavaScript thing is catching on...

JavaScript is Lisp now?

It's pretty damn close. First class functions give javascript great power. Combined with something like sweet.js and underscore, and javascript becomes a language with the functional library of a lisp along with macros. After that, javascript is just lisp with really weird syntax.

Not to be snarky, but that's like saying 'Javascript is just a Lisp except without the only characteristic that defines a Lisp'.

All the dialects of Lisp differ except in their homoiconicity, which is the one thing that gives Lisps their incredible expressive power.

I get frustrated when I hear people refer to languages with first-class functions as Lisp-like, because lots of languages have first-class functions, but that doesn't give them the power of Lisp - Lisp draws its power from homoiconic structure, which almost no other languages have (certainly not Javascript).

Most of my comment comes from the fact that Eich originally wanted to build a homoiconic lisp for netscape and built many of the features into javascript instead. Still no a lisp ,but it was designed to be similar. http://www.2ality.com/2011/03/javascript-how-it-all-began.ht...

Crockford called it "Lisp in C's Clothing" and then created this: http://www.crockford.com/javascript/little.html

I like the comparisons with ClojureScript: http://himera.herokuapp.com/synonym.html The major thing that continues to really annoy me about JS is the lack of proper lexical scoping, other deficiencies are just slight annoyances now (especially with a couple libraries that help the language be tolerable in certain use cases--e.g. https://github.com/coolaj86/futures).

JS has no "proper lexical scoping"? How so? I'm really curious... what your definition of "proper" is here, because JS definitely has lexical scoping.

Paste this into your browser location bar (it won't navigate away):

    javascript:void(function(){a = 1; {var a = 2;} alert(a)}())

That var a doesn't declare a new var within its scope, it declares it in the function, plus it is counterintuitive how that var a "retroactively" makes that local scope. Javascript has lexical scoping, but only within functions, not within all the scopes other languages have.

You want block scoping. Block scoping is coming in ES6 with the let keyword.

Python is the same here, for example, any many other languages too. Making `a` a local variable here is rather ugly thing to do, but it's (somewhat) consistent with how `function` keyword (not an expression) works.

The point being: JS implements full and proper lexical scoping; implementing lexical scoping for every block is not a requirement for having lexical scoping.

> "Lisp in C's Clothing"

And Perl probably has an even greater claim to this because it shares 6 of the 7 What Makes Lisp Different? things described by Norvig.

Reply on news.ycombinator.com