Scala Days Chicago 2017: What You Need to Know
Jeff Olchovy, Principal Engineer at Tapad, speaking at Scala Days Chicago
We kicked off a busy conference season at Scala Days Chicago last week (you’ll find us at Scala Days Copenhagen, FlatMap, and JavaZone later this year). Tapad co-founder and CTO, Dag Liodden, led a session on “Building a Company on Scala” and Principal Software Engineer, Jeff Olchovy, discussed how Scala developers can make the most of sbt in his talk, “sbt: Beyond the Build Tool”. We won’t give too much away since they will also be discussing these topics at Scala Days Copenhagen and Flatmap, but for a quick synopsis check out our tweets from the event.
Dag Liodden, co-founder and CTO of Tapad, speaking at Scala Days
For those who couldn’t make it to this year’s conference, here are a few notable takeaways:
The future of Scala is being explicit about the implicit: Martin Odersky’s keynote addressed the feature that he considers “makes Scala ‘Scala’”: implicits (calling functions or passing around parameters without explicitly stating it). Odersky mentioned that although they are meant to be used to make our code simpler, implicits can actually be a blocker for many Scala beginners because of the flexibility to misuse them. In thinking about the future, it’s time to be more explicit in how we use implicits in order to make their use cases clearer. Martin spoke about some of the proposed changes in future versions of Scala to achieve that, including: only allowing implicit methods (not vals) to be eligible for conversions, or allowing to pass in multiple implicits to a function, something not currently supported.
Scala is powerful, but shouldn’t be intimidating: This was a point that both Dag and another speaker, Kelley Robinson of Sharethrough, hit home. The main points being that:
Functional programming has a wide spectrum of use cases. They can be as basic as using higher order functions in conjunction with immutable data or as advanced as applying function composition over complex monads
Scala allows the user to write functional code from both ends of the spectrum. You should not feel like you are writing “bad Scala” if your code does not embody super functional programming techniques. For example, at Tapad, teams are encouraged to use Scala in a way that feels natural to the team, and in many use cases that results in a mix of object-oriented and functional Scala programming. This flexibility has played a prominent role in the success and growth that we have experienced.
While Rust isn’t Scala, it can offer some interesting benefits: Aaron Turon of Mozilla introduced Rust, a programming language sponsored by Mozilla. Rust is exciting because it aims to be a low level language while providing a lot of the benefits that higher level languages do. This can be seen in the way memory management is handled as it shouldn’t ever be possible to have null pointers. Although Rust is still a fairly new language, we look forward to seeing how it progresses.
Scala.meta is a toolkit with some promising use cases: Our take of Pathikrit Bhowmick’s talk was that this could be useful for a handful of different applications, such as writing macros. Scala.meta provides a very easy to use way of writing complex macros. One cool case where this can be applied is for serializing/deserializing case classes. With Scala.meta it is easy to create an efficient way to serialize case classes, which will also be applied recursively so it supports nested case classes. Another exciting use case is parsing abstract syntax trees, which can be used for complex expression evaluation.
Keep an eye out for further updates from Tapad Engineering while we are on-site at FlatMap and Scala Days Copenhagen! Hope to see you there.
Please also find this post on our new Medium blog.