There was a time when TheServerSide.com was a site primarily focused on Java development, and for those wishing to do .NET development, there was TheServerSide.net as well. But the server-side landscape has changed significantly since this site was originally launched. Java still dominates on the back-end, there’s no doubt about that, but a good server-side developer needs to know more than the lingua franca of the JDK.
The right development languages to know
Simplified scripting with Ruby
Understanding why Java doesn't scale
And finally, to be able to speak intelligently about a given enterprise software solution, a seasoned architect should know a thing or two about a peripheral JVM language like Scala. It's a difficult reality with which to grapple, but the fact of the matter is, Java simply doesn’t scale effectively. The manner in which Java manages data at runtime, having to traverse through large collections of objects while resolving a spaghetti like mess of shared pointers that link variables to their underlying data, slows the JVM down. As applications scale, this slow down becomes increasingly more pronounced. Interestingly enough, this inability of the language to scale linearly is a problem with the Java language, but not actually a limitation of the Java Virtual Machine itself. Linear scalability is indeed possible with the JVM, so long as the JVM is guided on how to manage the underlying data appropriately, and this is exactly what a peripheral JVM language like Scala does. Scala scales, and it scales along with the JVM, not in spite of it.
The benefits of learning Scala
There are other compelling reasons why a Java focused software developer should know Scala. The Java language isn’t perfect, and due to the global adoption Java has enjoyed over the past twenty years, changes to the language must be made slowly and diligently. Scala on the other hand first emerged about 10 after Java’s initial release, allowing it to incorporate a variety of new programming practices and tactics that simply weren’t considered best practices before the turn of the century. Functional programming, futures and actors are all incredibly powerful programming tools, especially when the development of a concurrent system is the end goal. These features have been baked into the Scala syntax since the very start, while the Java language is only just now starting to adopt them. Sure, Java 8 did introduce Lambdas, and Java 9 is looking to use an immutable data type to solve the pointer problem, but how long will it be before existing systems are migrated to those platforms? A feature introduced in the 2016 Java 9 release wont likely find itself in widespread use until 2020, if not later.
Even if you aren’t actively developing with it, the benefit of learning Scala is that it will not only teach you to be critical of how the Java programming language is implemented, opening your eyes up to some of the language’s shortcomings for which you may never have even been aware. And what’s more, Scala not only shines a light on these shortcomings, but it provides its own mechanisms to address them.
What do you believe to be the most important languages to know in todays world of polyglot programming? Let us know what you think.