- Paperback: 852 pages
- Publisher: Artima Inc; 2 edition (January 4, 2011)
- Language: English
- ISBN-10: 0981531644
- ISBN-13: 978-0981531649
- Product Dimensions: 7.2 x 1.2 x 9.2 inches
- Shipping Weight: 2.6 pounds
- Average Customer Review: 122 customer reviews
- Amazon Best Sellers Rank: #533,921 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.
Programming in Scala: A Comprehensive Step-by-Step Guide, 2nd Edition 2nd Edition
Use the Amazon App to scan ISBNs and compare prices.
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?
From the Inside Flap
Programming in Scala, Second Edition, is the definitive book on Scala, the new language for the Java Platform that blends object-oriented and functional programming concepts into a unique and powerful tool for developers.Coauthored by the designer of the Scala language, this authoritative book will teach you, one step at a time, the Scala language and the ideas behind it.The book is carefully crafted to help you learn. The first few chapters will give you enough of the basics that you can already start using Scala for simple tasks. The entire book is organized so that each new concept builds on concepts that came before - a series of steps that promises to help you master the Scala language and the important ideas about programming that Scala embodies.A comprehensive tutorial and reference for Scala, this book covers the entire language and important libraries.This second edition provides more than 100 pages of new material that covers new features in Scala 2.8, including: - The design of the new collections library - Structural subtyping - The new rules for implicits - Package objects - Chained package clauses - Named and default parameters - The copy method on case classes
About the Author
Martin Odersky is the creator of the Scala language. He is a professor at EPFL in Lausanne, Switzerland, where since 2001 he has led the team that developed the Scala language, libraries, and compiler. He is a founder of Scala Solutions, Inc., and was a co-designer of Java generics and the original author of the current javac reference compiler. Lex Spoon worked on Scala for two years at EPFL and is now a software engineer at LogicBlox, Inc. Bill Venners is president of Artima, Inc., and cofounder of Escalate Software. He is the author of many articles on Java as well as the book Inside the Java Virtual Machine, and the designer of the ScalaTest testing framework.
Top customer reviews
There was a problem filtering reviews right now. Please try again later.
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".