Recently James Ward, Developer Advocate at Typesafe, sat down with Jon Pretty at Scala Technology to hear about his path to Scala and what he’s looking forward to in Scala 2.10. Jon is an experienced Scala developer, consultant and evangelist. He first launched commercial Scala applications in 2005, and has overseen numerous successful Scala deployments in the UK Government and other enterprises.
How long has Scala Technology been helping developers adopt Scala and why did you head that direction?
We started using Scala in 2004. At the time, as two-man team of recent computer science graduates, it was a purely technical choice: we wanted to gain a technical advantage in our consultancy business by making use of the latest bleeding-edge technology, and Scala showed huge promise. There was no business case back then for developing software using a language so unproven in real-world applications, so we had to create our own proof: within a couple of months we had launched the first commercial application developed in Scala. This gave us a start, but we were always selling the end-solutions, not the technology: business still had little appetite for Scala.
It took another five years for this to change, as Twitter gained popularity and the world suddenly saw how Scala was helping them grow rapidly; when the first Scala Days conference was held; and when Martin Odersky was taking the initial steps towards forming Typesafe. After half a decade, everyone was starting to take note of Scala and to see the potential we had identified back in 2004. This was a watershed moment for us: a new market was opening up, and we decided to focus our energy back on the technology. And thus, Scala Technology was formed, giving us an opportunity to use the vast experience we had built up over the years, and to work with people who shared our passion in Scala.
What have you seen lately? Who is adopting Scala today and why?
Much has been said of Scala's uptake in corporate environments, where the robustness of statically-typed languages has always dominated. But this shadows a lot of smaller-scale adoption by nimble startups, who might traditionally have chosen dynamic languages like Ruby or Python to build their prototypes or minimum-viable products.
There's a growing realization that Scala can not only give the traditional “agile” languages a close run at quickly getting a project off the ground, but it allows that product to be taken more easily to the next level. In the fast-changing conditions of a typical high-tech startup, being able to adapt is crucial, and Scala's ability to be refactored quickly, safely and with confidence makes it a perfect fit for this environment.
We've worked with both large and small businesses, though startups often present unique requirements, not just on the technology front but commercially too: Being able to accommodate different funding models and flexibility on costs and managing risk matter more to small businesses, so we're familiar with exploring different ways to manage that.
If you look a few years down the road, how does Scala adoption change?
Scala has huge momentum behind it right now, but it lacks the same exposure, tools, native libraries and support as the likes of Java and C#. In a couple of years, this will have changed: I expect Scala's tooling support to have caught and overtaken Java's, and before long, Scala will be viewed as one of the top ten mainstream languages. Most people will still be running Scala on the JVM, but I expect an increasing number of users to be deploying Scala on other platforms.
What are you most excited about in Scala 2.10?
The most notable new feature in Scala 2.10 is probably the addition of macros. But while they are very powerful, macros are the best solution for only a small niche of problems, so I'm more excited about Scala 2.10's subtler but more pervasive enhancements. Of these, support for dependent method types in the type system stands out as genuinely useful, opening library developers up many new possibilities, such as the Magnet Pattern. I've used dependent method types extensively in building an intuitive and extensible open-source API for I/O processing in the Rapture I/O library.
String interpolation also provides another useful weapon in Scala's DSL armory. As I've watched Scala's development over the years, new features providing a "quick win" (however cool they might seem at first) have never been favored over those which provide a complete solution integrated throughout the Scala language.
String interpolation is no exception, and although many people will have seen simple examples illustrating variable expressions inserted into string literals, fewer will be aware that Scala 2.10 lets users define their own interpolations in just a few lines of code. And it doesn't stop there: you can then pattern match against your custom interpolations, extracting and binding the expressions within, just as you can with case classes!