News for hackers. Stuff that matters.
Re:Why Lisp is a Big Hack and Haskell is Doomed to Succeed (... by hibikir on Sunday March 30, 2014 @03:34PM (#7497549)
And that's why the 'war' has just moved to the JVM: Closure is a Lisp, Scala steals a whole lot of things for Haskell, trying to make it actually practical.

I think Haskell's ultimate role is a bit like Ruby's: It can't really win, but it's destined to be influential. That's a much harder road for Lisp, as its greatest strengths are also its greatest flaws.

Re:Why Lisp is a Big Hack and Haskell is Doomed to Succeed (... by thirsteh on Sunday March 30, 2014 @03:45PM (#7497600)
> Scala steals a whole lot of things for Haskell, trying to make it actually practical.

LINQ is "practical Haskell," so is most of Rust (if "practical" means approachable to imperative programmers.)

Besides being on the JVM (which is a big plus), Scala hardly makes anything more practical than it is in Haskell. In fact, Scala programmers tend to migrate to Haskell (and ML languages) rather than the other way around.

Re:Why Lisp is a Big Hack and Haskell is Doomed to Succeed (... by platz on Sunday March 30, 2014 @06:40PM (#7498297)
If by LINQ you mean the map/filter/fold crew, I think this may be selling Haskell a little short. You could say the same about python. At least F#'s computation expressions give you the full power to create your own monads with it's "computation expressions", and in LINQ things are more statically locked down.
Re:Why Lisp is a Big Hack and Haskell is Doomed to Succeed (... by thirsteh on Sunday March 30, 2014 @06:52PM (#7498335)
Right -- I wasn't sure whether F# would be considered "practical" in this case.
Re:Why Lisp is a Big Hack and Haskell is Doomed to Succeed (... by platz on Sunday March 30, 2014 @07:04PM (#7498367)
I guess F# isn't practical if you're building a WPF application (I agree the tooling is lacking). Otherwise it seems like it can do everything C# does (including mutation, classes, interfaces, properties), only with a slightly unfamiliar (at first) syntax.
Re:Why Lisp is a Big Hack and Haskell is Doomed to Succeed (... by cordite on Sunday March 30, 2014 @04:02PM (#7497675)
Doesn't scala suffer from the JVM constraints, like no tail call recursion, everything is an object, such that the compile times become enormous to work around them?

Haskell is indeed influencing, but it is not remaining stagnant.

Re:Why Lisp is a Big Hack and Haskell is Doomed to Succeed (... by lmm on Sunday March 30, 2014 @06:46PM (#7498318)
> Doesn't scala suffer from the JVM constraints, like no tail call recursion, everything is an object, such that the compile times become enormous to work around them?

Yes. Yes it does. Scala is a bodge that is destined to be replaced (or at least rewritten), and I say that as a huge fan of the language. I would happily bet on Haskell outlasting Scala in the long run.

(But I use Scala today, because in the long run we're all dead. Scala inherits a lot of useful production infrastructure from the JVM, and on recent progress it looks like Scala can get faster compiles quicker than Haskell can get better infrastructure. Which means that today, in many environments, Scala is the better choice)

Re:Why Lisp is a Big Hack and Haskell is Doomed to Succeed (... by heavenlyhash on Sunday March 30, 2014 @09:14PM (#7498908)
The author of scala at one point made some very good responses to questions about compile times on a stackoverflow question here: http://stackoverflow.com/questions/3606591/why-does-intellij...
Re:Why Lisp is a Big Hack and Haskell is Doomed to Succeed (... by jonesetc on Sunday March 30, 2014 @04:12PM (#7497720)
The way I understand it, is that Scala does support tail-call recursion by way of compiling to a loop. Compilation was definitely a pain when I experimented with Sit.
Re:Why Lisp is a Big Hack and Haskell is Doomed to Succeed (... by chc on Sunday March 30, 2014 @04:45PM (#7497824)
Scala supports simple recursive tail-call optimization, but is less elegant in handling mutual recursion (due to JVM constraints).

Clojure is probably the one you're thinking of that doesn't support tail-call elimination at all. Rich Hickey thought that if you couldn't do it cleanly in all cases (like mutual recursion), you may as well just come up with something else. So instead of optimizing recursive calls, Clojure has the recur function.

Re:Why Lisp is a Big Hack and Haskell is Doomed to Succeed (... by cordite on Sunday March 30, 2014 @04:53PM (#7497857)
I recall that scala uses "trampolines" by compiling to what is more like a state machine.
Re:Why Lisp is a Big Hack and Haskell is Doomed to Succeed (... by judk on Sunday March 30, 2014 @05:04PM (#7497913)
I thought Actors does that, but not Scala in general.(?)
Re:Why Lisp is a Big Hack and Haskell is Doomed to Succeed (... by cordite on Sunday March 30, 2014 @08:26PM (#7498687)
RĂșnar Bjarnason talked about it in his presentation "FP Programming is Terrible" [0] (he makes up for that title in the end)

I asked him about it on twitter since it reminded me of thunks, he said " a trampoline executes a sequence of thunks, yeah" [1]

[0]: https://www.youtube.com/watch?v=hzf3hTUKk8U [1]: https://twitter.com/runarorama/status/449070763421618176

Re:Why Lisp is a Big Hack and Haskell is Doomed to Succeed (... by judk on Sunday March 30, 2014 @05:03PM (#7497909)
Only self recursion, which is a special but common case.
Re:Why Lisp is a Big Hack and Haskell is Doomed to Succeed (... by aerique on Sunday March 30, 2014 @04:13PM (#7497722)
I'm not sure whether I am parsing you correctly, but did you just call Lisp not influential?