
Is Scala really more complicated than Java? - fogus
http://www.artima.com/weblogs/viewpost.jsp?thread=268561
======
osipov
As a personal project, I've built a simple search driven website using Scala +
Lucene. The article doesn't make a fair comparison of Scala vs. Java
complexity. The examples in the article are focused on Scala strengths, e.g.
for-comprehensions, closures, Range classes, etc. It is true that these
features are superior to Java equivalents. However, Scala is still too awkward
in implementation of annotations, generics and type inference in general. For
example, Scala 2.7.5 annotation problems make integration with Java
Persistence API (JPA) an adhoc hack. Scala 2.8 still has serious bugs open on
annotations. Generic type are fundamentally complex and while Java attempts to
abstract some of the complexity related to co/contra-variant types, Scala
requires a deep understanding of nuances in practical application of generics.
ML type inferencer in Scala is great when it works (in simple situations) but
it is a headache to figure out _why_ it causes problems in the cases when type
inference doesn't work as intended. Unfortunately when the type inference
doesn't work as expected one is forced to hard code type casting which defeats
the whole purpose of a type inferencer.

~~~
plinkplonk
"ML type inferencer in Scala is great when it works (in simple situations) but
it is a headache to figure out _why_ it causes problems in the cases when type
inference doesn't work as intended."

I've heard this many times. I think learning some formal type theory might
help. It worked for me, helping me get my head around Haskell and make sense
of type error messages.

~~~
osipov
"learning some formal type theory might help" -- understanding formal type
theory is not a prereq for understanding Java. If you are you suggesting that
knowledge of formal type theory is needed to be an effective Scala programmer,
then as I pointed out, Scala is more complex than Java.

~~~
plinkplonk
@osipov

" then as I pointed out, Scala is more complex than Java."

I didn't comment (either way) on this.

I was just trying to say learning type theory worked well for me when I was
learning languages with powerful type systems (Haskell in my case), especially
in understanding type errors. It may or may not work for you. It is just an
experience report/suggestion.

I don't care if Scala is more complex than Java or not. Apologies if you
thought I was making a claim to that effect.

~~~
osipov
No apologies needed, I thought your comment about learning formal type theory
and your book recommendation were valuable. My comment was based on the
premise of this thread (per the title) and the premise of the article.

~~~
joe_the_user
An interesting thing about this article is it makes me think about _just how
natural_ the english-fragments within mainstream (c-like) languages are.

Loosely speaking, a c-like English would be: "For each tree in the grove,
paint on the stem"

But what would a Scala-like sentence be??? "trees in the grove - paint circles
on their stems"???

~~~
rincewind
That might show that idioms from C got into your english, not the other way
round:

"For every cookie in the jar; I ate that cookie" vs. "I ate all the cookies
from the cookie jar" vs. "The cookie jar is empty"

(the last one assumes that the cookie jar was type-safe and contained nothing
but cookies)

------
cousin_it
I know that's totally beside the point, but I'd have coded the example like
this:

    
    
        print """
            Happy Birthday To You
            Happy Birthday To You
            Happy Birthday Dear XXX
            Happy Birthday To You
        """

~~~
swannodette
Your solution is:

print"""Happy Birthday To You\nHappy Birthday To You\nHappy Birthday Dear
XXX\nHappy Birthday To You""" -> 103 chars

This came up on the Clojure mailing list:

(dotimes[x 4](println"Happy Birthday"({2"Dear XXX"}x"To You"))) -> 63 chars

40 less characters.

~~~
cema
A nice trick! And can be derived directly from the "definition" of the song
(that is, from the way the song is constructed). Great!

------
Zak
Code that makes use of features unfamiliar to the reader appears more
complicated. Of course, it may be that Scala _is_ more complicated than Java.

I don't know Scala, but it is my understanding that it provides all of Java's
functionality (possibly with different syntax) for the purpose of
interoperation, as well as its own features. If that's true, then the language
is more complicated than Java, even if the code you actually write is not.

------
drcode
great concise summary at the top of the article- More writers should do this!

------
rwmj
People complain about OCaml because it doesn't use parens around function
arguments, and { } around blocks. Basically programmers don't like to learn
anything new, which is very sad for people who are supposed to be technology-
led and love embracing new ideas.

~~~
jacquesm
I don't think that's it. I love learning new stuff but if the new stuff is
somewhat like but still different than the old stuff I have a much harder time
giving it its spot.

For instance, in python I'm not usually tempted to put ';' at the end of a
statement, except on lines with function calls. For some weird reason that
f(x) _;_ goes completely automatic.

And every time I see my fingers do that I have to remove it again, and plenty
of times I simply miss it.

It's like a violin that you've gotten used to over the years, the next violin
may be a very good instrument but it will never be the one that you have this
finely tuned connection with that you built up over the years. That takes
years!

~~~
krakensden
You do realize that f(x); is a valid statement in python?

~~~
jacquesm
Sure, but the ';' can be lost without penalty.

------
tetha
I would be highly interested in the background of the friend motivating this
article. Is he a java-only-person? Does he develop/know multiple languages?

I am asking this, because just looking at this snippet, I had no problem
understanding it in a glance (which rates it as not complex), given that I
know and was reminded of haskells and pythons list-comprehensions, a rubys
block-structure and printf (don't hit me if these things are entirely
different in scala, but this is how I just read it, and apparently, it was
close enough to understand what this snippet does).

------
henning
Complicated how? The number of unfamiliar features (Scala has stuff that Java
does not)? The size of the language specification (Scala's is much smaller
than Java's)?

------
igrekel
I think there are more abstractions available compared to java. That means
there are possibly more things to understand before you can know how a piece
of code will exactly get to be executed. Now, having more abstractions also
mean the code can be more explicit and demand less "simulating in your head"
in order to understand what it does.

