Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Programming in Scala: A Comprehensive Step-by-Step Guide, 2nd Edition Paperback – January 4, 2011
The Amazon Book Review
Author interviews, book reviews, editors picks, and more. Read it now
Customers who bought this item also bought
What other items do customers buy after viewing this item?
Scala is an object-oriented programming language for the Java Virtual Machine. In addition to being object-oriented, Scala is also a functional language, and combines the best approaches to OO and functional programming.
In Italian, Scala means a stairway, or steps indeed, Scala lets you step up to a programming environment that incorporates some of the best recent thinking in programming language design while also letting you use all your existing Java code.
Artima is very pleased to publish a new edition of the best-selling book on Scala, written by the designer of the language, Martin Odersky. Co-authored by Lex Spoon and Bill Venners, this book takes a step-by-step tutorial approach to teaching you Scala. Starting with the fundamental elements of the language, Programming in Scala introduces functional programming from the practitioner's perspective, and describes advanced language features that can make you a better, more productive developer.
Top customer reviews
Things I love about the book:
(1) the Kindle for iPad edition was very well formatted (has a hyperlinked table of contents, hyperlinks throughout the book, chapters start on a new page, well formatted and easy to read code examples)
Things I like about the book:
(1) thorough (the book covers a lot of material)
(2) clearly written with no obvious typos/errors
(3) liked the way each chapter was organized. An Introduction followed by a more thorough discussion of the topic at hand followed by a summary of what was covered
(4) This book will work well as a reference after reading it as it is organized well enough that you can jump straight to a particular topic
Things I dislike about the book:
(1) choice of chapter order was not apparent to me. The book feels more like a lot of very well written tutorials, each covering a well defined topic, instead of a single unified tutorial (which is what I was expecting) with the goal of taking the reader from novice to a more advanced level.
(2) code examples are more complicated than they need to be
(3) the Kindle ebook does not have page numbers
I am of the opinion that this book will not get you up and running quickly. You have to read quite a bit before you get to a point where you can write useful code (I would suggest reading at least up to and including chapter 17 -- My Kindle tells me this is 38% of the book -- when you consider that the paperback version has 852 pages, 38% translates to around 320 pages of book material). Also, I believe that Scala is different enough from other languages I have used or studied that I think that (at least parts of) the book would have required a second reading or I would have to have followed up this book with a different book (I did something similar -- see More on getting up to speed quickly below) before I could be effective with the language.
More on getting up to speed quickly:
Before writing this review I also started taking the Coursera course [...] on Functional Programming using Scala taught by one the authors (Odersky). The course material is available even though the class has ended. There are only 7 days of college course style lectures with each day's lecture lasting between 1 and 2 hours. If you want to get up to speed quickly, I highly recommend that course. I was up and running after the first day's lecture. The course is a good way to follow up on the material in the book.
I gave this book five stars because this book is superior to other programming books I have read in terms how it is written (format), the material it contains (quantity and quality), how clearly that material is presented (readability), and how long I think the material will remain useful for (durability). I do not rank a lot of my books with 5 stars. I believe that I got a very good bang for the buck.
It's in the middle of the road, and that's why it's not fantastic. It's also teaching somewhat 'intuitively'. That is, they often avoid stating the rules explicitly saying stuff like 'it's not needed for this section', so you end up seeing unfamiliar syntax without really learning the rules. Things like the => and the <- are somewhat unique to Scala (though they do map to constructs in other languages). But they never really give you the rules around them explicitly, they just show a few examples of different ways you can use things. As a result, you can't learn Scala deeply.
The wildcards in Scala are also not presented in depth, and instead you encounter their rules piecemeal: chapter by chapter, use case by use case. Maybe they'd be too much for one place, but I can handle references to parsing rules and it would be nice to have this presented early on.
They also discuss lots of the similarities to Java. I'm honestly not sure if this would really be that accessible to someone without experience in Java. I do know Java, so the parallels and contrasts are valuable, but then they're also discussing the basics of inheritance and information hiding -- one of these sections must be a waste of time for most readers: either you're an amateur (excuse the term, not meant to be condescending) and the section about Java is a waste of time, or you're experienced and the fundamentals of inheritance are a waste of time (yes, some readers might be experienced without Java knowledge, please take this as an example of a symptom).
It's tough to be all things to all people. The result is a rather dry topic by topic introduction to Scala that doesn't help a reader gain much depth. That said, I think this will be an early reference to get going. Things it is lacking that could have made it move faster:
- more significant examples. I'm coding as I go along, but I don't feel like I will be code in Scala when I finish this book. Contrast with Practical Common Lisp
- choosing an audience. 1/3 of this book is not adding any value for me. I expect this is true for every reader depending on their backgrounds.
- depth -- really need some rules around. Statements alluding to more details that you don't need to know now are unhelpful
That said, I did give this 3 stars, as it's not a terrible introduction to the language. It is a good (and appears to be comprehensive) survey of what the language has to offer.
The reason I don't give it 5 stars is because I would like to see here detailed content about the Scala's type system and advanced features. However this is also an introductory book and is big enough already so maybe that subject should go into a different book, but after reading it I still feel that some questions go unanswered about the type system.
It was a great read tho and I was able to review and create Scala code after reading it, thus I would say it fulfils it's purpose. I didn't try other (shorter) books about Scala because I like to know the details of things, so I can't compare this to say "Scala for the impatient".