Customer Reviews

Programming Scala: Scalability = Functional Programming + Objects (Animal Guide)

5 star:		(7)
4 star:		(2)
3 star:		(5)
2 star:		(0)
1 star:		(1)

 

 

Scala is a very interesting language and tremendously powerful. It takes aspects of functional languages joins them to DSLs (domain specific languages) and adds it all on top of standard object oriented programming concepts and then runs the whole thing on the Java virtual machine. As such there's a lot of interesting things to learn and understand about the language and the fairly radical concepts its raising.

However, while the topic is clearly fascinating I feel the book is not especially well organized. Scala introduces many interesting and novel language design concepts (e.g. the functional features and their take on the actor model for concurrency). It also introduces a great number of language short cuts and syntactic sugar, allowing for DSLs or at the very least less typing and more of the feel of a scripting language. The book chooses to introduce the language short cuts first and then proceeds to use them liberally when introducing the language features. This no doubt promotes good "scala" practice but does make understanding the new concepts more difficult since we're still learning the new syntactic forms.

I think a better approach would have been to introduce the language concepts first - in long hand form (and we're usually talking just a few extra characters here, not pages of text) - and then follow up in the later chapters with the syntactic sugar and the ways to reduce typing and allow for alternative naming and syntactic forms (which helps support domain specific languages). That would have made it easier to grasp the concepts and then we could have learned how to enhance those basic skills and produce even more compact and flexible Scala programs.

One indication of this problem is the great number of forward references in the book. A concept is often introduced but it can only be partially explained (since the early focus is often more on syntax than deep semantics) and so many times the full explanation has to be deferred until later - and later is often 10 chapters later. You can do that once or twice in a book, but you shouldn't need to do it half a dozen times in each chapter - or it's a sign the overall organization is poor.

On the plus side the book is short (always a benefit when being introduced to a new language) and the chapters contain many interesting examples which are actually very helpful in explaining the authors points. The book also does a very good job of covering the breadth of the language and all that it introduces in a relatively short amount of space.

In summary I think it's a good effort but I suspect in a few month's time there will be better choices for learning Scala.

Programming Scala can range from scripts, to object-oriented, to functional, to Actor-based multi-threading, to sophisticated library writing. Scripts are pre-compiled with an implicit main, for those short knock-off tasks, with the entire Scala libraries and Java libraries at the ready.

Programming Scala, the book, welcomes readers from a variety of language backgrounds, such as Java, Python, Ruby, JavaScript. I've read other Scala books, but I nevertheless found Programming Scala to be interesting, informative and stimulating. The writing style is very clear, which is just as well, because some advanced programming techniques are tackled as the book progresses. The Scala language is so uniform and concise, with powerful features and libraries, that it is feasible to tackle advanced programming which would be unthinkable or impossible in many other languages.

The book encourages test-driven development in early chapters, which makes the example code pretty much self-explanatory.

Author Dean Wampler responded quickly to my minor change request for the downloadable sample code to self-test in Ubuntu. Authors aren't obligated to provide post-publication service to readers, but these guys do.

The Tapir (Elephant) in The Room is a fast moving hunter whose speed defies his size. Like Scala.

This book will get you up to speed QUICKLY with Scala.

I was under a time crunch to write code with complicated concurrency. With this book, I went from zero Scala experience to writing concurrent algorithms within a matter of hours. Concurrency has never been so painless. It's actually kind of ridiculous.

The book is extremely fluid and succinct. It gets to the point quickly. The organization is excellent and intuitive. While they assume you know enough about object oriented programming (and let's be honest, you probably do), they don't assume that you have a functional programming background.

The authors present a very strong case about Scala's strength as a modern multi-paradigm language, capable of addressing pertinent issues of scalability, concurrency, performance, development speed, reliability, etc. I'm definitely convinced.

If you are using or plan to use Scala, then this is a must have.

This book is frustrating.

The content is fine and understandable to an experienced programmer, but the amount of forward references to other chapters in the book is ridiculous, it seems like every other paragraph contains one, and it robs the book of any natural flow. If you follow along with the text chapter by chapter, you are either a) trusting that the authors do indeed explain concepts that they bring up but then defer elaborating on to much later or b) constantly jumping all over the book.

I think that there is a lot of good knowledge in here, but a much, much better job could have been done on organizing it such that each chapter stood relatively on it's own, each being an extension of the next. Or if you aren't going to do that, just follow the cookbook formula, where you can zoom in on some relevant examples and learn from those.

There aren't a lot of Scala books out there, so choices are limited, but I feel you would probably be better off waiting for a second edition on this one.

Complete, and gets the job done, but it definitely doesn't follow the "Spiral Approach" or "Inverted Pyramid": explain the simple things first and the details later. For example, already in page 36 we're learning about the exact rules for numeric literals (including how to write them in octal!) On page 51 we get three pages listing every reserved word in the language. Some of the middle chapters are really hard to follow, which is mostly because they're explaining tricky and unfamiliar concepts, but also they could be explained better.

The book "Programming Scala", is a dense, well written book that covers concisely many aspects of this great language.
Scala is the most advanced language with which I have involved, and as I learn it better, I admire even more the clever design decisions behind the language. Therefore, it is difficult to have an easy to read book on such a technically advanced language. The material of the book although it is dense in concepts, it is readable and the examples are very good and instructive.
I strongly recommend the book to anyone involved with Scala, and to anyone that wants to become a better programmer, since Scala is an excellent vehicle to implement robust and effective software systems (I believe that currently is the best one).

The book is very useful as a complement to the classic "Programming in Scala" book of Odersky et. al., which in my opinion is the best for learning systematically Scala from the beginning. It presents many aspects of the language with a different and complementary view and thus the reader can gain a lot of benefits and better familiar with the powerful Scala language.
In conclusion the book of Dean Wampler and Alex Payne is valuable both for the intermediate and advanced Scala programmer and for any's competent programmer's bookself.

The author is/was working for Twitter. They are one of the first large scale web companies to adopt Scala. All the code works and their code has taught me much about sophisticated and clean programming style. Type less and do more and how it can support concurrency and scalability is thoroughly discussed in this book. Scala is not an easy language because of its rich syntax and its power and cleanness. The book is especially helpful to advanced users due to this nature. However, as for a beginner like me, I still find it immensely helpful. If you are experienced programmers, this is a good book for you. As for me, I want to use Scala to build my web application, this book is a good first step for me to take this route. To go further, I need additional references to help me achieve this goal. This is my first review and an expression of my gratitude to the author.

I've read (most of)all 4 books on scala: Staircase, Pragmatic, Apress (Pollak) and this one. The Pragmatic and staircase books are relatively gentle explanations of the language, this takes more of the tone of a reference doc. Which is not to say it's written like a language spec, but its coverage is comprehensive and moves crisply over the major topics: the object model, type inference and annotations, in first 7 chapters. Functional constructs (map, fold) and actor model are in the next 2 chapters.

I think the chapters on advanced O-O and the object and type systems (6, 7, and 12) are pretty heavy going. Really not for reading through at one sitting, and the authors do an excellent job of covering the gamut without bogging down in detail. For a beginner writing their first code, Chapters 1-5 and 8 are a great orientation, then you can hit the others when issues arise.

So it's appropriate as a tutorial for experienced java devs, and motivated learners, and a reference doc for everybody (It's currently the only book covering 2.8's features, tho some of the 2.8 features may have mutated since the book's oct 09 release). If somebody handed me a scala, or mixed scala/java repo and said "Test/debug/extend this!", I would say "Buy me the Oreilly book".

The unresolved question in my mind is how many people using scala for lift apps will need to understand the language's full capabilities, and will other people be using scala for sysadmin or data mining type tasks (where shorter "scripts" are often pipelined). Certainly, there will be big apps written by multi-dev teams in scala, adoption by java shops is inevitable (IMHO, given better IDE plugins and a stable 2.8 release, among other things). Those folks need this book. For somebody using lift's off the shelf capabilities, you may not want to get into the nuts and bolts of the object system and type system.

Full disclosure: I was the technical editor for Dave Pollak's "Beginning Scala," which of course I also recommend, and Dean and Alex very graciously included my name in their preface. With that said...

"Programming Scala" is simply spectacular work. As I tweeted, it's dense and chewy, like a well-crafted caramel. Dean and Alex bring the full weight of their experience with multiple platforms and languages to bear on Scala, showing us its various strengths (and a few weaknesses!), applying it to tasks that modern programmers are virtually certain to care about, and do so with the sense of fun that I've come so strongly to associate with Dave, Dean, Alex, and really the whole Scala community. That they manage to do this in such a slender volume without feeling rushed, cryptic, or incomplete is a testament to the tightness of their writing and the quality of O'Reilly's editing. "Programming Scala" is an indispensable member of the Scala canon, and deserves a prominent place on your bookshelf.

The first few chapters are breathtakingly fast. Some of the middle chapters are kind of slow, but are still worthwhile. Scala is a fairly large language (unlike, say, Scheme or C), and the book is a fairly dense 400 pages. I found it helpful to read slowly and take notes.

As for Scala itself, I really like it! Scala is a nice mix of Java, C#, Erlang, Haskell, Ruby, and Smalltalk. You can treat it as a "better Java", or you can treat it as a more enterprise-friendly Haskell. Either way, it's exactly what I was looking for: a language with reasonable syntax, an ML type system, and a decent set of real world libraries. I know that the Haskell community is working hard in this direction as well. I think Scala stands a very good chance at being a work-friendly, programmer-friendly language.

I'm a little afraid that its type system may be too large and too complex for a lot of programmers. To be fair, I think that C++ is too large and complex for most programmers too. I'm also afraid of subsetting--i.e. the situation where every team picks a different subset of the language to use. This is very common in multiparadigmatic languages like C++. On the other hand, some multiparadigmatic languages like Python seem to avoid this problem.

Nonetheless, there's a lot to learn in Scala--covariance, contravariance, parameterized types, abstract types, self-type declarations, lazy values, by-name parameters, DSL-friendly abbreviations, path dependent types, oh my! And there's more! I ended up with 50 pages worth of notes.

I'm pretty sold on Scala. Now, all I need is a startup to hire me to write it ;)