- Paperback: 384 pages
- Publisher: Addison-Wesley Professional; 1 edition (March 16, 2012)
- Language: English
- ISBN-10: 0321774094
- ISBN-13: 978-0321774095
- Product Dimensions: 7 x 0.9 x 9.1 inches
- Shipping Weight: 1.1 pounds (View shipping rates and policies)
- Average Customer Review: 79 customer reviews
- Amazon Best Sellers Rank: #564,100 in Books (See Top 100 in Books)
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.
Scala for the Impatient 1st Edition
Use the Amazon App to scan ISBNs and compare prices.
All Books, All the Time
Read author interviews, book reviews, editors picks, and more at the Amazon Book Review. Read it now
Frequently bought together
Customers who bought this item also bought
About the Author
Cay S. Horstmann is principal author of Core Java™, Volumes I and II, Eighth Edition (Prentice Hall, 2008), as well as a dozen other books for professional programmers and computer science students. He is a professor of computer science at San Jose State University and a Java Champion.
Top customer reviews
Scala is a difficult language construct. Most Java developers I have spoken to feel that it is counter-intuitive (to Java). With this in mind, this book does an amazing job of landing the Java developer into Scala. The first 15 chapters are phenomenally well written. It shows that it was written by a person used to teaching, instead of disbursing information. The latter is the problem with the other well written, but dense, O'Reilly book 'Programming Scala'. The chapters progress methodically, with a minumum of back and forth references to chapters, which seems to be a challenge in writing Scala - concepts are so inter-mingled, that such references seem to be inevitable. You just have to learn to ignore the little 'Notes' and references. In fact, the reading was so pleasurable, I finished 15 chapters cover to cover within 2 weeks.
But then, the book takes a nose-dive. The chapters start getting dense. This is where the author should have stuck to the earlier approach of teaching. But the chapters start reading like references, with a lot of information stuffed in, almost as if the author was getting impatient to reach the end himself. When I reached 'Actors', I just had to put the book down. Googling, I found some excellent articles (danielwestheide's blogs, Alvin Alexander's snippets from his excellent 'Scala Cookbook' that I strongly recommend after getting Scala basics) that explained the Actor model so simply and so methodically.
To summarize, this is a decent book to start off with on Scala. Don't despair if the latter part seems rushed, move on to the Scala Cookbook or online blogs.
This is a great book for anybody who wants to get his feet wet in Scala and yet the time is just for 384 pages. Plenty of examples after every chapter makes absorbing the wisdom of Scala from the book an almost never-ending endeavour. Don't skip them so you can fully appreciate the author's efforts to teach you Scala.
I consider myself a novice to the Scala language with a quite extensive, decade-long experience in Java and a bit of functional programming in Clojure and F#. Without much practice in Scala I needed a book that would guide me as if I'd attended a Scala course. I think Scala for the Impatient did the job very well. It was written in a lively style and the level of details greatly went beyond my expectations. I'm now using the book as a reference to turn me into a Scala professional and the often I read the chapters the more details I find (I guess it may well apply to any IT book, but only now could I experience the feeling).
The book provides many (if not all) of the most interesting parts of Scala for all of the levels of Scala experience. The book uses the experience levels that were identified by Odersky to distinguish the features of Scala that would be of interest to application programmers and library designers. I didn't pay attention to the levels, though and read the book from cover to cover.
Right from Chapter 1 the author encourages to write smaller programs as a way to learn Scala. If the steps to install Scala were to serve as an indicator of how the book is written, it took the author 4 single-line bullet points and the Scala interpreter was available. That was surprisingly concise. Should you need more, you're asked to visit the book's website. The author simply decided to waste no page for a less interesting material.
Every chapter begins with an introduction to highlight the main points. This may very well be used for less experienced people who only need a gentle introduction to more advanced features of Scala. Think of the introductions as an overview of Scala and the chapters as an more in-depth material. With the experience levels it may save you a great deal of (reading) time yet keep you abreast of the features of Scala you don't need to know now, but may need later.
The author quite often compares Scala to Java and C++ (sometimes C#) and although he said in Preface "I assume you know Java, C#, or C++" some experience with the languages might help, but is certainly not required. It just let the author skip "explaining variables, loops, or classes" (page xix). Full coverage of Scala is not the goal of the book and so is convincing you to use functional paradigm over object-oriented one (or vice versa). The author simply demonstrate Scala with notes about his experience and let you pick what suits you the most.
Regarding the title - "Scala for the Impatient" - don't get fooled by the "Impatient" part. It's not that the book skims over Scala hoping that you learn it without knowing few more details or similar. Quite the contrary, but the pace is well-thought-out and steady so you may not notice you're reading stuff you would consider out of your scope. Cay Horstmann gave them so many that I think I may have understood the reason behind the "Impatient" part - I often became impatient to apply the knowledge to projects, but couldn't simply stop reading as I was worried I'd miss parts that would help me sorting out problems even better (!)
And the last but not least, the book was issued on March 06, 2012, but given the recent changes in Scala I don't think it has lost its value (despite not being up to the recent version of Scala and missed a few latest changes). The version of Scala used in this book is 2.9 as the pre-2.10 String concatenation and a note about enabling continuations in 2.9 might imply. It didn't make the book any less valuable.
Most recent customer reviews
1. To see the code samples you have to click on a link which displays an image. Why aren't they embedded?