[Disclosure: I received a free review copy of this book from the publisher.]
My background: I've been a Java developer for twelve years, and I've been following Scala for over four years. I'm not a fanatic about functional programming. My primary interest is in applying Scala in corporate production software development.
"Scala for the Impatient" is to Scala as a recipe book is to cooking. You're not going to learn the basics from it, and you won't learn much of the theory behind Scala, either. It's mostly a collection of short how-to items. The back cover says as much, that it "concisely shows developers what Scala can do and how to do it." In most cases there's no explanation of why something works, how the technique fits into Scala or into various programming styles, what the advantages and limitations are, when you'd want to use it, when you wouldn't want to use it, nor what alternatives you might have.
I have no idea what the purpose of the first few chapters was. They're disorganized grab-bags of mostly the extreme basics (how to call a method) with occasional advanced topics mixed in (implicit conversions and operator overloading, on page 5). If you have even a basic knowledge of Scala, you're not going to learn much until somewhere around Chapter 6. If you're a beginner, these early chapters will leave you totally confused. I'm stunned that the "def" keyword is simply used without any discussion. I'm even more stunned that on page 33 we get, "Alternatively, you could write a.filter(_ % 2 == 0).map(2 * _)" when there'd been no prior mention of closures or anonymous functions, much less the underscore shortcut syntax, nor any mention of the filter and map methods.
Around Chapter 5 or so, the chapters start focusing on specific topics and the book becomes more coherent. Early on there tends to be a problem with organization, where special cases are described first and the topic ends with a description of the everyday usage. This is especially noticeable in Chapter 7 (Packages and Imports), where the chapter drags you through the various ways that you can use nested package definitions before acknowledging that sticking a single package statement at the beginning of the file, the way it's done in Java, "is the preferred notation." Here again, the organization improves in later chapters.
The really good stuff is toward the end, starting at about Chapter 15. Here the chapters are focused on topics that are specialized enough that they're only going to be used on occasion, so there's not as much value in understanding compared with just doing. For example, if you need to write a parser for a domain-specific language, there's not much point in learning all about combinators. You just need to know how to use Scala's combinator parser library, and that's what this book tells you.
Any Scala developer who's trying to write reusable generic classes will run into problems dealing with derived types, and Chapter 17 provides help in heading those problems off. Chapters 18 and 21 show how to deal with even deeper typing problems, plus how to use implicits to make it easier to use your new class library. Understanding the theory behind Scala's type system would be nice, but sometimes you just need to get your danged library working.
"Scala for the Impatient" mostly avoids getting into functional programming. It does, of course, cover closures and the higher-order functions that use them. Beyond that, though, there's not much FP until the latter parts of the book, where there's a glimpse at currying, a sub-section on tail-recursion, a section on higher-kinded types, and a chapter on continuations. The for-comprehension is treated as the equivalent of the Java enhanced for-loop, with a brief mention of the "yield" variation. Other reviewers have also noted the absence of FP cheerleading in this book, which might be even more remarkable than the "for the Impatient" style.
Typical for tech books, the number of typos and factual errors is disappointing (the factual errors are relatively minor and don't significantly diminish the value of the book). It might take a publisher about a year and a half to get a novel into print, but tech books would be obsolete by that time. So they're rushed out the door with a link to the online errata. Unfortunately, the online errata for "Scala for the Impatient" also has typos and errors. Even with the rushing, tech obsolescence already has hit "Scala for the Impatient": Chapter 20 is about actors, but Scala's actors are now essentially deprecated in favor of the Akka library -- Scala 2.10 is currently planned to be the last version containing the actors described in this book.
Also typical for tech books, the index is hit-or-miss. That's particularly unfortunate for a book like this that's mainly a bunch of disconnected tips. The table of contents is going to be the primary tool for locating the desired tips; fortunately, it seems to handle the task pretty well.
Aside from the first few chapters, "Scala for the Impatient" isn't a bad book. But neither is it a great book. I know that different people have different learning styles, and certainly there are those who will appreciate the "just do this and don't ask questions" approach. But for right now I wonder how many people who are considering Scala are the sort who don't want to understand what Scala is about and instead prefer "monkey see, monkey do" recipes. I suspect that by the time a second edition comes out with the typos and errors fixed and -- I would hope -- the first few chapters dropped and the other early chapters reorganized, it'll have a much bigger audience.
The last third of the book, from about Chapter 15 onward, will probably be useful for the Scala programmer who needs to get involved with any of the covered topics: Scala's annotations, XML handling, dealing with the many complications of creating generic libraries in a statically-typed language, parsing of domain-specific languages, the (now deprecated) actor library, creating implicits of various types, and continuations. The middle, Chapters 6 through 14, could be useful to the fairly-new Scala programmer, although I personally don't think the "for the Impatient" style serves well -- I'd rather see a lot more discussion. Chapters 1 through 5 are pretty much a waste of perfectly good trees; although there are a few useful morsels in there, they're hard to find amidst the chaos.