
Scala as EJB 2: feedback (incl. Fantom comparison,funny comments - gtani
http://blog.joda.org/2011/11/scala-ejb-2-feedback.html
======
ekidd
Stephen Colebourne's original post on Scala was discussed at length on Hacker
News: <http://news.ycombinator.com/item?id=3264849>

There were a lot of interesting perspectives, both for and against Scala's
design decisions, and I learned a lot.

1\. Scala is a complex language, with many tools aimed at library authors.
There are drawbacks to this approach (witness the headaches of C++), but also
advantages (witness the massive commercial success of C++).

2\. Plenty of Scala developers are happy to use it as a "better Java." A small
but vocal minority are engaged in hard-core functional programming, which can
occasionally lead to both cool libraries and minor conflict within the
community.

3\. Some of Colebourne's original criticisms were acknowledged by Scala
developers, especially those pertaining to module systems. However, opinions
on whether Scala should limit mutability (as Clojure and Haskell do) were
divided.

This followup post is less interesting. He goes out of his way to quote people
who made insightful comments that agreed with his views, but only quotes snark
and mockery from those who disagreed.

~~~
felipehummel
Best summary on this whole discussion.

------
harryh
If anyone is interested in looking at a medium sized scala project and
deciding for themselves what they think about the language you might want to
check out rogue, a MongoDB query DSL that we developed at foursquare. You can
see it, source and all, here:

<https://github.com/foursquare/rogue/>

------
felipehummel
I really want to see all this thrash/unreadable Scala code that everyone is
talking about. I haven't done any great projects on Scala, only smaller ones.
With a few exceptions (of operator overload and implicits abusing) I've read
many Scala sources and after you pass the "functional programming WTF moments"
you come to understand pretty much everything.

~~~
adabsurdo
no. the problem is that scala allows almost any string of characters as
identifiers, and this encourages programmers to use symbols instead of english
words for their function names. So you end up with identifiers that convey no
meaning whatsoever, like /:\ or >>:.

Sure, this can be in fact very nice if you are writing a DSL for a problem
that already has its own well-known set of symbols, like a branch of
mathematics.

However, what happens in reality is that most programming is "business"
programming. But still programmers use it for everything (because we're lazy
and typing :: seems faster than "append"). The scala api leads the way here.
For example the list class:

[http://www.scala-
lang.org/api/current/scala/collection/immut...](http://www.scala-
lang.org/api/current/scala/collection/immutable/List.html)

The following are all subtle variations on append and prepend:

::, :::, ++, :+, ++:, +:

Can any non-scala programmer guess which one is which? When you move on to the
Map or Set class, it's a little bit the same and a little bit different. Sure,
at one point you will remember all of this by heart, but the same pattern
repeats itself when you try to use another library: it defines its own little
language, instead of using the one common to us all: english.

Note another huge drawback, for me at least: you can't google such symbols
because of course search engines will treat them as noise. Even searching for
them with regexes is tricky because you can't use word boundaries.

The argument I heard over and over is that you can make non-sense function
words even if you're restricted to alpha-numeric. This is true, and it
happens. However, if I call my function "append" or "xyz", and what it does is
"prepend", it's obviously the wrong name and you can point it out.

Symbols, on the other hand, are arbitrary, and it becomes a question of taste.

edit: removed some list operators added in error, thanks Inufu

~~~
finnw
> ::, :::, ++, :+, ++:, +:

> Can any non-scala programmer guess which one is which?

I have read the documentation and I still do not know which one is which.
Specifically the summary documentation is the same for both ++ and ++: Can you
explain the difference to a non-scala programmer? I can see that the answer
must be in the type signatures, but I have no idea how to decipher those.

~~~
zohebv
In scala the use of : changes the associativity of the operator, so a ++ b ++
c is equivalent to (a.++ b).++ c while a ++: b ++: c is equivalent to (c.++:
b).++: a However fear not :-) the arguments are always evaluated left to right
i.e. a,b,c and never c,b,a. It might be useful to think of (c.++: b).++: a as
a ++ (b ++ c) except that ++ has c as the "this" parameter in the inner
expression and not b.

------
tutysara
I am wondering why there is no response to this post for such a long time. Did
scala guys decided to show their disappointment by ignoring this post here?

~~~
vetler
Colebourne's attitude reminds me of an attitude I encountered a lot when I
used Perl. Some people would spend a lot of time complaining about how bad
Perl is. Meanwhile, lots of people would be happily producing clean and
maintainable code with Perl. People who like Perl will probably nod
acknowledgingly, and people who don't like it will think I'm an idiot for
thinking that Perl isn't so bad.

It's best not to get caught up in the language wars and just focus on getting
things done. Which reminds me, I should be getting back to work.

~~~
spidaman
Apt comparison. It's easy to see how both perl and scala can degenerate into
"line noise", both are quite powerful and both have their religious adherents
and detractors. While I would refrain from using punctuation characters in
method names, I think it's an asset that scala allows it. Colebourne's desire
for version awareness in class loading is one I'd agree with with but I've
wanted that in just about every language. The rest of his complaints just
sound like crabby BS to me. FWIW, my experience with scala was a short project
last year where it was essentially just a "better java" with smatterings of
implicits and FP, I enjoyed it and plan on using scala again in the future.

~~~
SWengineer
I think quite a few java devs, myself included, are starting to use scala as a
'better java'. After a decade or more of java coding we're looking for
something more expressive which isn't a scripting language.

------
foobarbazetc
This is one of the lamest "things" on HN/the Internet in a while.

You have one guy who says he doesn't like Scala, provides almost no actual
reasons apart from hand waving, and pretty much says he's never actually used
it for anything. He then points to a language which has zero traction, and
will never gain any, as his ideal language.

That's great. It really is. So this guy doesn't want to use Scala. That's good
for him. Why do _you_ care?

If this was an interesting analysis of the language, or the libraries, or some
actual code, that would be something to talk about. But it's more a whiny "why
are all you guys switching to Scala! I don't like it! Come back!"
pseudo-"debate" than anything else.

~~~
soc88
Great and accurate summary.

------
Tichy
Does Fantom have any traction? It sounds interesting.

~~~
timclark
Fantom is an interesting language go and try it out! I don't think it has much
traction but it is simple, easy to understand and contains some thought
provoking ideas. You can get to know most of the language and most of the
built in libraries with a few evenings playing with an editor and reading the
online documentation.

Also go and look at Ceylon and Kotlin (please, please JetBrains get some code
out for Kotlin soon!), they both also contain lots of interesting ideas but
are more complex than Fantom.

In fact Fantom, Kotlin and Ceylon all have two features that I like, null
safety and a module and dependency system baked into the language.

