Wednesday, 4 December 2013

Scala's Maturing Community

I've been involved in the Scala community and attending Scala conferences for about four years now. I've just come back from 2013 Scala eXchange, hosted by Skillsmatter in London. It was a great conference, one of the best I’ve been to, and the organisers and speakers should be thoroughly pleased with their efforts. One thing that I did think quite interesting was a significant change in emphasis from all of the previous Scala conferences that I’ve attended.

When I first started going to Scala conferences four years ago, the emphasis was definitely on an introduction to Scala. The talks focused on basic language features, how to use the collections libraries and core functional programming concepts. There were also some side talks about interesting libraries built in Scala, like Akka and Lift.

Last year the focus moved to a higher level, with more time spent on talking about where Scala was going and on more advanced functional programming concepts. There were talks focusing on things like Lenses and Monads and lots of detail about highly functional libraries developed using Scala. Presentaions about Akka and Lift were still present and people were starting to talk about Futures. In all of these talks, however, functional programming was the primary focus.

At Scala eXchange this year the emphasis was almost entirely flipped around. Most talks were about reactive programming using asynchronous approaches. Loads of stuff about Akka, actors, futures, events and the like. Some talks focused on Scala features such as macros and using type classes. However, there was very little direct talk of functional programming: it was just assumed that everyone present was using immutable data and following a functional programming approach. A huge shift in perspective from just a year ago.

I believe that this represents a massive shift in the maturity of the Scala community. We have moved from an immature group learning about how to use this exciting new language, how to work with immutable data and how to blend functional approaches into our code. We have instead become a group who are using this fantasic language and a set of fairly mature products and reactive techniques to build highly scalable systems. A huge leap in just a couple of years.

I remember a similar transition in the Java community when conferences went from talking about basic Java concepts like POJOs, collections and design patterns to talking about building complex solutions using advanced libraries like Spring and JMS. The Scala community seems to have made this leap much more quickly than the Java community did.

The one thing that worries me slightly about this change is that using immutable data and functional programming has almost become an unwritten assumption. Each presentation just seemed to assume that you would be programming in this way by default. While this is great for those of us in the community who have made this transition, I think we need to be careful not to skip this step for those people just transitioning into the Scala world.

The worst case would be developers transitioning from a language like Java straight into an asynchronous reactive programming model without first going through the transformation of thinking in terms of immutable data and functional programming. Bringing the concepts of mutable state and imperative code straight into an async world is a recipe for disastrous software projects. These in turn could tarnish Scala's representation and significantly complicate the life of those of us trying to bring Scala into traditionally conservative organisations and companies.

It's great the the Scala community has come so far and matured so fast. But, let's not forget the core concepts that underly this transformation. We must ensure that we continue to emphasise their importance as we move forward into the brave new world of highly scalable, asynchronous, reactive systems that Scala seems to the targeting so directly and successfully.


  1. I certainly agree that the level of topics is one up from the last year- there's more bleeding-edge and advanced stuff, but balanced with case studies from the industry.

    I definitely agree that the Scala newbies might have felt in the wrong place, at least initially. At least that was my impression when I overheard someone complain that they don't understand anything from Simon Peyton-Jones' keynote about lenses. It was a very challenging talk and Simon is a very entertaining and energetic speaker, but maybe some justification for going through all these hoops was necessary- see, Haskell cannot mutate state (at least not uncontrollably), and there are some benefits, e.g. for concurrent programs, etc., etc. Also there were some tweets wondering why a Scala conference starts with Haskell- is it because Scala wants to be Haskell? Is this where it should be going? Maybe some of these concerns should be addressed so newbies can feel at home. I feel Viktor's talk was much better as a starting keynote- it was entertaining and addressed a very fundamental aspect of computation. All in all it provided a compelling justification of why reactive (and why functional).

    According to Wendy (SkillsMatters' CEO), there have been about 3 times as many attendees this year compared to last year- amazing! So yes, Scala is growing- and maturing. There must be something it's doing right (I believe it is), and the community can only win when new people join and share their perspective.

  2. SKILLSMATTER = Unable to download the videos.

  3. Anyone transitioning to Scala and not going through the FP Coursera course is making things hard on themselves and extending their learning curve unnecessarily.

  4. Scala's Community Maturing? that'd be a good idea

  5. Scala is really a nice language and I will love to see it as a platform like Java in near future. Community is definitely growing, I can see lot of blog post about Scala, Akka, Play and Slick but still a lot of ground needs to be cover to come anywhere near to Java.