
Scala – The Simple Parts - coffeecodecouch
http://www.slideshare.net/Odersky/flatmap-oslo-presentation-slides?1m0rTry
======
ryanobjc
From most of the people I talk to, they rarely complain that scala sold out to
industry, but instead talk about how complex the language is.

For truly widespread adoption, I'm talking PHP or Java levels, you need to
have a totally different mindset. I don't think Scala is that language.

~~~
ch4s3
I think achieving PHP or Java levels of adoption is as much about timing and
serendipity as it does language features.

~~~
wmhtet
Java(blue collar language
[http://dfjug.org/thefeelofjava.pdf](http://dfjug.org/thefeelofjava.pdf)) is
easy. Scala is not([http://blog.goodstuff.im/yes-virginia-scala-is-
hard](http://blog.goodstuff.im/yes-virginia-scala-is-hard)). (I am a Scala
fan.)

~~~
platz
I wish they would get rid of CanBuildFrom

~~~
saryant
I write Scala production code on a daily basis and I've never had to even look
at CanBuildFrom. I know it's there (I remember the API docs before they
started hiding things), I just never have to deal with it.

I know it's a common complaint, it's just one that's never impacted me in the
real world. Never comes up.

------
cfeduke
A word of advice: if you move from the .NET platform - C# - to the JVM, then
Scala is your language. Java was your language for a very long time, and Java
8 is pretty close, but I still believe Scala is the right choice.

There is a ton of complexity in the type system but you don't need to learn it
all at once. If you approach Scala development like you approach C#
development you'll go far.

~~~
pjmlp
I agree, if one can afford to be in a company that gives some freedom about
which tools to use.

If we are talking about the typical enterprise, with mega projects, having
out-sourcing and off-shoring components, then Java is still the king.

Since a few years I am mostly involved in such type of projects and I see how
many of such developers struggle with modern programming concepts.

------
eranation
Scala is great no matter what is the "true" answer to the question "is Scala
too complex?".

If it's indeed too complex for the mass average developers, then I can use it
to filter them out. I got a free way to hire better developers (I don't have
to use Scala in production in order to use it in interviews...) Also if you do
find a top developer who managed to master Scala's complexity, then the
complexity is no longer a problem, it becomes a benefit, and they use it to
create better libraries and APIs for the "regular" developers to use with more
ease and type safety.

If it's not complex then I can easily hire any decent Java developer and
provide Scala training (I think there is no argument that it's more productive
/ expressive than Java*, and remember in this "scenario" Scala is not more
complex to learn than Java)

Win win

Now the real issue is compile times. If anything itches me toward trying
Kotlin is having way too many coffee breaks
([http://xkcd.com/303/](http://xkcd.com/303/))

~~~
ryanobjc
Productivity of a programming language is a tricky bit.

Definitely you can achieve more with less characters in Scala than Java. Are
you paying by the character?

For me, legibility and long term readability is the most dominating factor out
of any. This is really subjective, but saving on characters you have to type,
only to make the code a lot harder to read seems like penny wise pound foolish
to me.

And to pull out an expert who agrees with me, Linus slaps C++ around for many
of the same reasons. He noted that it's a lot easier to review patches in C
because there is no hidden features (eg: operator overloading) that prevent
comprehension.

~~~
virmundi
I'm curious to see how Scala matures. Right now the community is really into
the FP side. So much so that they want to make everything look like Haskell.
So we've got operators and types and nomenclature that doesn't make sense to
the average developer. So the developers could mature/advance/become-academic
or they could take the good parts of Scala and treat it as Java++. I, frankly,
think the second is better.

~~~
platz
I'm not sure if it's accurate to say that the community is on the FP side, or
if there's just an extremely vocal FP community within scala drowning out all
the other scala community members.

~~~
virmundi
Perhaps that is true. But they seem to be in API vanguard.

------
virtualwhys
This is all a preamble to Dotty, the new experimental compiler ("dotc" in the
slides), making its way into Scala proper.

When it was first announced some Scalaz core members freaked out on Twitter
(due to proposed simplification of the type system), but that died down,
apparently the changes won't completely neuter the type system down to that of
other JVM languages.

Presumably tooling and build times will improve, along with fewer ways to do
the same thing, when Dotty comes on the scene (guessing a couple of years
away).

For now, if one makes use of SBT sub projects along with incremental builds in
SBT 0.13 (and turns off automatic builds in Eclipse/IntelliJ), one _can_ have
a snappy development experience and decent compile times.

Have to learn the ropes though, as with any powerful language, out of the box
there are hard yards to get through...

------
SkyMarshal
Scala was the first ML family language I learned. I tried to love it, but
found I needed help learning it, so I turned to Haskell hoping for a better
understanding of some of Scala's type system and other ML concepts. Then I
fell in love with Haskell.

Equally complex, if not moreso, and not any easier, but it felt simpler since
it focused on a single paradigm instead of attempting to mix two big ones, and
the whitespace-enforced readability and uniformity helped reduce cognitive
load while learning and working with it. Great performance too, C-like in some
cases with expert optimizations, and a range of concurrency and
parallelization options.

~~~
platz
yep. When I first tasted Scala it seemed great, but the having abstractions
that leak less (haskell) is something I really appreciate.

And there's something about Scala using traits for everything that rubs me the
wrong way.

Stuff like this I still find odd, mixing abstract classes with functions and
inheritance.

    
    
            abstract class IntSeqBuffer extends SeqBuffer {
         	     type U = Int
    	}
    	object AbstractTypeTest1 extends App {
      	  def newIntSeqBuf(elem1: Int, elem2: Int): IntSeqBuffer =
        	    new IntSeqBuffer {
             	 type T = List[U]
             	 val element = List(elem1, elem2)
           	       }
      	  val buf = newIntSeqBuf(7, 8)
    	}

------
tonetheman
Pretty much if there is a slide with a title "Why not use a Monad?" then this
is not the simple parts.

I tend to wonder why more people do not talk about Eckels book on Scala if
they want a more basic intro to the language.

------
dkhenry
The presentation is much better in person.

