Customer Reviews

Programming in Scala: A Comprehensive Step-by-step Guide

5 star:		(29)
4 star:		(5)
3 star:		(3)
2 star:		(1)
1 star:		(1)

 

 

Scala is a relatively new language that combines object-oriented programming with functional programming. Usually, when a new language gets some press coverage, some hastily written books are published, that merely give the user some impression of a language, rather than a good basis to build on.

This book is completely different: right from the start you will notice that it is carefully written and comprehensive. Sections naturally flow from one to another, and every concept is introduced good examples and rationale for why Scala uses a concept in a particular way. For example: Scala Ints are compiled as primitive types where possible, but they can also be treated as class instances (e.g. by invoking instance methods). The book not only explains that this is the case, but also how it works, and how it differs from auto-boxing in Java. Such in-depth coverage is provided for all major Scala language constructs.

Besides the covering language concepts, there are also some chapters discussing library functionality, such as containers, actors, building parsers, XML, and Swing programming. The book concludes with a hands-on chapter, where a simple spreadsheet application is implemented.

I wouldn't recommend this book to newcomers to programming, but anyone interested in functional programming or a user of the Java programming language should at least give it a serious consideration. It's a very interesting read that may widen your horizons and show that a good blend of object-oriented and functional programming does indeed exist. Additionally, it is poised to become the standard work for learning Scala.

It's difficult not to let one's enthusiasm for the Scala programming language color one's affection for this book. Nevertheless, _Programming in Scala_ is a rich book with reward after reward for the interested reader. Much can be found on the web about Scala, but this book is still indispensable for the Scala enthusiast for a number of reasons.

First, the prose is clear and gentle, finding the right medium between terseness and belaboring hard points. The authors reveal motivations for many aspects of the language, so that one cultivates a feel for Scala as one progresses through the text. The reader's surprise decreases the farther one gets, as a sense of taste is acquired.

Second, the ordering of the topics is well thought out. This makes the book cohesive, and it's more useful than trying to build one's own curriculum from web materials. For example, pattern matching is explained before XML parsing. This allows the reader to grok the rich support for XML found in Scala. As another example, the "for" expression is covered after exposure to higher order methods. This illustrates their equivalence, and enhances one's understanding of both. As a third example, functional objects are introduced before exploring stateful objects. This gives those readers more familiar with imperative programming early exposure to functional concepts, and sets the stage for appreciating the real power of Scala.

Third, Scala's features are explored with meaningful examples, or mini case studies. Functional class design is introduced with a Rational number class. OO class design is explored with a two dimensional layout library. A circuit simulation API demonstrates writing DSLs. Abstract types are illustrated with a Currency example. Pattern matching is demonstrated by a simple arithmetic expression parser. The richness of "for" expressions is driven home with a solution to the famous eight queens problem. These and other examples flow naturally without appearing contrived, and they make learning Scala a pleasure.

Finally, this book's coverage of the Scala type system, including parameterized types, covariance, implicits, and view bounds, is worth its weight in gold. There's much ado in the programming community about static vs. dynamic type systems. This debate is rather like arguing about whether hammers or screwdrivers are the better tools -- the answer of course depends on context. _Programming in Scala_ arms the reader with enough insight into Scala's design to approach this debate intelligently.

I've only had the book a short while, but the binding appears to be durable. The quality of the print and paper is good. The glossary and index weigh in at a respectable 42 pages.

The text is remarkably free of errors. This eliminates distractions and lets the reader get to the good stuff. I found just one missing punctuation symbol in 700 pages of prose, and no problems at all with the code samples. This sets the bar high for other technical books, where the error checking typically is not nearly so careful.

The books and articles cited within _Programming in Scala_ read like a Who's Who of required reading for the professional programmer, and this speaks both to the thoughtfulness of the designers of the language and to the relevance of this book. For examples, Abelson & Sussman's _SICP_, Evans' _Domain Driven Design_, Fowler on Inversion of Control, Bloch, Goetz, and the list goes on. If these authors' writings are interesting to you, you will love this book.

Challenging concepts (like contravariance) and abusable language features (like implicits) can scare off would-be Scala programmers. This book explores such concepts and features sensitively, and affords the patient reader with deep insights into why the language designers really "got it right." Upon digesting this book, programmers will be able to write beautifully expressive code using these concepts and features. Moreover, the diligent may even contribute meaningfully to the blogosphere's dynamic vs. static discussions. Polyglot programming is the future, but Scala's domain of applicability is especially vast. So, both hobbyists and career programmers would neglect to learn Scala at their peril.

This book is a "must have" for any Scala enthusiast.

The Scala language first crossed my consciousness over a year ago, at a stage where I was just starting to get into functional languages. But even with the various quick tour documents on the language web site, it was clear there were a lot more subtleties to this one that were not being explained.

With the stairway book, that gap has been bridged.

The book is aimed at the experienced programmer in 'C' derived imperative languages, with at least some familiarity with the Java(tm) language, and ideally some notion about functional programming techniques -- it is not by any stretch of the imagination a "my first programming book". For the intended audience, it is an extremely effective step-by-step guide to the features, and the syntax, of the language (this is a great contrast with e.g. Foundations of F# (Expert's Voice in .Net), a book aimed at a similar subject and audience, but which expends very little effort towards separating the accidents of the particular example from the generic syntax). While I am by no means yet fluent in the language, I feel that when I'm using it for hobby coding that I'm not just groping in the dark, but instead have a solid guide and reference to lead me.

Don't get me wrong, this is a good book but not a whole lot different than the first edition. I was disappointed that the GUI Programming chapter is still using SimpleGUIApplication, which is a deprecated class. I was also hoping for more information on functional programming. A chapter on the best techniques for making reusable components would also be a good addition. Martin Odersky wrote a "Scalable Component Abstractions" back in 2005, in which he described what is now called the Cake Pattern, which improves on component reuse, but he makes no mention of this technique in this book. So, yes, this is a good book to learn scala, but my recommendation is that if you already have version 1, it's probably not worth your money to get version 2.

I have found the presentation in the book to be awesome for my 15 years experience with Java. Each "new" concept is introduced at just the right level of the abstraction (this is the syntax), concreteness (here's an example usage - i.e. an aspect of the semantics) and then a pleasant mildly judgmental comparison to how the same is currently accomplished in Java (1.5 or higher). I also like how principled and consistent the authors remain as they present code and design patterns. It reminded me of my experience reading Bertrand Meyer's "Object Oriented Software Design" back in 1997. There is a very deep consistency and pleasantness to every aspect of Scala. It clearly has learned immense amounts from C/C++, Java, Eiffel, Modula 2, Lisp, Erlang, Hackell, etc.

Thanks to Oracle's recent acquisition of Sun (2010), I started looking for my "what's next after Java" as I have little confidence Oracle will be as good to the future of Java as Sun had been. I like that Scala integrates so naturally with Java code. I like how there is activity to integrate it with C#/.NET. Scala really does feel like the "next thing after Java" just as Java was the "next thing" after C/C++ 15 years ago. It's core is now sufficiently stable, I can see Scala eventually compiling to targets outside of the JVM.

"Programming in Scala - 2nd Edition" has held me mesmerized throughout. I haven't been able to put it down. I have the ebook version (too) loaded in my phone and I read it every spare moment I get. I am being quite literal in that I cannot put it down. And I cannot wait to dive in and play with the language, while never being very far from all the Java libraries I have learned to depend upon over the years. The book and the language seem to be a perfect balance of encouraging a movement towards Scala like thinking while completely supporting total integration with Java 1.5 (or later) code today. I have not felt this inspired for a new language since my adoption of Java in late 1997.

Summary: Excellent at selling and teaching Scala to a long-time Java code-head

If you want to learn Scala, read this book! It was written by the creators of Scala, so it's bound to become a classic. Unless you have a good background in both functional and object-oriented programming, you can't pick up Scala from a few examples and tutorials. I tried. This was the first Scala book published and the first one I read. I am now reading it a second time. As far as I can remember, it's the only computer book I've read twice. The book begins with a gentle introduction to the conceptual foundation and capabilities of Scala. It covers every aspect of the language in its own chapter. Towards the end of the book, it introduces special topics, such as parallel programming, XML processing, parsers, etc. and you will be amazed how easy this is with Scala. As others have already mentioned, the book is well written. Although some of the concepts are difficult, the writing style is always concise and clear. Everything is illustrated by crystal clear code examples, none of which are gratuitous, verbose, or Mickey Mouse style. The thing I liked most about "Programming In Scala" is its practical approach. You get to type code into the Scala interpreter right from chapter 1. The book invites you to try out the code examples, modify them, try this or that, while providing all the theory you need to know (but not more). It's exactly what it says: a comprehensive step-by-step guide.

This is currently more or less the standard book if you want to learn Scala, and for good reason.

The book is extraordinarily well written - complicated subjects are explained very clearly, in a way that shows that the authors are experienced educators. For example chapter 19 (about type parameterization), which is one of the more complicated subjects, starts with a simple example, which is refactored step by step, adding new concepts at every step. The subject is still complicated, but the way it is presented is extremely well thought out.

I wish more technical books were written so clearly.

This book has to be one of the best books I have read over on software development. I should mention that I been shipping products with Java/C++ since the mid nineties, using Ruby for at least 10 years, and use Erlang extensively on my own projects at home, there was so much additional content in this book that it made my head spin.

As was previously mentioned, the language itself is absolutely beautiful and it's hard to draw the line as to what I am more excited about, the language or the book but I can tell you that the content delivery is furious, very clear, legible, well organized, and a true joy to experience. A caveat is that this book is probably not for the beginner as it draws upon your familiarity with other languages and mainly concentrates on the differences.

There are so many goodies within the Scala language itself, things that they did for the sake of consistency that you would probably never think of, that I was constantly just saying "wow" as I was reading it.. (like array notation.. so minor.. yet so f@#$@#king major).. and the CLEAN approach to object construction.. finally.. the "lack of" duck typing that looks TOTALLY like a duck, multiple argument lists that make currying so easy that it's trivial to make your own "operators", true OO without the auto boxing madness of Java, sexy operator overloading with C++ precedence thrown in for free, Erlang's actor model, etc..

The authors also tell you the why behind the how which is very much appreciated.

I consider this book a must read.. Even if you don't plan on using Scala, it exposes so much innovation that it is really a joy to read.

I was initially turned off of Scala because of it's compatibility with Java but now realize that I was misguided as it plays a much more minor role than I previously assumed.

Even if you put all of Scala's functional programming aspects aside, it's a much cleaner OO implementation than Java, so if you are more of an OO purist, you will love Scala.. first class functions, everything is an object, declarative overriding, bounded generics!

As for the functional, everything is there as well.. higher order functions, anonymous functions, closures, Erlang actors, pattern matching..

Putting both together, you get first class higher order functions and pattern matching on type! totally cool..

ilan

Must Buy!

I don't know how the first edition looked like, probably completely differently, because there were a lot of praises and for the second edition I cannot shake off the feeling the book by the designers of Scala was simply pushed in order to show the Scala is a mature language.

Or maybe my expectations were too high... Anyway, taking into account it is over 800 pages, I expected nothing else but the bible, the ultimate reference of _the language_, something like TC++PL by B.Stroustrup for C++. Not the case here -- when you start peeling off the content starting from frontend (Scala wrapper for Swing) you notice the chapters are too shallow, the wrapper is buggy, it does not tell anything essential, so those pages are simply wasted. Same story with XML parsing (once you start using it, you will google for it and find out it is recommended not to use it, because of its peculiar design). Maybe something about regular expressions? -- forget it, there is a section for it, but it really says in bold words "use google, Luke". Oh, and when it comes to deployment, use google too.

So, in short, for "external" features&issues, it is better to forget about this book. How about the core language? Fortunately the meat is in it, but... the organization is messy. Not only notes or remarks, further references, parts you can skip or not (the authors are probably big fans of RPG), but even at macro scale -- in the middle of learning the language, without solid foundations -- unit testing. Collections are explained _after_ the List is explained, and implementation/design of List is on the other hand several chapters after Collections.

I am also annoyed by lack of _clear_ indication (or warning even) whether given part is genuine Scala construct, or it is just a thin layer over Java library and I should read explanation in some Java book. I just hope ex-Java developers recognize the difference on-fly and have more smooth ride than I do (no Java background).

This is not worthless book, but it is not a good book either, reading it is not fluent (because of all remarks, discontinuities), as reference it is a disaster. Each time I try to get something from it, I get "not here" answer. After some time, now I try to use google first, because I am tired with fruitless getting it from library just to put it back.

Final word -- if I could have my money back, I would not buy it again, sorry, too chaotic, too shallow, poor as a reference, and bumpy reading. And not hardcover for over 800 pages (the one thing which is not the authors' fault). My recommendation -- look somewhere else.

Of the books I've read marketed toward working programmers (read: not textbooks), Programming in Scala (PiS) is my favorite.

First off, the book is accurate. Martin Odersky invented Scala and is a researcher in programming languages. So yes, he "gets it." PiS lacks the errors (conceptual errors, editing errors, programming errors, etc.) one usually finds in programming books. PiS is precise in its use of terminology. Odersky says what he means, means what he says, and understands what he's saying. PiS is a masterpiece of technical writing for a general programming audience.

Second, PiS doesn't get ahead of itself. It builds its coverage of Scala at a reasonable pace, giving you everything you need to understand the next section. The staircase on the front cover is a good summary of PiS itself, not just the Scala language, as is the subtitle "A Comprehensive Step-by-step Guide." Object-oriented programmers with a couple of years of experience should have no trouble picking up the functional style.

If you're a programmer considering Scala or interested in learning a functional language, I strongly recommend PiS.