I’ve been writing Scala code for about 9 months now daily. I just recently completed (as much as one can complete software) a small project at work that took much longer than expected due to things that didn’t seem like they should take very long taking an eternity to figure out (Marshaling and UnMarshaling data is a huge pain in the ass using spray-json. I highly recommend fasterxml if you don’t want to waste shitloads of time battling the library itself. It works like the Play libraries, which is nice.)
Once I get things working, they work reasonably well, although I feel like what I have built is fragile. Things that should be easy are a huge pain in the ass. It’s been running for 30 days with no problems, which is nice, but that’s mostly because Akka is solid. I just don’t feel like I have my head around this language. I was a dumbass and decided that using a web framework for what I was doing was overkill, so I tried to build it with Akka, Spray, and Slick. It was a waste of time, other than for learning Akka/Spray/Slick. I should have stuck with Play and used traits to make testing my code easier. The previously mentioned huge pain in the ass (which I never did get working) would have never occurred, it just works in Play. My primary complaint about Play was it was hard to test, but that was actually my problem not really understanding how useful traits are when it comes to testing. Anyway, you live and learn.
It’s an interesting place to be. Nine months seems like it should be enough time to grok a language; however, I still feel like I’m scratching the surface. I’m not expecting to be an epic badass at it, but it’s harder than it should be. I have the same feeling with Scala that I have with C++. If I can’t get the bulk of the language into my head, I have much less confidence in what I am writing. I think that makes me a weaker developer in some ways, but at the same time, the point of abstraction is to not have to worry as much about what’s going on within the abstraction. Scala is so complex with its generics implementation and type system and every other thing it tries to throw in, that it just gets out of hand in a hurry. It is an amazingly powerful language, and overwhelming because of it. It feels like it has created a whole new set of very complicated problems for me to solve to do what should be less complicated.
Scala offers all kinds of badass ways to get concurrency and parallelism and a neat type system, but at the cost of being a really really complex language with a seemingly insurmountable amount of concepts and associated buzzwords. I blame the JVM and the JVM community at large. They love abstractions of abstractions with abstractions in them, wrapped in Lists of Generics, which are type erased so you can’t tell what is inside of them at runtime without writing a bunch Manifest or TypeTag bullshit, each with a different name depending on the order that the abstraction occurs. It’s maddening. The JVM is amazing, and also drives me nuts. I’m starting to feel like the “solution” causes more problems than it solves. I think I’ll always be a JVM outsider. It just always feels a little wrong to me, even when it’s working (and gobbling up memory).
To put it in perspective, I rewrote my Scala app in Python in about 4 days using Falcon. My Python version handles the load it needs to and actually uses less memory. It won’t scale at even a fraction of the scale of the Scala version in its current version, but it doesn’t need to. If that became a requirement, I’ll bet I could write it to scale in less time than it took me to write it in Scala. Admittedly, I have been writing Python code for much longer, and since I already had the design worked out, reimplementing it is always easier than the original implementation. I also used a framework, so it’s not as fair of a comparison as if I had used Play. It isn’t 86 days easier though. I’ve been looking at Go and it tries to solve the concurrency/speed/memory/complexity problems in a kind-of backwards way that is interesting to me. It doesn’t have classes or generics, and I kind of love that idea. They tried to intentionally keep it simple, which is the philosophical opposite of Scala. It’s a get-shit-done language instead of an academic language. I’ll give it a try at some point.
I’m not giving up on Scala. The challenge is fun; however, I don’t think it will ever be a dominant language. I don’t think it will every be possible to scale a Scala development team in most cities. There just won’t be enough people that are actually good at it that don’t cost a fortune. What do I know though? I could be wrong, but it just doesn’t feel right to me. Maybe it’s better if you love the JVM, I really don’t know. It’s a very complex language though, and I’m not settling on it as the best way to tackle concurrency/parallelism problems.