I've not been blogging much lately because I've been heads down in a large ColdBox / ColdSpring / Reactor project and it's literally been taking all my time. What free time I ought to have has been consumed by FW/1 and managing the growing Railo Consulting business! The large project has been very interesting and it's drawing to a close as we approach launch. We've faced a number of very interesting challenges along the way and we've had to be pretty creative about our solutions.
One particular challenge has been the large, dynamic data set that the system's users represent and the fact that we have to export a subset of that user data to a fuzzy search engine that likes its data in XML (and, fortunately, its queries in JSON). CFML is very good at dealing with both XML and JSON but the vast amount of data and the huge size of the XML data packets being pushed around meant that CFML just simply wasn't the right language for that task. Sure, CFML can make individual user XML packets and post those to the search engine but what we really needed was a high-performance daemon that could run in the background, automatically publishing and re-publishing the entire database as needed so that we didn't have to deal with thousands of HTTP connections from CFML to the search engine during peak traffic, allowing us to scale more easily.
I've tried to pick up a new language each year for the last few years. I have experience with functional programming languages from back in my university days (and that formed the core of my PhD research back in the mid-80's) so I've dabbled with Haskell and Erlang in the past - but I've never had cause to use them commercially (unfortunately). In 2008, I focused on Groovy and liked the "dynamic Java" nature of it, stripping away all the "noise" in the syntax (such as semicolons!) so you can be much more productive than in Java. The Broadchoice Workspace - desktop collaboration - app used Flex / AIR on the front end and Groovy / Spring / Hibernate on the back end. It was a good experience (and I've recently done some more consulting on that project and it reminded me why I enjoy Groovy, all over again).
2009 offered an opportunity to learn a high-performance, statically typed language that supports both the OO style I've been using since the early-90's as well as the functional style I've known since the mid-80's: Scala. Like Groovy, Scala allows a nice, bare syntax (again, without semicolons!) although Scala is much heavier on operators than many other languages. Scala's function style, free of side effects, lends itself well to lock-free concurrent programming and that was just what I needed for the background process that scanned the database and published XML! In addition, XML is a native data type in Scala so it's incredibly easy to generate - and parse - XML directly in the language, without needing to revert to library functions.
Scala is statically typed, like Java, but it allows you to omit most of the type information since it infers it from the code. Whereas in Java you have to specify the type on both sides of a declaration like this:
SomeType stuff = new SomeType();
In Scala, it can deduce the type of the variable from the type of the expression you initialize it with:
val stuff = new SomeType()
Combined with the higher-order constructs afforded by closures (which you also get in Groovy) and functional programming constructs, the net result tends to be code that has very few type declarations anywhere in the code, except in function signatures. If you've written much Java, you'll appreciate how much less typing you have to do!
I've long recommended that CF developers learn additional languages. I've also long cautioned against learning Java as being both "too similar" and "potentially misleading" for CF developers (because writing CFML in the style of Java does both languages a disservice). I've recommended languages that are way off the mainstream like Prolog and Haskell because they make you "think different" and I believe that to be one of the best ways to improve as a developer. I think Scala is different enough that it makes a worthy target for CFML developers - in lieu of the far less mainstream Haskell - so you can experiment both with functional programming and with actor-based concurrency. Scala's structural type matching (via expression match / case construct) offers a little taste of Prolog too.
But don't just take my word for it: read why David Pollak came to Scala in 2006 and why he still loves it so much! David Pollak is the creator of the Scala-based Lift Web Framework (something else on my 'to learn' list!).