On: Consider the Nimrod Programming Language

[joehillen]

What is Scala doing in the same list with Rust, Julia, Nimrod, and C++? You do realize there is a JVM preventing it from being a systems level language, right?

Also, you should need no more reason to avoid Scala than this: https://www.youtube.com/watch?v=TS1lpKBMkgg

If you're interested in Scala, learn Haskell. It's faster, its design is re-enforced with proven mathematical concepts, and it doesn't have the worst syntax ever.

[kasey_junk → joehillen]

There are lots of reasons to choose Haskell over Scala, but a blanket statement that it is "faster" is idiotic.

[joehillen → kasey_junk]

But it is faster. It's both faster to compiler and faster to run. I think it's a valid reason to prefer Haskell.

[nomad42184 → joehillen]

Except that it isn't faster at runtime (http://benchmarksgame.alioth.debian.org/u32q/benchmark.php?t...).

[Pacabel → nomad42184]

If you want to prove your point, using totally unrealistic micro-"benchmarks" such as those is by far the worst way about doing so. You're better off giving no evidence whatsoever than you are referring to those.

[yen223 → Pacabel]

Are there any more realistic benchmarks that we can refer to? Because I've read a lot about how Haskell supposedly runs faster because of its purity, but I've not seen a lot of evidence actually supporting that notion.

[igouy → Pacabel]

"[B]etter off giving no evidence" than pointing to measurements that provide a known context -- source code, implementation version, command lines, measurement scripts...

Nonsense.

[profdemarco → nomad42184]

Almost all the Haskell entries in the shootout are just using the FFI to call into C libraries. None of them are remotely close to idiomatic Haskell.

[nomad42184 → nomad42184]

Everyone knows, of course, that these benchmarks don't tell the whole story. However, it's ludicrous to assert that providing no evidence is better than providing a array of microbenchmarks across a variety of different languages, machines and implementations. Further, the assertion that Haskell is "faster" (in some blanket sense) than Scala is completely evidence-free.

[nomad42184 → nomad42184]

@profdemarco --- sure; and they're still not faster than their Scala counterparts.

[dom96 → joehillen]

Perhaps his intention is not to just compare system level languages.

[stormbrew → joehillen]

Holy crap the music in that video's intro makes me feel like I'm about to watch the Hunger Games. And then it's just a guy talking.

[bsaul → joehillen]

This video you've linked shows many general and philosophical statements but really not that many concrete examples... I stopped before the end because i got a bit fed up with general sentences like "complexity is the ennemy". From what i've read about the astonishing number of scala features, i am more than ready to believe him, but i would really need more examples...

[joehillen → bsaul]

He does go into detail. Keep watching.

[saryant → joehillen]

He also goes on to say that no language meets his expectations today and despite that speech, he's still active in the Scala community.

https://github.com/paulp?tab=activity

[nomad42184 → joehillen]

Except that Paul Phillips has stated many times that he still programs routinely in Scala and, despite its flaws, considers it to currently be the best option. His arguments about what's wrong with Scala are compelling, but his continued use of it and desire to create his own collections library also speaks volumes.

[andrewflnr → joehillen]

It's a language that "attempts a speed-elegance unification", as the author specified before that list. It's not as if Julia is a systems language at all, but it also definitely belongs there.

[pjmlp → joehillen]

> You do realize there is a JVM preventing it from being a systems level language, right?

You do realize there are quite a few commercial JVMs that generate native code AOT like any of the referenced languages, right?

[sixbrx → pjmlp]

I presume they still have a largish runtime attached with complicates FFI especially if callbacks are involved. I've found Java FFI to generally be a pain.

Also, I think a lot of organizations would never approve using these in production, too likely that behavior will differ vs Oracle's or the OpenJDK VM's, the company won't be around in a few years, etc., and the gcj is very out of date from what I gather.

[pjmlp → sixbrx]

I did not mention gcj, it is a dead project since 2009.

I don't know, but I guess enterprises do trust Aicas, Aonix, IBM, Excelsior and quite a few others.

[joehillen → pjmlp]

That's too terrifying to imagine.

[pjmlp → joehillen]

I fail to see why.

[barchar → joehillen]

Nimrod's syntax is quite similar to scala (and Pascal!). Haskell can be really fast but fast Haskell and easy/safe Haskell tend not to overlap as much as one would like

[joehillen → barchar]

> Nimrod's syntax is quite similar to scala

What are you talking about!? Have you even looked at either?

Nimrod:

    for i in 1..100:
        if i mod 15 == 0:
            echo("FizzBuzz")
        elif i mod 3 == 0:
            echo("Fizz")
        elif i mod 5 == 0:
            echo("Buzz")
        else:
            echo(i)

Scala:

    for (x <- 1 to 100) println(
        (x % 3, x % 5) match {
            case (0, 0) => "FizzBuzz"
            case (0, _) => "Fizz"
            case (_, 0) => "Buzz"
            case _      => x
        })

In nimrod you'll notice a lot less parens, curly braces, and '=>'.

> fast Haskell and easy/safe Haskell tend not to overlap as much as one would like

Not even remotely true. Where did you even get that idea?

[dom96 → joehillen]

It really depends on what part of Nimrod and Scala you look at. The similarities are perhaps more apparent when looking at the function declaration syntax, generics and/or the variable declaration syntax.

[codygman → barchar]

"fast Haskell and easy/safe Haskell tend not to overlap"

I'm sorry, but the only people I've heard say this are those who are slightly open-minded about Haskell but truly believe it usually can't be remotely as efficient as imperative alternatives. None of the people I've heard make these statements have had even a few months experience writing Haskell.

If you can qualify this, I'd be pretty interested. Or if you've had an experience with Haskell that led you to believe this, I'd like to see if there is another solution.

I'm very interested in these limitations people always talk about with Haskell, but none of them have held up so far. I've been evaluating Haskell for a while and am very interested in testing any limitations you've faced.

[nomad42184 → joehillen]

Also, Julia has no business as a systems language either. I think it's a more general language comparison.

[frowaway001 → joehillen]

If your plan was to make Haskell users look like douches, you are doing a pretty good job around here.