Scala: Our Retrospective of the benefits/drawbacks
As the closing part of a Scala Experience Report Liz and I gave at XP Day we detailed a retrospective that we’d carried out on the project after 3 months where the team outlined the positives/negatives of working with Scala.
The team members who were there right at the beginning of the project 3 months earlier had come up with what they thought the proposed benefits/drawbacks would be so it was quite interesting to look at our thoughts at both times.
Some of this is available in our slides from the talk but Nat Pryce suggested it’d be interesting to post it up in more detail.
We weren’t aware that we’d be doing this exercise until the session where we did it and noone looked at the original answers so hopefully some of the potential biases have been removed!
Quite a few of the expected benefits from June were observed in June, such as having to write less code, functional programming constructs, XML support and the ability to write DSLs.
The community was one benefit which wasn’t expected - we’ve found that every time we get stuck on something we can go on Stack Overflow and find the answer and if that doesn’t work then someone on IRC will be able to help us almost immediately.
Our experience with Scala’s complexity partly matches with that of Stephen Coulbourne who suggests the following:
There is also a sense that many in the Scala community struggle to understand how other developers cannot grasp Scala/Type/FP concepts which seem simple to them. This sometimes leads Scala aficionados to castigate those that don’t understand as lazy or poor quality developers.
We’ve tried to be reasonably sensible with the language and only used bits of it that the whole team are likely to understand rather than learning some obscure way of solving a problem and checking that in.
On the other hand reading the code of Scala libraries such as scalaz or SBT is something that I, at least, find extremely difficult.
Changing the SBT build files can be quite a scary experience while you try and remember what all the different symbols mean and how they integrate together.
The learning curve for Java developers has been a bit of a mixed experience.
When we started working on the project we were effectively writing Java in Scala and we’ve slowly learnt/introduced more Scala features into our code as time has passed.
I think everyone who has come on that journey has found the transition reasonably okay but we’ve had other team members who joined later on and went straight into code that they weren’t familiar with and for them it’s been more difficult.
It will be interesting to see the team’s thoughts if we do the exercise again 3 more months on.
I would imagine there would be more ‘dislikes’ around code complexity now that the code has grown even more in size.
It probably also mean the lack of IDE support becomes more annoying as people want to refactor code and can’t get the seamless experience that you get when editing Java code.