The Northeast Scala Symposium just wrapped up in Boston. I braved the snow, ice, and bitter cold with Don Coleman, Al Iacovella, Nicolas Kijak, and Ken Rimple and lived to tell about it. We’ve collected highlights from a few of our favorite sessions from the first day.
Mathias Doenitz kicked off the first day of sessions with a talk on the upcoming Akka HTTP module. Akka HTTP is essentially Spray 2.0, but has a new foundation based on Akka Streams. The new stream architecture is expected to allow better performance in situations where the akka-http layer acts as a proxy, and provides a strong foundation for building WebSockets support. Interestingly he said that Akka HTTP is currently very slow, but expressed confidence that it will become performant. No promises were given on when Akka HTTP will be released. It is dependent on releases of the Reactive Streams specification and the Akka Stream implementation.
Toby Matejovsky talked about evolving a monolithic application into a set of microservices. He defined microservices as logically grouped sets of functionality deployed independently. He told us that it’s a lot easier to start with a monolithic app, but at some point you will (hopefully) outgrow that model and need to a adopt a microservices approach. One of the indicators that you need a microservices architecture is that you have multiple entry points in an application to support different types of servers. Although microservices make the applicaiton easier to scale, the approach does introduce some new problems to consider: there is more to keep track of, RPC calls are slower than in-process calls, and more care is needed in migration so that messaging does not break. Finally, he pointed out a number of useful tools, including sbt-release, sbt-assembly, sbt-native-packager and sbt-buildinfo.
Bill Venners gave a talk on his Scalactic library, primarily focusing on the
Or type as an alternative to scalaz‘s
Validation type. Scalactic targets people not familiar with functional programming, whereas scalaz relies heavily on users knowing functional programming. He says that Scalactic attempts to fit better into the Scala standard libarary. One example is putting the success argument before the error argument, which is more consistent with other Scala APIs and makes more sense for beginners. Bill stated that “Scala is a reform movement for OOP.”
In addition to explaining F-bounded Polymorphism, Marconni Lanna gave us a REPL-based slideshow with seamless live coding. Very cool!
Dick Wall gave an impassioned talk about contributing to the documentation of Scala. He recently began cleaning up the contributor documentation, and is soliciting help for several projects, including converting the bug tracking system from JIRA to GitHub, improving the core APIs, and documenting approaches/tutorials and content better on the website itself.
If you are a grammar expert, or typos hurt your eyes, you can even contribute editorial changes to the documentation. He is also looking to see people contribute more Activator templates, which can help beginners get started in new APIs.
Erik Orsheim gave a talk on Intervals, SemiRings and other features in the Spire library , which has a set of number abstractions and number types to augment those built into the Scala API.
Jon Pretty discussed how Scala infers types, and how it can make some rather crazy decisions for you when it doesn’t have enough to go on (try this in the REPL:
List(Vector(0), Range(0, 1)) and see the crazy type it comes up with). TL; DR – you can short circuit this a bit by specifying types in your declarations instead, but you should be aware that everything from your return type, to any applied parameters, to existence of a unique implicit may impact the ultimate types inferred.
Josh Suereth closed out the day by advocating that we should build UIs for our developer tools, and that sbt provides a good foundation for them.
Overall it was a great conference and we’re looking forward to next year in Philly.