This is mostly due to the Scala compiler being a bit slow. The team at Typesafe is working on that, but if you don't want to wait just buy a decent recent machine with a SSD and you will get back the snappiness you had with Play 1.
True. Reloading pages on Play 1 (Java) took less than a second. It's about ten seconds now on Play 2 because of Scala.
The move to Scala feels like a mixed bag to me: it added both features and bloat to Play. Play 1 feels so light and fast in comparison.
It seems to me the Play developers moved to Scala more for personal fun than for their users (nothing wrong with that, just making an observation).
There's a project out there somewhere for integrating Groovy with Play but it looks quite immature.
Play 2 stripped out all the Groovy code from Play 1. There must be a reason.
> Groovy 2.x offers pretty much all the benefits of static compilation and dynamic language features together
Groovy's dynamic compilation is reliable, but sloooooooooow. The static compilation added in Groovy 2 is much faster but still buggy e.g. http://stackoverflow.com/questions/14774709/groovy-2-1-0-wei... It was written by one developer, and first shipped in Grails only 2 months ago. And does Grails actually use any of Groovy's static compilation features? I haven't seen anywhere it's used: point me to somewhere in the Grails codebase if it does.
You don't get all the benefits of static compilation and dynamic compilation together, you can get bugfree (but sloooooooooow) code, or faster (but buggy) code.
I guess you mean execution speed, not compilation? Compilation is fast enough I think. Execution certainly compares fine with other dynamic languages, at least, in my usage (and for some things it is much faster).
> The static compilation added in Groovy 2 is much faster but still buggy
The bug you mention is certainly bad, but it was addressed extremely quickly. Are there other examples?
> It was written by one developer, and first shipped in Grails only 2 months ago
A little misleading - static compilation has been in core Groovy for 9 months or so and is now supported by the core groovy team.
> And does Grails actually use any of Groovy's static compilation features?
I don't know, but it's not really relevant. I'm not advocating for Grails here, I'm advocating use of Groovy with Play. Part of the reason I want that is that I'm not extremely fond of Grails for various reasons.
You mentioned Guillaume Laforge as leading the Groovy project, but from my experience, Graeme Rocher, the Grails Project Manager, seems to have far more say over Groovy's direction.
As for calling Groovy "one of the most popular languages in use today", it figures fairly low in most popularity ratings (e.g. not in Tiobe's top 50), and only shows the occasional burst when it's been actively talked up, e.g. just before a conference when the project managers are selling conference seats.
In fact, if you read through all the reasons he recommends Scala, every one of them has been addressed in Groovy in the last few years.
Look at the key differentiator of each language when it was first created. So,
If you really need the JVM...
* Groovy for quick-to-write dynamically-typed scripts for testing Java classes
* JRuby if you need Java 7 and invoke-dynamic
* Scala if you need static compilation
* Clojure if concurrency is important
Of course, if you need specific software, choose Groovy for Grails, Scala for Lift, Clojure for Leinengen, etc.
If you don't need the JVM, consider Ruby, Python, Javascript, etc.
Maybe they moved to Scala because Scala is a superior language.
And where I work, we are users of Play specifically because it supports Scala well.
As you are probably aware, this is a highly controversial claim and there is certainly no widespread agreement on it.
It's not false, it's just silly.
Isn't that just repeating the “all languages are equal”-myth?
The analogy is perfectly fine imho.
No, it's debunking the myth that you can compare any two languages and say which one is objectively superior.
There is no such total ordering.
There are certainly languages which are comparatively close, so that it is hard to tell, and where different weightings can lead to different results. That doesn't mean it is like this for every comparison.
For instance, the comparison between Java and Scala certainly doesn't belong to this group, just like comparing PHP with many other languages also leads to a clear outcome.
But honestly, I don't care. There are also people claiming that there is no "objective superiority" in cases like "evolution vs. intelligent design", "6000yo universe vs. billions of years", "software patents vs. no software patents", "no contraception/abortion vs. women's rights".
Right reaction is to laugh and move on.
It's always about context: if an A/B test show you that changing a button's color from red to blue increases conversion rates by 50%, than red really is superior to blue for this context. Same, if your developers are 50% more productive in Scala than in Java that Scala is a better language for you, same way that red really is superior to blue in the above.
And I really like the dream of a "language agnostic-framework", though I know it's not really possible. It would be cool to have a Play framework which also supports Clojure or JPython or JRuby, as for some developer teams these languages might be superior to Java or Scala - but I know that the development effort would be huge*. But in the real world, 90% of good programmers will take Scala over Java anytime, even if they'll have to learn it! Heck, I'd take C# on mono over Java any day!
Personally I think the syntax in scala is even uglier than Java's, if such a feat were possible, and looking at scala code makes me want to stab my eyes out with forks. Thankfully I don't think I'll have to touch the JVM any time soon.
You realize that none of your points are actually related to the language itself?
Yes, Scala's syntax is ugly, just look at this cryptic operator soup: int[][]_00_[][]=null;
What on earth is that? I've never seen anything like that in Scala code?
But in both cases, sensible people can disagree on whether or not the additional power justifies the additional complexity and those insane compile times.
And just to be a little more specific in what I mean by complexity: What I mean is, how much do you know about what a particular piece of code does when looking at it in isolation? How much additional context do you need to figure out what it does? How many possibilities are there?
Powerful syntactical abstractions are a double edged sword.
I wouldn't say that. I think the main difference is that Scala spent its language design budget on more useful things compared to Java. Have a look at C# if you want to see a language with tons of features.
> What I mean is, how much do you know about what a particular piece of code does when looking at it in isolation? How much additional context do you need to figure out what it does? How many possibilities are there?
From experience, that amount of code is considerably smaller than Java because I can be pretty sure that some piece of Scala code usually won't mutate stuff all over the place.
Scala's syntax is flexible enough to let you build DSLs. It makes use of operator overloading, optional braces after method calls, infix methods, etc. All features that Java doesn't have.
Being able to build DSLs is a good thing, but the whole point of DSLs is to hide some of the semantics of the underlying language and let you think in terms of the domain the DSL was built for. So there is clearly a power/complexity/understandability trade-off.
Another way to say this is that Java is a lower-level language than many newer languages, consequently it's much more wordy. And it is certainly wordy, to the degree that it's difficult to follow one's own code. And I see you make a similar point.
But you can write straighforward Java, and on average reading someone elses Java code is easier than reading typical C++ code for instance. I don't have experience with reading other people's Scala code but it seems similar to C++.
BigInteger four = new BigInteger("4"); BigInteger sum = four.add(new BigInteger("2")); // assuming you won't need 2 again so why store a in var
I never wished for the ability to do operator overloading anymore than I do when I have to use BigInteger in java. It just makes math look so unnatural and hard to read. You end up with variables all over the place to do Math on numbers or have to create a bunch of them in the method arguments. Just an utter mess when compared to the similar class in C# that does it with operator overloading.
What Scala has done however is to pick particularly powerful features that are allowed to intersect as much as possible giving a lot of flexibility. At the same time it has introduced and encouraged functional programming concepts which are new to many OO programmers with Java backgrounds. This can make it seem a little daunting but I found it no more difficult to learn than any other language and easier than some.
The compile times are simply because the compiler is doing a lot more. It's always going to be slower than the Java compiler, though there are still optimisations that can happen. That's a trade off, the additional expressivity and safety of the type system is either worth it to you or not. In the case of Play, you're getting compile time checked routes and templates for example.
In terms of reasoning, it is much easier to reason about idiomatic Scala code in isolation than it is Java. This is because you have much richer type information and can apply the substitution model without being worried about mutation and side affects. It is true however that the flexibility you are given can be misused and you aren't forced to stick to a functional style, so when someone goes off the reservation that can result in hard to comprehend code. Most of the FOSS projects I've seen in Scala avoid this but YMMV.
a = b
The fact that operators are methods and can be overridden simplifies things - you no longer need to know and remember operators. They are always methods on the type you are looking at. This is what I mean by more regular and fewer surprises, the footprint is smaller.
So you can use this simpler, more powerful feature to create DSLs. They are compile checked and are "real Scala". The tools autoamtically help you. Of course, DSLs exist in Java but they often involve tools like JTB and JavaCC, extra compilation steps, no compiler assistance for users - I could go on. Which is more complex?
Anyway, I agree you could abuse the more powerful language features to write hard to comprehend code. However if you take a look at Scala code in the wild, you will see that these concerns so far have been largely theoretical and of course you can also write incomprehensible junk in Java or any other language should you wish.
I'd encourage people to try the Coursera Scala course which is running again soon, and see for yourself.
And I don't agree that it's a theoretical problem that only arises with bad code. It's simply a downside that we have to be aware of when we use DSLs, even well designed ones. For some purposes bland code is just better than smart code.
But I do agree that a Scala based DSL is hugely superior compared to any byte code manipulation based Java framework that obscures lanaguage semantics beyond recognition. It's also way easier to reason about Scala code than about Python/Ruby style meta programming.
scala> def ==(a: Any) = false
<console>:7: error: overriding method == in class Any of type (x$1: Any)Boolean;
method == cannot override final member
def ==(a: Any) = false
^
I hope you do realise that my point isn't even specifically about Scala, but about syntactical abstraction in general.
Yes, that's what all the Typesafe employees repeat ad nauseam at conferences and on mailing-lists. Anyone who has spent more than a year coding in that language knows how ridiculous that claim is.
I'll just pick one example: _ has six different meanings depending on where you use it.
It's fine to like a language (I love quite a few myself) but don't drink the kool aid and try to remain objective about the strengths and weaknesses of your tools.
FYI: I don't work at Typesafe, and I share his experience.
One great thing about Scala is that one can immediately tell whether someone has actually used it by looking at the complaints.
Things like "OMG _!!!", "Null, Nothing, None ... sooooo confusing", "Perl", "C++" give it away immediately. I wonder why people are not more upfront and honest about not having spent more than 5 minutes with Scala. It's totally OK, no one can learn everything.
Having used Scala for several years now the claim is a long way from ridiculous.
I find the idea that an opinion contrary to yours means someone is drinking kool aid and failing at objectivity a little ironic.
https://github.com/robfig/revel
It didn't feel like idiomatic Go to me, but was a very nice, featureful, and complete framework.
One thing that comes to mind is ACID compliance. Any other pluses of using sql over an ORM would be appreciated. I have a friend who swears by it, who taught another friend that is now swearing by it.
When you use "sbt ~run", sbt compiles each file as soon as it changes. I.e., as soon as you save out the editor buffer. By the time you click on the reload button, sbt has usually already compiled all your changes, and it only takes a second or two for either your working page to reload, or for you to see a compiler error message.