The JVM situation

https://groups.google.com/forum/?fromgroups=#!topic/scala-functional/kvbaE6cAzqM

by Rickasaurus • 13 years ago

57 102 13 years ago

groups.google.com

guard-of-terra3• 13 years ago

The JVM is extremelly useful after you consider that all other foundations for higher gen languages are either:

- Can't get threads really right.

- Have some lousy pausing single-thread mark-and-sweep GC.

- Is proprietary and bound to one dying platform.

- (Bonus points) has 3rd party libraries that are not thread-safe or segfault from time to time.

WRT "making language not unlike Scala but with better interop", Kotlin and some other projects seem to do that but they can't get themself out of the door :(

praseodym2• 13 years ago

People should be investing time in Scala (compiler and tooling, e.g. IDE support) instead of designing their own language that probably won't get a lot of traction.

guard-of-terra3• 13 years ago

I'm not sold on Scala and my colleagues aren't either.

For an outsider it looks like a C++ for JVM: A language of endless short-sighted features that's going to bury yourself under it.

It's not even Haskell because Haskell strives to be elegant.

praseodym2• 13 years ago

To be honest, neither am I. I've done small projects in Scala (+libraries) and the amount of clever small features makes for short (maybe sometimes even elegant) code, but readability is a nightmare.

Front and foremost, though, I found tooling to be lacking. Reading a stack trace is horrible, the compiler is slow and the two most mature IDEs (IntelliJ IDEA and Eclipse) both have problems highlighting/checking and completing code.

For now, I'll probably stick with plain old Java.

seanmcdirmid2• 13 years ago

Been there and done that. However, designing languages to push the state of affairs forward is more my cup of tea (working on Scala helped with a lot of ideas though).

Writing tooling is incredibly difficult, especially when Eclipse isn't really designed to support new JVM languages. It is easier to write an IDE for your language than to plug into Eclipes.

profquail3• 13 years ago

I wouldn't say all other foundations for higher-order languages -- F# runs fantastically on the CLR (or Mono) and doesn't have any of those problems you listed.

cgag• 13 years ago

F# and the CLR aren't proprietary?

Fice2• 13 years ago

I would rather say that the mentioned problems are typical of languages that use their own VM instead of basing on an established platform like JVM or CLR.

JVM and CLR are not very different. What would be the reasons to want to avoid JVM, but still consider CLR as an acceptable choice?

pshc• 13 years ago

Rust is the anti-JVM.

- Proper task isolation with pointer ownership.

- No global GC. Task-local GC when needed, and explicit ownership otherwise.

- Mozilla.

- No NullPointerExceptions. Unsafe code is convenient when you need it.

jacques_chester3• 13 years ago

I personally am really excited by Rust, but it's also still a fairly fast-moving target. Lots of work is still being done on the semantics of the language.

It's an industrial research project, basically. When the semantics stabilise I reckon it'll be a technical winner in its chosen domain.

adamnemecek• 13 years ago

"Scala is not a well-designed language" regardless of anyone's opinion, that's a pretty ballsy thing to say on the scala DL :-).

octo_t4• 13 years ago

I think its recognised, even by people like Odersky, that the language has been significantly compromised by the decision to run on the JVM.

It is an incredibly well-designed language, but lots of that effort has gone into covering up some really nasty warts.

Aqueous• 13 years ago

Here i am thinking it's the best language I've ever written in :-) I guess that's not really incompatible with still being "not a well designed language." When we're comparing ourselves to platonic ideals I guess the real thing can only pale in comparison. I just don't perceive the compromises.

For me, attaining a factor of 5 lines to 1 line code shrinkage translating from a legacy (though still imperative) codebase is amazing, and must point to an excellent language design. Of course I realize I could probably achieve the same thing with a number of other functional languages of which i have limited experience

gruseom• 13 years ago

I'd be interested to hear some examples of how the decision to run on the JVM has skewed the design of Scala. (Plus whether/how the same is true of Clojure.)

guard-of-terra3• 13 years ago

They would never get it out of the door if it wasn't based on the JVM. The reason is Haskell. JVM mandates certain imperative tools in the Scala language; if you subtract these, you end up with Haskell, and Haskell is big enough that you'll have hard time reinventing it.

PommeDeTerre5• 13 years ago

Members of the Scala community are generally quite mature, and this reflects in their attitude and response when it comes to legitimate criticism of Scala.

To most of these people, Scala is merely a tool, often just one among many others. They fully realize that it has flaws, and are very willing to acknowledge the existence of these flaws. They don't take it personally when somebody points out such problems. This is quite evident after reading through the discussion in this case.

This does differ from how members of the the Ruby and JavaScript communities take criticism of those languages, for example. Such people do tend to be much more emotionally attached to those programming languages, for whatever reason. They react with hostility and denial when they encounter legitimate criticism.

Technological improvement happens best when criticism can flow freely. The people involved are focused on acknowledging and accepting that flaws exist, and then proceed to try to fix them. On the other hand, when legitimate criticism is shunned or blindly denied, like in the JavaScript community, technological progress proceeds at a much slower pace. More effort is placed on defending and maintaining the status quo, even when this is the most ineffectual and non-beneficial thing to be doing, than is expended on improving the situation.

steveklabnik• 13 years ago

They react with hostility and denial when they encounter legitimate criticism.

Citation needed, Rubyists in particular have been whining (and rightfully so) about MRI's poor concurrency support for the past year or two. That's just one counterexample.

Everyone that I know that's good at Ruby has their own favorite wart where it does something they hate.

sanderjd2• 13 years ago

It's pretty simple really, and far from unique to programming (let alone to the Ruby and JS communities in particular): all communities tend to take criticism from insiders in good faith, and tend to take criticism from outsiders more personally. It is obvious from reading the thread that Tony Morris is "inside" the Scala community, both due to his demonstrated depth of knowledge and to the deference and consideration given to his question. You have to earn the ability to say "Scala is not well-designed" on a Scala list. If somebody showed up and started a thread saying, "I just discovered Scala and it is immediately clear to me that it is poorly designed", it would turn out very differently.

It seems to me that there is a pretty typical mix of criticism coming from inside the Ruby and JS communities being responded to thoughtfully, and criticism from outside being responded to defensively.

azth4• 13 years ago

This does differ from how members of the the Ruby and JavaScript communities take criticism of those languages, for example.

Don't forget Go. :)

jbrechtel• 13 years ago

Let's just say that Tony Morris doesn't mince words on the Scala MLs.....

brucefancher• 13 years ago

Clojure.

clubhi• 13 years ago

Too succinct.

kleiba3• 13 years ago

The comment or the language?

All kidding aside, one- or two-word comments are quite uninformative. Just because the original article with its "Scala is not a well-designed language" statement doesn't bother backing up bold claims with arguments, we should not fall into the same trap here on HN.

It's worth talking about Clojure as an alternative to Scala. They're both targetting the JVM, and they're both still on their way out of a niche. But just throwing out the name of an alternative programming language doesn't make a useful comment yet, nor does the "too succinct" reply.

dustingetz• 13 years ago

clojure and scala aren't really in competition, in the same way python and java aren't.

Afforess• 13 years ago

It's fun to hate on Java (cause who here hasn't hit stupidity with Java?), but the fact is that Java does a lot right.

There are two types of languages, the languages people hate and the languages no one uses.

jlgreco• 13 years ago

There is a third type of language: languages that people hate so much that no one uses them anymore.

For values of "no one uses" that set up the "like"/"not used" dichotomy, I'd say Perl is in both categories. With any luck Java will get there too one day, even if the JVM doesn't follow it.

twic4• 13 years ago

With any luck, all the languages we know today will get there too one day, as they are rendered obsolete by further decades of experience with programming languages.

Well, except LISP, obviously.

peter_l_downs• 13 years ago

Prolly the biggest advantage of the JVM in my opinion was pointed out by "iv...@ivan.net.nz":

    > The one thing I like about the jvm is that I can compile 
    > and package code on one platform and deploy to another 
    > without worrying about anything but the fact that the jvm 
    > is installed.

Solves so many headaches!

yumraj• 13 years ago

While it's not the same thing, 'go' can compile for multiple platforms, and then you can deploy appropriate binaries on another OS as long as 'go' is installed.

burntsushi• 13 years ago

and then you can deploy appropriate binaries on another OS as long as 'go' is installed.

Nope. Go does not need to be installed for a binary produced by the `gc` compiler to run.

tieTYT• 13 years ago

Yes, and for how good Haskell is as a LANGUAGE, it sucks at this very important feature (assuming you want to use a 3rd party library).

michaelsbradley• 13 years ago

There's always Frege:

https://github.com/Frege/frege

But it's definitely a work in progress.

mjn• 13 years ago

Sun used to use the catchy slogan "write once, run anywhere" to refer to this property...

mrhonza• 13 years ago

Yes, I agree that uberjars are a great thing when it comes to the JVM ecosystem. However, with the advent of projects like docker, I can't help but think that this reasoning is now obsolete. You can write your app in Go, Rust or Haskell and deploy it inside a container that you provide. You control the environment that it runs in.

octo_t4• 13 years ago

Simon Ochsenreither has been investing a fair amount of resources into Avian[1], an alternative JVM with support for tailcalls and various other useful toys.

I think this is possibly where languages like Scala may lead, potentially forking a JVM and refitting it to their own needs.

[1] https://github.com/ReadyTalk/avian/

akurilin• 13 years ago

Interesting, it'd be good to have community-drive alternative to the JVM, like some kind of a Postgres of VMs. Also tail calls are what people complain about with Clojure on the JVM, so this would address that problem.

octo_t4• 13 years ago

When I'm done with my current project, my plan is to make the heap 64-bit on 64-bit machines (which was currently an issue last I checked).

twic4• 13 years ago

By "to the JVM", you mean "to the Oracle JDK".

The implication that the Oracle JDK is the JVM equivalent of Oracle/DB2 is rather unfair. The Oracle JDK is really OpenJDK, which is, as the name suggests, open source.

It is true that there is one behemoth corporation behind OpenJDK, but that still makes it the equivalent of Chrome or Eclipse, not Oracle or DB2.

twic4• 13 years ago

Avian is a very impressive piece of work. I'm not sure i'll ever switch to it, but hopefully, its very existence will drive the OpenJDK to improve itself to compete (eg adding tail call optimisation). A bit like how Scala forced Java's hand in adding lambdas.

bitcrusher• 13 years ago

There are really several layers of issues to deal with in regards to the JVM.

First, the JVM really IS NOT a great choice to build other languages on. It wasn't designed for it; In fact before invokedynamic, it was nearly impossible. For all intents, building other languages on the JVM is a bad hack, regardless of how elegant ( or not ) the language syntax is. The amount of fuckery required is nearly unbelievable.

Second, the JVM is owned by Oracle. It is technically 'open source' but Oracle has proven time and again to not only be against open source, but one could even support the position that they're actively hostile towards it.

Ideally, the solution would be to invest engineering mind-share into creating a REAL VM that was designed to host many programming languages. Regardless of what you think of Microsoft, they got .Net correct in that their tooling infrastructure was built from the beginning with multiple programming languages sitting on top of the CLR ( and later the DLR ). The LLVM folks have been making some progress in this regard by way of VMKit, but personally I cannot understand why this issue doesn't get more mind-share. Python, Scala, Ruby, Clojure, Lua, etc would all benefit in the end.

Pxtl3• 13 years ago

They tried. Does nobody else remember Perl 6/ parrot?

ishbits• 13 years ago

So what are my real options for avoiding the JVM on new projects? Go? I'm not into functional save a bit if Scala. But not willing to invest time in something like Haskell.

I also don't feel like Python is an option. Seeking more performance from a single node is what he me move to Java from Python for many of the the things I work on.

eccp2• 13 years ago

I think it's easy to feel overwhelmed but you probably can scale up with Python with little effort with PyPy (time ago you could do that with Psyco) or change your processing to something based on Twisted.

jerf2• 13 years ago

Without even a hint of what you want to do with your "new projects", that's not possible to answer. Python is a sensible answer for many cases, for instance. Go is pretty plausible for some projects but would immensely weak for others (for its age, it has great library support, but it is still a young language), etc. C++? D? Ocaml? C#, perhaps on Mono? How exotic are you looking to be? In the rich, diverse world of programming languages, the JVM is merely one participant. It's large, but I do not think everything else merely lives in its shadow or anything, it is not that dominant. Not even close, really. (C++ may once have stood atop the world, but nothing else has quite pulled that off since.)

PommeDeTerre5• 13 years ago

C and C++ are still the dominant languages, by far. They're still actively "standing atop the world".

Almost everything truly important today is written in one of them, or both of them. The usable, production-grade implementations of PHP, Python, Ruby, JavaScript, Lua and Perl depend on one or both, as well. Most JVM implementations depends heavily on them, too.

When they're providing the foundations necessary for even their competitors or alternatives, it inherently makes them even more valuable and effective.

azth4• 13 years ago

Have you checked out Rust?

skybrian• 13 years ago

I think you have to start with your target platform. If you want to run in the browser it has compile to JavaScript. That has consequences. If you're targeting mobile phones it has to generate Android or iOS code, preferably both. On the server there are many more choices; targeting LLVM might be a good bet.

Language design is important, but being a good fit for the platform is more important.

Pxtl3• 13 years ago

Come to the dark side. C# has been awsome since about 3.5

happy_dino2• 13 years ago

I don't think C# is even remotely able to compete in this battle. :-)

rbanffy5• 13 years ago

While C# runs on platforms other than Windows, those platforms have such incredibly rich programming ecosystems one has to wonder why would anyone program in C# for them when there are hundreds of languages more appropriate to the specific problem.

kvb3• 13 years ago

Hundreds of languages? I don't know, Xamarin's tools seem to indicate that there's a real demand for using C# on a variety of platforms. While not my personal preference, C# is really a wonderfully well-designed language.

profquail3• 13 years ago

If they're going to switch from the JVM to the CLR, they might as well switch to F#; in fact, I'll even argue it'd be easier for them to switch to F#, since they'll be able to continue using many of the functional programming concepts and abstractions they've already learned in Scala.

Pxtl3• 13 years ago

For a multiparadigm langauge, C# 3.5 and up offer some solid functional programming stuff. Obviously if you want to go hardcore into FP you can find it in F#, but if you just want to do lots of awesome things with lambdas using otherwise-conventional OOP, C# is surprisingly well-equipped.

A lot of C# developers are stuck treating it as Microsoft Java, which it hasn't been for several years.

To me, the biggest problem with C# is cultural. C#'s user-community is entirely enterprisy... it's open-source adoption has been minimal, and that means that most C# code is still heavily stuck in a "cathedral" mentality where coders either use exclusively Microsoft libs (which are often terrible - no single company can ever be expected to get it right every time) plus some heavy wheel-reinventing, or maybe they pick up some gigantic vendor-backed 3rd-party lib like Telerik. There isn't the massive community of open-source developers like you see on other platforms.

rbanffy5• 13 years ago

Seriously, I stopped reading on "1) Scala is the best available programming language for the JVM."

There is no such thing as "best programming language". A programming language either fits your problem, making if comfortable to express your program with it, or it doesn't.

PommeDeTerre5• 13 years ago

"Best" doesn't necessarily mean "perfect" or "optimal".

You can easily be given several choices that are all imperfect or suboptimal. But of those choices, there could very well be one that isn't as imperfect or suboptimal as the others are. This one can be considered the "best".

That's pretty much the situation here. Given that the major players in this arena are Java, Clojure and Scala, we often find Scala coming out ahead in most measures. In this context, it can be said to be "the best".

sultezdukes• 13 years ago

I think the OP was referring to the fact that "best" is subjective. Obviously many, many others don't think that Scala is the "best" programming language on the JVM.

Given that the major players in this arena are Java, Clojure and Scala, we often find Scala coming out ahead in most measures.

The "we" in the above sentence refers to you and some other people that might have that sentiment, but not lots of other people.

michaelochurch4• 13 years ago

I'm sorry, but I think calling Scala "not well designed" is a bit off the mark and smells of flame-bait. Relative to the extremely hard problem of putting a Hindley-Milner type system on top of the JVM, I think it's extremely well-designed.

I probably prefer Clojure slightly, but Scala-bashers are missing the fact that, for what Scala is trying to do, it does it extraordinarily well. Now, I don't like object-oriented programming at all so I question the utility of that aspect of JVM support-- Clojure's doing a much better job of making that stuff the weird-looking clunky part-- but Scala does a damn good job with what history handed it.

srean3• 13 years ago

People here might like to take Felix for a spin.

http://felix-lang.org/share/src/web/tutorial.fdoc

http://felix-lang.org/share/src/web/nutut/intro/intro_index....

All analogies are inaccurate, so with such inaccuracies assumed, one can look at Felix as: Felix is to C++ what Scala is to Java, but that is is not a very illuminating comment.

To give an idea, Felix is a whole program optimized, strongly typed, polymorphic, ML like language that can interact effortlessly with C and C++ code and has coroutines baked in. It uses a mix of lazy and eager evaluation for performance and compiles down to C++.

jongraehl3• 13 years ago

What's wrong with it, then? Such a language would need:

1. tool support (valgrind, gdb or better)

2. good performance - 64-bit on the major desktop OSes (mobile a plus, obviously)

3. real concurrency

4. libraries

5. build time for large projects ("compiles down to C++" makes me think this could be an issue)

Most new languages fail at several of these, for years. You'll notice that I haven't mentioned language design at all.

srean3• 13 years ago

It scores extremely, extremely well on 2.

Regarding 3 it has had coroutines built into the language since the last 10~15 years, much before the language Go made it more mainstream. preemptive threads is more recent. It does have a stop the world garbage collector, which is not good for concurrent applications, but the semantics allows one to avoid creating garbage to a large extent. Libraries is chicken and egg, one needs higher level of adoption to drive this. 5 could be a legitimate concern, but I dont think its going to be any worse than Scala or C++ in this respect.

As far as language design goes, Skaller the author is a well regarded PL theorist active on LTU.

I am not saying this the best, end all language, but one that has enough interesting features that would be interest to the early-adopter rich crowd that we have here. It certainly has grabbed my eye balls

kvb3• 13 years ago

While there's plenty to disagree with, it pains me to see such rich fodder for an interesting discussion on the design, implementation, and adoption of programming languages languish on the second page of HN while the first page still has a dozen NSA stories.

The JVM situation

Related Stories