Anyway I support the suggestion that C++ has a bad reputation. It depends on where you’re coming from and if you’re experience began with C-like languages it figures that you will have just accepted that C and it’s relatives are just the way to do things. Just like your own first language makes more sense to you than others.

However, if you’re coming to C++ from languages like Assembler, Lisp and Smalltalk then C++ is a dreadfully painful experience of a fairly disgraceful grammar and not the best logic.

The biggest problems I have with scala are: very long compilation times (compared to Java) and very poor tool support. You could add other things such as poor error messages etc., but I don’t think they are as important, and anyway I do believe they are all due to the same underlying problem, which is that the language tries to accommodate too many features, and the grammar became way too complicated. The whole DSL thing by the way I find utterly pointless and I think it is dead end route. Actually, I can’t help comparing it to dreadful C++ “clever” (or were they called “smart”?) classes that took advantage of all sorts of dubious C++ features like operator overloading, implicit type conversions etc., in order to behave like proper high level types from proper high level programming languages. And they almost always worked the way you’d expect them to, except when they didn’t.

And the symptoms are almost identical as with C++: extremely long build times, painful recompilations after adding a whitespace to an unrelated file, people trying some elaborate workarounds (fsc? precompiled headers? distributed builds?), cryptic error messages, standard IDE features that you take for granted not working with scala source.

In the end I don’t really care if I can use named params or not, or if I can omit the dot in order to make the language feel somehow more “natural” to non-technical users (until the first error message shows up, I suppose). What I do care about is that Eclipse doesn’t hang in the middle of code editing, and that it recompiles stuff when it needs to be recompiled, and doesn’t recompile when it doesn’t need to. None of these things works in Eclipse scala plugin at the moment, and the intellij one isn’t any better.

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.