Firstly, sorry it has been so long since last blog post. Life is busy when you have two children. I decided to try and learn Scala in 2013 and I am currently still pluggin' away. This blog post is a review of David Pollack's Beginning Scala.
David Pollack has been writing software since 1977. He wrote diagnostic software for the Commodore 64, the first real-time spreadsheet and founded the Lift Web Framework in 2007. He describes his experience with Scala as an epiphany that changed the way he approach software; he certainly writes with enthusiasm and passion and in this book we even get a forward from the Godfather himself
'Beginning Scala' focusses very much on the core fundamentals of Scala. The book in length is just under 300 pages. This is quite short in comparison to say Martin Odersky's excellent 'Programming in Scala' which is well over twice the length. Where I see the
for Beginning Scala is for someone who wants to dip their toe into the water and is curious about the language feels and wants to get a good overview of the language quickly. For more a detailed and substantial take on the language something like Odersky's book is necessary.
Areas covered include:
- Scala traits and Scala's type system
- Scala collections and their immutable nature
- Functional characteristics (passing functions, returning functions)
- Pattern matching
- Actors and concurrency
There are also some tips on how to introduce Scala to your team and some best practise advice. My favourite parts were the explanation of Scala traits and the demonstration of the classic GoF
made so simple using pattern matching (
I'll cover this in a separate post
). The one criticism I'd have is that I think what really sets Scala apart from Java is not that has lots of syntactic sugar but that it offers a functional programming approach. This doesn't just mean you can pass functions to function, return them functions and so on but that you have to approach problems in a very different way. In functional programming
is favoured over
. There are many problems that developers could solve using iteration with one arm tied behind their back but to solve them using recursion is trickier. One of Scala's features is that it facilitates both approaches but I think if you are going to embrace the functional paradigm properly you need to ditch iteration and embrace recursion. This isn't really covered in the book - in fairness it is not really covered in detail Odersky's book either. However, if you look at the
on coursera it is a massive massive massive massive massive massive massive massive part of it.
So overall, a very good book and well worth a dabble for someone that wants a dabble in Scala but if you want more you'll need more.