How do you feel about Scala now ? Features, Libraries and Performance ?
It’s almost getting close to 2 yrs since you wrote this blog.

thanks
Saifi Khan.

where same term might be both value and function call, that is aways prone to ambiguity.
i like C approach there, that made parenthesis mandatory and eliminated ambiguity.

in contrast, in TurboPascal (pointers were untyped), function XXX():pointer lead to ambiguity on assignment : var x: function:pointer; x := XXX; – is it address of function or its result?
even such strict andd anti-ambiguious language as Pascal fallen to ambiguity there

with regards to UAP, there’s more confusion though. For example, let’s say I get an array using a function:

classOf[scala.collection.mutable.HashSet[_]].getDeclaredMethods

Then I want to index into the array. The logical way to do it is

classOf[scala.collection.mutable.HashSet[_]].getDeclaredMethods(0)

but, since it was actually a function, this produces an error; the correct code is

classOf[scala.collection.mutable.HashSet[_]].getDeclaredMethods()(0)

This is an inconsistency iirc. c# properties do not have.

I disagree. Scala has consistency, purity in some things (operators being named function calls), but an overwhelming number of language constructs on the other hand. The type system is difficult and unintuitive. For example, in the compiler phases, one actually imports various classes (i.e. types) by referencing bound variables, essentially forcing long classes with many bound inner classes — even if these inner classes have pretty unrelated functionality.

One point where Scala does worse than C++ is by hiding potentially expensive processing. The -optimise setting breaks certain files, and the regular settings seem to be even too sugared for Java IcedTea to properly optimize.

The other unfortunate thing is class file compatibility. Things may be pretty on the surface, but having classes “Function0″ through “Function22″, and type-erased function signatures clearly demonstrates how they’re trying to hook into the class file format.

Regarding the concise syntax, I do very much like the match statement, but I think Python demonstrated how to achieve a lot of elegance with a very simple language, and some of these thoughts ($self$ as a parameter, being able to have classes deriving from str) were lost. Of course, some things are not feasible in a statically typed language.

Finally, I think they really messed up trying to support UAP. **The meaning of an expression can change based on what type it’s assigned to**, which they needed to do in order to support actually grabbing function objects, when the function had no parameters. C# did it better, and came out earlier.

However, as I don’t completely hate C++, I see Scala as a potentially useful / practical language. It fills a niche where one needs expressive statically-typed languages, and I hope it can evolve further.

would like to see more scala examples on:

1. clean break – the language stands on its own and java-like is just an illusion (a great examples of this are the for comprehension, and that everything is an object…)

2. the language is orthogonal – any feeling of complexity in the language is there for a reason (amazing type system, or the ability to extend the language with constructs that look and feel like keywords or DSLs).

3. how simple it is to express things in scala via direct comparisons with ruby and java (you’ve done a bit of this in the past).

keep up the great work.

I wish there was a new language that is both powerful and easy to learn without learning its predecessors. I mean by this Java 5 without learning Java 1.4, C++ without learning C, Groovy and Scala without learning Java.