Jari-Matti Mäkelä wrote:
bearophile wrote:
As Sing# (http://en.wikipedia.org/wiki/Sing_sharp ) and Chapel, Scala is
one of the languages to be followed more, because they share some of
future purposes of D2/D3.
A small presentation about the close future of Scala (it's not a general
introduction to Scala): "Scala -- The Next 5 Years" by Martin Odersky:
http://www.scala-lang.org/sites/default/files/odersky/scalaliftoff2009.pdf
Scala is an impressive language and overall well designed. There are
certainly truckloads of features that could be taken from Scala to D. But
I'm afraid that the desire to have familiarity and compatibility with the
C/C++ family is more important in this community than cool new functional
features. Here's a quick comparison of some factors:
[snip]
You are making very good points, thanks for an insightful post. A few of
them are slightly inaccurate, but those were discussed by Walter
already. I'd like to make a few high-level comments.
I find the lack of rigor in certain parts of D as damaging as you do.
Fortunately, that has improved by leaps and bounds and is still
improving. When I joined Walter with working on D back in 2006, D was
quite a lot less theoretically-motivated - it was all greasy nuts and
bolts and pegs hammered in place. There was a tacit agreement between
Walter and me that D will improve the rigor of its ways, and indeed we
have made strides in that respect. If things work out properly, we'll be
able to define SafeD - a proper, checkable safe subset of the language.
It would be great if there were more PL heavyweights in the D community
(as you mention there are in Scala), but D's community is in large part
young and enthusiastic, and that's an asset. Possibly some of the young
students using D will become PL experts themselves and help improve it.
(Unlike you, I think that by and large there is no hatred or shunning of
the ivory tower.) Among other things, it would be great if you yourself
hung out more around here. It's a risky proposition, but I guess it's a
simple fact that you have a better chance at making a vital contribution
to D than to Scala.
About unifying FP and OOP, I hope you can educate me a bit. My
understanding from a cursory search is that Scala does not have true
immutability and purity, only Java-style by-convention immutability a la
String class. Is that correct? If that's the case, I think Scala got the
syntactic sugar part of FP right (pattern matching) but not the purity
and immutability aspects, which I believe are much more important. These
aspects are related to concurrency as well, where I think Scala has a
distinctly underwhelming lineup. Even with what we know we can implement
now in D concurrency-wise, we'll be in better shape than many (most?
all?) other languages. Stay tuned.
I agree that D could improve its type deduction - it doesn't even do
Hindley-Milner. (Incidentally, you chose a particularly poor example
regarding the type of array literals - those are very easy to type
properly (and in fact I do so with a library function), but Walter
insisted that typing by the first member is simple enough for people to
understand and remember.) I'm afraid D's type deduction abilities will
stay at about this level at least for D2. The good news is that, due to
templates' deferred typechecking, I haven't found that to be a huge
problem in practice.
Andrei
- Re: Scala future, Sing# Andrei Alexandrescu
-
