dow.ngra.de

As I’m learning my way with Scala one analogy cannot escape from entering my thoughts. The analogy is (of course?) Haskell.

However I don’t mean the way the language is built up, but rather the way it’s governed. Both Haskell and Scala are designed and implemented by brilliant scientists, who are the benevolent dictators when it comes to choosing the language features. In the Haskell case it’s the Simon Marlow and Simon Peyton-Jones behind the GHC compiler along with a very active community with a lot of outstanding members. In the Scala case it’s Martin Odersky and the LAMP.

Such a setup means that the language leaders are highly aware of the decades of computer science research and can pick the best and innovate on top of it. This is great, because you get substance instead of the buzzwords. However this also means that they are driven by success in research community.

What is the problem with that? Well, Martin is the professor at LAMP, which today means he has to teach and produce papers. However, to publish papers one must be constantly innovative, since CS conferences do not readily publish just case studies and tech reports. Since his main focus seems to be Scala it means that the language is constantly evolving to accommodate the innovation needed to get published.

The drive for innovation by itself is wonderful. However a programming language is a relatively fragile thing, since it must fit into the imagination of potentially millions of people. But when it’s constantly improving it is hard to fit it in. Just look how much trouble introducing Generics caused to Java programmers.

The reason why I started with Haskell is that situation in that community is even more extreme. While Haskell 98 report standardized a relatively conservative language almost everyone today will use the GHC extensions. And those take by now the largest part of the GHC user guide and are often underdocumented and hard for a newcomer (and sometimes an experienced Haskeller) to understand.

The Scala changes are perhaps not so extensive and we are dealing with a more practical language, but still the change log in the end of Scala spec makes for quite a long read. And since I love the language itself and the people behind it I would be very interested to know what are the goals and how long will Scala continue to evolve before slowing down.