Want to dive even deeper?

Take the course Stairway to Scala Applied Training - 2 by Bill Venners and Dick Wall and become an expert!
Stairway to Scala Applied Training - 2
by Bill Venners , Dick Wall

Check it out!
You're watching a preview of this video, click the button on the left to puchase the full version from ScalaDays 2013.

% Completed!


Keynote - Scala in 2018

It's 2018. Scala is now 15 years old and the dominant programming language for enterprise apps. But how did we get here? What hurdles did we tackle and what hurdles tackled us?

Published on
  • 22.722
  • 34
  • 32
  • 95
  • 37
  • What to Talk About… ?
  • The History of Poetry?
  • The History of Poetry?
  • The Perl School  Computer language poetry proposed in 1960s  First poems written in Algol in 1970s  Perl’s design allowed for poetry:  I know it’s weird, but it does make it easier to write poetry in perl – Larry Wall on a Perl feature, 1990
  • Black Perl BEFOREHAND: close door, each window & exit; wait until time. open spellbook, study, read (scan, select, tell us); write it, print the hex while each watches, reverse its length, write again; kill spiders, pop them, chop, split, kill them. unlink arms, shift, wait & listen (listening, wait), sort the flock (then, warn the "goats" & kill the "sheep");
  • Ode to Scala I love her silken symmetry; Her supple form entices (oh yes) Enraptures - entraps – me!   I love this it's heaven; Yet import pain.                    _ Sh*t  Why     this synchronized torment?   Heaven & hell
  • Ode to Scala if (she says) "Your love is not enough” (Resist, resist, resist) "I find your lack of faith disturbing.” Be not obsessed. Relax This map suffices That way madness lies; I say "It IS enough"
  • Ode to Scala class warfare extends ghetto (filled) with suffering if (easily angered) throw under the bus object ridicule extends warfare ridicule hurts class unity extends community with joy 1000 fold Remember The     wheel is not a new idea with Scala Remember & rejoice print { money }
  • Scala in 2018 How Scala Became a Mainstream Language
  • 2018: The Leading Newer Language  Scala has broken out of the pack  Biggest thing since Java  Language fragmentation here to stay  Specialization  No new blockbuster languages
  • 2018: Java Endures
  • 2018: Java Endures  Java is regularly pronounced dead  Deeply uncool  In reality, it’s not going away any time soon  Good for Scala, as its fate is linked to that of Java
  •  Not just about Java, it’s the JVM  An amazing piece of software
  • 2018: Users of Scala  Scala’s niche: Leading enterprise language  Traditional enterprise apps  Twitter-like category of super high demand consumer apps  Part of a messy world…  Java and Scala often mixed  DSLs an important niche for Scala
  • 2018: Who Doesn’t Use Scala?  The mythical “corporate developer”  Scala is not adopted by millions  Startups less likely to use Scala  Still hate the JVM  Still love dynamic languages  May rewrite in Scala if they encounter the Twitter scenario  Front end no longer on the JVM  Predominantly JavaScript
  • How Did Scala Win?  Moved toward the mainstream  Embraced Java ecosystem  Chose to fight only winnable battles  Scala language innovation slowed down, improving backward compatibility, compiler and tooling
  • Oh No!
  • Sometimes It’s Good to Sell Out
  • Some Successful Sellouts Tony Flow and the Miraculously Majestic Masters of Red Hot Chilli Peppers
  • …some Successful Sellouts Mother Mcree’s Uptown Jug Champions Grateful Dead
  • Confession: I am Biased
  • Confession: I am Biased  Have coded purely in Scala for the last year  I love Scala more than any language since C  Doubt I will program in Java again  Chose to join Typesafe board
  • Confession: I am Biased  Have coded purely in Scala for the last year  I love Scala more than any language since C  Doubt I will program in Java again  Chose to join Typesafe board  Pretty typical background for a Scala adopter  Enterprise software experience  Java background
  • Why Scala is Awesome  Not verbose like Java  Amazingly flexible for a strongly typed language  I’ve always liked type safety  Elegant combination of OO and functional  Best code reuse I’ve seen
  • Why Java Sucks  Verbose and error-prone     Lack of default method arguments Constructor duplication Getters/setters …  Immutability doesn’t feel as natural  Comparative lack of code reuse
  • Why Java is Awesome… Reason Scala response JVM is robust and performant Scala runs on the JVM Awesome tooling • Strong typing helps tooling • Improving in Java-based IDEs Community of pragmatic programmers focused on solving real world problems Mixed community, includes purists and zealots
  • …Why Java is Awesome Reason Scala response Great backward compatibility Poor backward compatibility Powerful libraries and frameworks • Consume Java libraries easily • Ignore Java solutions and rewrite in Scala Restrictive language Flexible language a blessing & a curse Culture of readable code Culture of unreadable clever code
  • Lessons for Scala From Java’s Popularity  No accident Java is #1  Learn from Java’s successes as well as its failures  Play nice with Java, rather than totally rejecting it
  • Myths That Hold Us Back
  • Myth #1: It’s Good to be Clever def templateContent: Parser[(List[Simple], List[Def], List[Template], List[TemplateTree])] = {         (several(importExpression | localDef | template | mixed)) ^^ {           case elems => {             elems.foldLeft((List[Simple](), List[Def](), List[Template](), List[TemplateTree] ())) { (s, e) =>               e match {                 case i: Simple => (s._1 :+ i, s._2, s._3, s._4)                 case d: Def => (s._1, s._2 :+ d, s._3, s._4)                 case v: Template => (s._1, s._2, s._3 :+ v, s._4)                 case c: Seq[_] => (s._1, s._2, s._3, s._4 ++ c.asInstanceOf[Seq[TemplateTree]])               }             }           }         }       }
  • With Great Power Comes Great • Implicit conversions • Implicit parameters • Operator overloading • Ability to use unicode charset in identifiers • Renaming imports • Type inference • Powerful collection library with baffling internals • …
  • With Great Power Comes Great • Implicit conversions • Implicit parameters • Operator overloading • Ability to use unicode charset in identifiers • Renaming imports • Type inference • Powerful collection library with baffling internals • … Cannot simply deny this and argue language is simple
  • Lessons from C / C++
  • Lessons from C / C++
  • Advantages of Languages in Which You Can’t Write Poetry…  Also hard to hang yourself  Java’s success was partly due to being less powerful than C++
  • Advantages of Languages in Which You Can’t Write Poetry…  Also hard to hang yourself  Java’s success was partly due to being less powerful than C++  Java 8…  Good for Scala, bad for Java?  But we don’t want anything bad for Java
  • Dispatch “periodic table”  Need to translate into English a design smell  Good code is self documenting
  • About Readability, Not LOC
  • About Readability, Not LOC java is much better suited for big teams *because* it's a stupid language that feels like you're coding with yours [sic] hands bound. the more humans you add to a group, the more stupid each individual gets, even if they all are geniuses.
  • About Readability, Not LOC Any fool can write code that a compute can understand. Good programmers wri code that humans can understand – Mart Debugging is twice as hard as writing th code in the first place. Therefore, if you write the code as cleverly as possible, yo
  • Need Scala Coding Standards  Can do the same thing in many different ways  Poetry may not be good code  Need to converge on one good way  Something the Rails guys did well with Ruby  Need clear division between application developer and library developer roles  Martin Odersky “Levels”: http://www.scalalang.org/node/8610  Don’t make application developers do bizarre stuff
  • Myth #2: Ignorance Should be Punished
  • Myth #2: Ignorance Should be Punished If your coworkers are idiots, that's really a problem with your coworkers.
  • Myth #2: Ignorance Should be Punished If your coworkers are idiots, that's really a problem with your coworkers. You even said "avoid answering Scala questions with Haskell." Fuck you Kevin. If I feel it is appropriate to answer with Haskell, I will do exactly that -- I really don't care that you do not understand.
  • Lessons From Other Communities  Groovy  Poor language, great community  People are welcomed, not abused  It’s OK to write in Java at first  Spring  Culture of respect in forums  Karma works  Respect breeds respect
  • Facts To Remember  Most of those who will use Scala in 2018 aren’t using it today  Where will they come from?  All leading languages are similar to Java  Java community 52x larger than Haskell community  How do we welcome them?  What do they need to be productive and adopt Scala incrementally?  Make their first weeks enjoyable, not humiliating
  • Myth #3: OO is Bad  Shouldn’t feel guilty for using OO design  OO is a valuable and proven paradigm  Scala is a better OO language than Java  If you hate OO programming, go write Haskell or Lisp
  • Myth #4: We Don’t Need Frameworks Language so good we don’t need no lousy frameworks
  • Myth #4: We Don’t Need Frameworks Language so good we don’t need no lousy frameworks  It’s not just about the language  Much real world programming has little to do with elegant expression of algorithms
  • Myth #4: We Don’t Need Frameworks Language so good we don’t need no lousy frameworks  It’s not just about the language  Much real world programming has little to do with elegant expression of algorithms  Like saying we have a fast car, so we’ll use the time we save to build our own road
  • Myth #5: Java Sucks and Java Coders Aren’t as Smart as Us  Tendency to dismiss Java viewpoints and libraries  Typical arrogance of a young community  Appropriate for a while
  • Exhibit A: Scala ORM in Theory I think we really need SIQ or whatever we call it shipping as soon as possible. Being able to say here are the hundreds of lines of code you need to work with a database:   you need some classes for ORM,   dozens of annotations to describe the connection between them  dozens of lines for simple type safe queries  you need to know the quirks of Hibernate/JPA/EclipseLink and   you probably still need to write SQL for more complex tasks and here is how you do that in Scala, with a single line of code: <example> I think if we would have this, we have more or less won the whole enterprise stuff.
  • Exhibit A: Scala ORM in Practice val withAthleteAndComments = { (Workout.withAthlete ~ Comment.simple *) map { case all => all.groupBy(_._1).headOption.map { case (workoutWithAthlete, comments) => " " (workout, athlete, comment.map(_._2)) } } } That will get you a Option[((Workout,Athlete),List[Comment])]
  • Embrace it: Java Ecosystem is a Huge Benefit to Scala  A key strength  Not an embarrassment  Shouldn’t assume we can do everything better in Scala
  • Myth #6: Purity Matters What if many people are wrong? It's not as if there aren't countless examples of many people sharing the same mistake, surviving only by patting each other on the back, confirming the perpetuity of the mistake.
  • Myth #6: Purity Matters What if many people are wrong? It's not as if there aren't countless examples of many people sharing the same mistake, surviving only by patting each other on the back, confirming the perpetuity of the mistake. val withAthleteAndComments = { (Workout.withAthlete ~ Comment.simple *) map { case all => all.groupBy(_._1).headOption.map { case (workoutWithAthlete, comments) => " " " (workout, athlete, comment.map(_._2)) } } }
  • Myth #5: It’s All About New Language Features  Mainstream languages can’t progress like the wind  Backward compatibility matters  Scala will win as an enterprise language  Scala needs to be more boring
  • The Only Thing that Needs to Go Faster is the Compiler  Compiler is slow and buggy  C++ eventually solved those problems  Language is a moving target  Makes it harder for new adopters to learn
  • My 2c On Language Innovation  New language features like macros not highest priority  Need to create two language profiles  Academic experimental tool  Drive the future  Subset: Scala for working developers  Stable, small footprint  Need to be paranoid about footprint
  • Conclusion
  • A Critical Moment  Scala has a great chance of being the next big enterprise language  Less likely to appeal to startups  The Scala community will determine what happens next  What will Scala be when it grows up?  Do we want it to be mainstream?
  • How Scala Becomes Mainstream  Community needs to evolve more than the language  More pragmatic  More welcoming of newbies  Coding standards need to be developed and adopted  Need to embrace the Java ecosystem and Java  Need to stop reinventing wheels  Scala language innovation needs to slow down
  • The Journey Has Already Begun… Welcome     new era with boundless       potential   Thread sleep sweetly. Enough.  §


Jo Voordeckers 2 years ago
Excellent quote about readability: #43
Peter Pilgrim 2 years ago
I thought it was one of Johnson better keynotes: a nice return to form when Spring Framework was new 2005
Tom Switzer 2 years ago
I thought the talk was overly negative. He showed no examples of the community actually helping someone or anything. Instead he focused solely on the bad parts and a few choice quotes. It puts the community in a bad light and completely ignores all the awesome people who spend their own free time to help others learn Scala. If you want to make the community better, shine a light on the people who are doing good and teaching others and ignore those who aren't helping. I feel this was a step back for the community, which I personally think has actually been doing really well over the last year (give or take).
tpolecat 2 years ago
Agree with Tom. I found this talk arrogant, insulting, and profoundly ignorant.
Naftoli Gugenheim 2 years ago
Clearly this guy doesn't follow the mailiing lists. The one single individual who made the mailing list unpleasant was banned a long time ago. In order to make his point he has to dig up a 2-year old post?
Nick Clarke 2 years ago
What Tom and tpolecat said. Watching this talk made me quite angry, and if this is really where Scala will end up in 2018 then that's pretty depressing.
2 years ago
His talk was great, blunt, and deep. If we want to make Scala accepted as a first class citizen in the enterprise world besides Java we should follow the pieces of advice he gave us in his talk. He already made it once, so we should be grateful to have him on the Scala side.
Scott Yan 2 years ago
I thought there were good and deep advices in his talk, which we should take in the future. In my opinion, it was a great talk. :)
AndreasS 2 years ago
Often the phrase 'idiomatic' scala code is used in this talk but no definition is given. Scala reinvents java libs because there are problems with the java solution. Finding the problem naming it often helps on improving the situation. Also I dislike the claim that there are more junk libraries in scala than in java. Facts, numbers? Definiton what 'junk' means? Its a bit too foggy to make a real argument but it is used all the time in the talk :/
Josh Cough 2 years ago
I also agree with Tom. There are so many examples in here, but I'll just pick one. He said that we need to have a less arrogant, more accepting community, but also on a huge rant against dispatch - a library built by one of the best community members. This is awesomely hypocritical. His goal is clear, and even stated - he wants Scala to sell out, because he wants to be able to cash in. Scala in 2018 should be about building the best possible Scala, not building the version that makes the most amount of money.
Seth Tisue 2 years ago
I found this talk sadly divisive. Especially when it reopens old wounds in the Scala community from several years ago. Until now, those wounds had been healing just fine.

Also, I think Rod's own position in the enterprise Java world makes him look to that world for Scala's growth. But that world is aging, conservative, and backwards-looking. I think we should focus on making Scala attractive to fresh faces and fresh minds. People at startups, people just now learning to program, and so on. People who pick languages because they're fun to program in, not because legacy lock-in forces their hand. People who if we lose them, are much likelier to choose Ruby, Python, or JavaScript — not Java and the "enterprise" technologies that have accreted around it.
Simon Ochsenreither 2 years ago
What pains me most is not that I've been called arrogant, naive and stupid in that talk, but that the actual "exhibit" does not support but contradict his claims. Instead of wasting his ridicule on me, he could have had a look at what Slick and Scala macros have been up to in the last year. (Hint: The "single line of code" which I wanted to see has already been written.)

Anyway, I found the X vs. Y attitude disappointing, because it devaluates the work of all those people out there who worked incredibly hard to make proponents of _both_ X and Y happy.

Some of the things mentioned are not only reeking of anti-intellectualism, but are just plain dangerous, like the idea of splitting Scala into an "academic" and "pragmatic" profile. That split will not only go through the language, but will divide the community as well. At a time when parts of the community are already on the verge of creating their own language due of the perceived lack of progress in topics they strongly care about, this is certainly not helping.

In the end, the question really is (as Seth) mentions: Are we happy to live solely in a walled, Oracle-owned garden, where we are being shown around as a proof that Java isn't _that_ embarrasingly outdated?
Or do we to target new devices, support more deployment scenarios, encourage people to experiment with it and be more welcoming to people who are not "senior JavaEE experts"?

We all see how rapidly the Java ecosystem is losing mindshare and influence pretty much everywhere (except on the server): Java on the client is pretty much dead, Java applets are more than dead and the mobile story should be known to everyone by now.

The prospect of gaining a bigger share of a stagnating/declining market doesn't sound that great to me when I see how other market segments are experiencing an explosive growth.

In short, do we want to be more like TurboHercules or Xamarin?
Sander Mak 2 years ago
Agreed with Seth, but realistically, that's not where the majority of the easy money is. With Typesafe they chose to make Scala a business. This has consequences. Not saying it's bad, but the enterprise market is one they can't ignore from a business perspective. Personally, I think it's great that Scala doesn't have to be a mono-culture either way.
Seth Tisue 2 years ago
“Scala doesn't have to be a mono-culture either way” — amen.
Sergii Starodubtsev 2 years ago
Like about poetry especially in the beginning.
Justin Forder 2 years ago
I agree with Rod's points, but I don't think it was necessary to use actual quotes from the mailing list to illustrate them.
Darth Hater 2 years ago
The statement about some part of the community is still very valid. The statement of Naftoli Gugenheim above is not true. That "$%"% (Morris is his name) is still on the mailing list.
Darth Hater 2 years ago
The conclusion of this talk that the community is the problem NOT the language should alert us all!
Frederic Masion 2 years ago
Not very smart and a bit provocative but the facts are true :
-The community is the most important thing
-Scala can't become mainstream if it is elitist or for purist
-Scala isn't haskell
-There's no need to reinvent the wheel because it not written in scala

I would prefer do some scala with "java noobs" on my working time rather than doing it with purist only on my free time ;)
It's time to make scala mainstream
Will Barksdale 2 years ago
A couple of these comments represent exactly the attitudes that are so destructive to the language.
Matteo Mortari 2 years ago
I'm new to Scala, and personally I find indeed is missing a clear and neat *instruction* on how to do ORM in Scala (in a simple and neat way). Indeed slide parleys.com/channel/jfokus-201… resonates with my experience. Besides of this, I like a lot how Scala is helping me in building tools, like data transformations, etc.
Brian Tarbox 2 years ago
All of these things needed to be said. I count myself an advanced beginner in Scala and my heart sinks each time a huge new language feature or feature cluster is added as I'm still absorbing the "old" stuff. Our Boston Area meetings are great and I enjoy them but there is certainly a part of the community that prizes cleverness over readability (though I guess if I was smarter that clever code would be readable). Keep in mind that RJ knows a thing or two about building successful systems.
Viktor Hedefalk 2 years ago
I definitely agree that the description of the community was overly negative. For me, the Scala community has been as important as Scala the language in making me more productive. It's of course easy to dig up a few offensive posts in any large enough mailing list. But I believe that the Scala community is a highly welcoming place for newcomers. I've been hanging out mostly in the Lift list and that has been incredibly valuable for me.

Also, once you start to know the people in the forums you can also kind of filter out and just absorb the good stuff. Actually, Tony has probably written some of the most informative posts out there, and quite soon you'll just accept the wording that sometimes goes with it. The context of the post Rod showed is also not that Tony wrote "f*ck you" to the newcomer OP, but to Kevin, another senior community member and that they clearly have a history. Still, of course you want the forums to be a kind of warm and fuzzy place so I'm definitely not defending it.

parleys.com/channel/jfokus-201… - "Do we want it to be mainstream?". We'll, the rest of the talk clearly uses that as an axiom. I think Typesafe is great and I have a lot to thank the people there for. It's also great if they can make a few bucks and most of them definitely deserve it. However, Rod's opinions represents the bad part of commercial Scala for me. I for one will scream "fork" if the strive for mainstream makes the language aim for the obvious worse. I hope he doesn't have too much influence over there at Typesafe.

/import language._
twc…@gma….com 2 years ago
I am from the Groovy community and have to say Rod's comments about the Scala community are spot on. The Scala community is full of 'self-righteous language bigots'. There might be some nice people in the community but as a failed Scala programmer, I have to say one thing that turned me away from Scala and back to Groovy was the negative community. No need for anyone to consider themselves better for knowing something that another person does not yet understand. Good luck attracting new developers.

I must admit I did not like Rod's assessment of Groovy as a 'poor language' but he is someone I greatly respect technically and is entitled to his opinion. Nevermind, my community is full of very nice, helpful people. We can usually have what I consider 'big boy' conversations where you can disagree and not be verbally abused.
con…@gma….com 2 years ago
I think this talk will become a important MILESTONE for scala.

As a advanced-/beginner+ scala programmer working on my first project, I remembered my early days of frustration:
horrible language API docs(think about CanBuildFrom's),
incompatibility issues between scala versions,
a community that dislikes(or even hates) any questions related to Java or Java libraries,
a community that advocates(or even enforces) immutability but never tells you how it would complicates your problem(think about lenses),
libraries that are impossible to use util you read and understand its source code... ...
The list can go on and on.

So what Rod did here is no trivial IMHO, he studies and understands what it means for a beginner to start learning scala, what they like, what frustrate them, what the community should do to help them.

He's blunt, he even use words like "sellout" while he could use "compromise". But what kind of "sellout" is it?
Is it sellout if you take two minutes to write an alias of a method called ':<<|' with a name 'filterAndAppendTo'?
Is it sellout if you tell a beginner to (try and) "pimp" a Java library and give him some good example on how to "pimp" it, instead of writing a new one? (the word pimp also shows how self-righteous we are.)
My answers will be no, and i truly believe that i'd learnt much faster and achieved more if our community is a bit more friendly.

So my two cents: as a community we need to reflect on a lot of things we did, and Rod's talk is a very good point to start.
And people, don't be fixated on those so-called "sellouts" because they are not. They are compromises we make to become a better community and eventually making scala a better language for everyone.
Mathew de Detrich 2 years ago
Simon, your comment actually is proving Rod's point, not disproving it.

If you want a completely intellectual language whos target domain is an audience who have a masters in computer science and spent the last 2 years studying category theory, then go learn Haskell, or heck, go even deeper and learn stuff like Agda

On the other hand, if you want a pragmatic language that is trying to blend OOP and Functional programing, then use Scala

One of the biggest issues personally is the amount of clever hackery and boilerplate abuse in Scala libraries is painful. Reading someone elses Scala code, almost all of the time, ends up resulting in a metaphorical lobotomy. Scala as a langauge is nice, but so many core parts of its system are a mess. Its build tool, SBT, is horrifically overcomplicated (and believe it or not, a build tool, moreso than any part of the language, needs to be easily understandable by anyone, because anyone is going to be using that tool), and Scala still severly lacks any decent ORM/Database layer. Slick is a nice concept, but is anything but DRY considering how expressive scala is (just look at how you define models), and the other ORM (such as squeryl) suffer the same problems.

The other comment I would like to make, is that pure functional programming is not the solution to everything. ORM's are needed in Scala, just as they are needed in Java, because they solve certain types of real world problems much better than how functional alternatives do. People in scala need to stop reinventing everything in a purely functional way just for the hell of it or because they like it.
Jelle Victoor 2 years ago
Rod is making these blunt statements to strengthen his point, don't be personally offended by it, that is not the goal of this talk. I thought he had some interesting insights.
Worst talk ever in my life! what a negative talk with pointless enumeration of mythical problems. If there are problems, suggest solutions. This is especially needed when the problems mentioned are "personal", "moody" nonsense ones. I was actually surprised that the word "F**K" and an explicit naming of the subject was in a talk! was he drinking when he prepared the talk slides? pathetic, such a waste of my time for this one.
Nicolas Martignole a year ago
I agreed to most of its points, being a "pragmatic developer". This was really an interesting keynote. Scala is moving fast, most of the Scala developers are also Java developers. I really think also the point about OO is important. Scala was not designed to be "just a functional language". I encourage Scala-fist to read the intro by Martin Odersky in "Programming in Scala : a comprehensive step by step guide".
Alan Johnson a year ago
Great talk. I'm very new to Scala and so I don't know much about the community, but I think his points apply not just to Scala, but to any community.
Anton Kuzmin a year ago
Good talk. All those who felt offended, are just pumped up with their pride and they couldn't stand the constructive criticism.

Login to add comments!