- 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.
It's an industrial research project, basically. When the semantics stabilise I reckon it'll be a technical winner in its chosen domain.
But in the long run, it'll be worth it, and I have no doubt that Rust will become an amazing language worth using.
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?
The Windows-based implementation of the CLR is proprietary, but as other posters have mentioned, it's built around an open, standardized specification (ECMA-335). Xamarin has been making big strides in improving Mono over the past year, and it'll only continue to get better.
Most things work, but there are a few things that are broken in unavoidable ways. Similarly, the performance isn't terrible, but the optimization is not quite at the same place as the original platform.
Xamarin's rapid work suggests that there will be a 'production-ready' CLR for most platforms (they've got it down for iOS, Android, and recently OSX) soon enough.
Right now, they are stuck in the odd middle, but it is still an amazing value if you are building common code cross platform apps.
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.
But let's just look at one element of Scala's truly byzantine iteration logic collection: Iterable
Inherited: Iterable IterableLike Equals GenIterable GenIterableLike Traversable GenTraversable GenericTraversableTemplate TraversableLike GenTraversableLike Parallelizable TraversableOnce GenTraversableOnce FilterMonadic HasNewBuilder AnyRef Any
Implicitly: by traversable2opsby MonadOpsby any2stringaddby any2stringfmtby any2ArrowAssocby any2Ensuringby alternateImplicit
Source: http://www.scala-lang.org/api/current/index.html#scala.colle...
..and now explain what all these aspects actually do! And that's just one small element!
And look at the method set of that thing.. Whoa! Again C++ suddenly seems minimalist.
Also, the implicits shown are any implicits which can be invoked on Iterable, which includes all implicits which can be invoked on Any.
If Scala is used as "ML with OO features when really needed but not otherwise" it's quite nice, but I would not advise using Scala without a style guide for a multi-developer project.
Considering that Scala ships with BOTH tons of collection types AND tons of useful operations, this seems to be a sane thing to do.
Scala manages ...
- to make both adding a new operation AND adding a new type not suck too much
- to retain the “best” collection type through operations, without duplicating code left and right
Most other languages fail already at point number one. No other language has managed to achieve point number two, let alone both.
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.
You should consider Clojure. The community is evolving in a way that compensates for some of the tool chain problems, and Leinengen is definitely more intuitive than SBT.
My traditional bias favors static typing, but I think Clojure might beat Scala because for most web applications, runtime typing (you can implement similar guarantees as in compiled languages; however, checking isn't at compile-time and therefore your testing will be less performant) is good enough.
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.
- 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 :(