Metascala – A JVM written in Scala

Unless somebody like Tony Morris needs to feel better about his day. The average IRCer is really nice but (at least when I was over there) there is an ugly and abusive side that almost burned me out on Scala.

If you're only familiar with scripting languages, it's going to be sort of a leap into learning Scala and could be done I think, though probably not the language I would recommend starting with since it's easy to abuse. The syntax is nowhere the same, but Scala sort of reminds me of the "Perl of statically compiled languages" in that you can write some really obtuse code without even trying if you're not careful. I don't think that's a bad thing necessarily, because it's a language that gives you a lot of flexibility (and more than enough rope to hang yourself). If you work with someone else, be sure to discuss some sort of agreed upon standard to using Scala, else you'll end up with some messy code.

Scala looks a bit like Python in parts as well as Swift, but I consider it more closer to a progressive version of C# with F# mixed into it.

When I was learning Scala, I was intimidated by a lot of the syntactic sugar that it had. It's a calming effect to realize that all of that desugars into very simple, regular things. Java happens to be a very regular, unsurprising language.

So despite how surprising/special Scala may seem, under the hood it's just a bunch of methods.

There will be an acclimation period where you eschew the fancy stuff and stick with the Java style. But as you encounter the same structures and pain points, you will begin to see which Scala structures you like and will become comfortable with.

Find a style guide. Don't go crazy with point free. In general, it's a bad idea. (It's good if your DSL is super sexy/robust/easy to understand)

One safe rule of thumb is, as grammar and rules expand, the performance and simplicity of the compiler begin to deteriorate, particularly if features aren't added carefully.

The second is in practice, the additional grammar gives you far more ways to tackle the same problem. The is the conundrum that metaprogramming gives in languages like Ruby. Teams begin the phase of coding to the domain before letting other things fall into place.

Thinking ahead is good, but I think the issue is Scala's grammatical flexibility makes it too tempting to dig ourselves into a DSL before we're really ready. This is why we'd get so grumpy when PM's came to us asking for new features that'd require a refactor. We bought in to our own idioms, if we programmed things without the DSL, we'd be more nimble.

And we're not dumbasses. We're experienced programmers with experience programming in that domain before, but the target always ends up moving for reason's outside of engineering's control. From experience we know, DSL has no place until you're very secure in what the needs of the business is.

That said, no codebase is future proof to the rest of the team needing last minute changes - but I feel scala forces you into design decisions too early, and we thought that was an advantage.

Actually, I liked scala for not having Java's boilerplate. Then I began to miss those old things java forced you into.

It was painful, because the ego investment the team had in scala was huge. A lot was on the line. Crow had to be eaten.

[1] http://en.wikipedia.org/wiki/Principles_of_Compiler_Design

(Also, the designer of one of the languages mentioned was completely unaware of Scala when he created his own.)