It all started with Martin Odersky's keynote. I saw this presentation online before, so I was not entirely surprised. Martin was telling the story behind Scala and how certain decisions were playing out in the long run. He argued, for instance, that in order to have collections that work with additional type information (in the form of a class tag) introducing CanBuildFrom was necessary, he also assessed that various language features such us implicit parameters (typeclasses), pattern matching for data decomposing, intuitive nesting, tailrec, everything-is-an-expression, unified set of collection operators worked well together. Later in the talk we were made aware of language features that lacked the same cohision (in particular: existential types, higher-kinded types and implicit conversions) and how Dotty could be the silver lining here (more about this later). After the keynote the reaction in the hallway discussions was mixed. Some thought that Martin provided an excellent assessment on the State of Scala, others found the talk a bit too defensive.
Eric Meijer (Rx Fame) was walking us through typical control flows issues such as returning from a try-catch. He moved from a classic imperative solution to a functional one, only to go back to Mutable State Land, eventually arriving at Goto-s. Entertaining! Next on my agenda was Viktor's and Roland's talk on Reactive streams (and more specifically the akka implementation of the spec). Reactive Streams was a hot topic during the whole conference and rightly so, being able to interop between various streaming API-s — independently from language and library — could be huge. It remains to be seen if library authors and users would embrace the new API. After that, I had to rewatch Endre Varga's talk on challenges in building distributed systems (which was my favorite talk at Craft Conf).
Brilliant stuff! Besides Reactive streams, the other common theme of the conference was house cleaning, which was expected given the fact that Scala just turned 10 years old! The macro based Scalablitz, for example, can achieve impressive speedups by applying parallelization & specialization techniques on various collection operations. Unfortunately, the list of supported collection types and operations are still a bit limited (in particular: no support for Lists) but I am certainly curious to see where this project will go! In Simon Ochsenreither's talk (Simplifying Scala), we were introduced to the struggle of fixing usability issues in programming languages (yay for simplified for comprehension syntax!). Then the Play team was gossiping about play 2.4 and beyond which I summarized in this tweet:
My favorite presentation of the day was coming from Nilanjan. In his food inspired Play Recipes talk he walked us through two real life problems (and dishes!) and then live coded the solutions on stage. While this in itself is nothing special, Nilanjan's apparent love for food and teaching made this talk very entertaining.
This was a loooong day, so the follow up roof top party was very much welcomed!
Through various metaphors Chad Fowler tried to challenge the negative connotation of Legacy in software development. The gist of the talk was that every system in use will get old at some point, so rather then trying to fight it, we should embrace our legacy. Breaking an application into smaller components (also known as the Hot Topic of 2014) is probably the best way to ensure that older systems can be maintained.
Dotty & Effective Scala
Dotty's legacy is Scala and the hope is that some of the ideas in Dotty could be folded into mainline Scala at some point. Nada's presentation was focusing on the central element of this research project i.e. how Scala's type system could be simplified by desugaring it to Dependent Object Types (DOT). Nada showed some great examples of the potential wins and challenges.
After that, Josh gave an entertaining talk on API design.
This is a topic where it's impossible to come to a common agreement but even so, Josh laid down a solid foundation for good APIs while also throwing in some nuggets like fighting binary incompatibility with method overloading.
While I am not an IDE user, it was good to see the competition in the (Scala) IDE space lighting up again. I particularly liked the new async debugger that was demonstrated by Iuilan. DI patterns and composition are always hot topics at Scala conferences. While DI (and especially DI frameworks) usually mentioned in a negative context in the Scala community, the lack of agreement on the best solution was apparent from the number of talks on this subject. The Reader-Monad-as-a-DI-solution idea (presented by Jason Arhart) was interesting but it's hard to imagine why either Cake Lovers or Implicit Context Passers would switch over. There were also a ton of talks I wish I had not missed, Miles Sabin & Jon Pretty's Scala: The First Ten Years or Dick Wall's Less Fashionable Patterns in Scala comes to mind but as I came to realize socializing always makes up for all the misses. After all, how else could I have been introduced to Dropbox's client side architecture or Company Flow otherwise?