To be honest, [Scala] has been on my periphery for some time now. I had heard of it before, but the first real mention I actually remember was a talk [Ted Neward] gave at No Fluff one year. I couldn't go to that talk, but I remember him talking about it a few times some other talks he did that weekend.
Fast-forward 2010. When I went to [Strange Loop], there was some buzz on Scala. Of course, Scala is kinda mainstream for Strange Loop then so there wasn't that much talk on it, but there was buzz. Of course I ignored it.
So, with all that, this is what I knew about Scala:
- It's statically-typed. Since Python has been my first love, I really can't get into static typing. I see the benefits, but writing code in those languages makes it feel pedantic.
- It runs on the JVM. I already have Jython as my JVM-alternative of choice.
- It's kinda functional and kinda OOP. OK, Python is also like that, but that idea weirded me out.
Then we fast-forward to just a couple months ago. I read [this excellent blog post] and thought he was spot on when talking about the perils of modern day software developers. I honestly know nothing else about Michael Church, but he was spot on in the second part, so how right was he on the first part -- the list of languages?
I already know Python and C. And, OK, not ML and Clojure, but I know what their general idea was. And then there was Scala again. It was this thought that got my attention:
I think Scala is the language that will salvage the 5 percent of object-oriented programming that is actually useful and interesting, while providing such powerful functional features that the remaining 95% can be sloughed away. The salvage project in which a generation of elite programmers selects what works from a variety of programming styles -- functional, object-oriented, actor-driven, imperative -- and discards what doesn't work, is going to happen in Scala. So this is a great opportunity to see first-hand what works in language design and works in language design what doesn't.
And I'm all for that -- there are some good parts of OOP, but a lot of it has become painful. All the styles Church listed have some merits as well as downsides. If you can actually do all of them, then the cream of each style should rise to the top.
Another one of his thoughts grabbed me was:
[Scala] has an incredible amount of depth in its type system, which attempts to unify the philosophies of ML and Java and (in my opinion) does a damn impressive job.
Incredible type system? In a static language? I have yet to see such a beast. OK, the only static typed languages I have used are Pascal, C, and Java, and not one of them are good.
So, not to lengthen this anymore, I decided to dip more than my toe in the Scala waters and see what all this hype was about. After mucking with it off and on for about a week, I have to say that I've impressed. discovering a language since I started banging on Python over 10 years ago.
I'm far from a journeyman in Scala, but I'm getting up to speed on it rather quickly. When I learn something, I need to be a do'er , not a reader. I've been using [Scala Koans] to play with. It uses [SBT] to continuously run the tests, which is very cool. When I get to the point of mucking around a little deeper, I use [Scala Test] with SBT to give me the same continuous feedback.
I recently did [Osherove's String Calculator kata] to Step 6 in 30 minutes, without any Googling or even too much fumbling. That says something about how easy it can be to get started creating code that actually does something.
Here are some things I have learned to love in Scala:
- [Pattern Matchers]. This is probably my favorite. Now that I have groked them, I may never want to write a parser in anything but Scala ever again. I should also state I avoid
switch-casestatements of any kind in any other language but that structure works really well for Scala's pattern matching. When you use them with regular expression groups, magic happens.
- [Case Classes]. It does a lot of the boiler plate of making objects for you, and you get a sane
equalsto boot. And, as the link says, they go nicely with pattern matchers.
- The static type system does make sense, and does not annoy me. Look
numbers? Well, since we are filtering it, it must be a collection of some sort. Is it a
Listor is it an
Array? Then what is
negatives? Well, since we are using
filter, it must be the same kind of collection that
numbersis. But my favorite part is this: it doesn't matter. I know how
negativesshould behave, because it should behave just like
numbersdoes. This makes sense to me, so much so that a type declaration for
negativesbecomes superfluous (hello Java ...)
Now there are things that have annoyed me in Scala. But I'm a beginner so I think some of those things will iron themselves out. I've been coming up with web app ideas that I can start writing in [Lift], which probably says something about how how I feel about learning it.