Customer Reviews

Programming Scala: Tackle Multi-Core Complexity on the Java Virtual Machine (Pragmatic Programmers)

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

 

 

Last year, I decided to go through what I thought was to be an easy undertaking and that was to learn Scala. The only book at the time was Artima's 'Programming In Scala' (note the 'In' in the title, it's a different book), and the book was OK at first, but became a very difficult read as the chapters progressed. The reason for the hardship is because that book does what a tremendous amount of programming books do erroneously, they provide long examples and even longer explanations for those examples over the course of many pages. The problem with that is that you often are flipping too much to reference back to the code and back again to the explanation, and you end up at the inevitable point that you realize that you didn't really learn that much.

This book, 'Programming Scala', does it right. It gives you a code snippet on the average of 12-15 lines and provides a quick and clear explanation. Venkat Subramaniam repeats that recipe throughout the book and it really increases your chances of retaining this information, which is exactly what you need. The structure of this book is a winning formula.

'Programming Scala' covers generics, collections, and pattern matching better than any book on the market. You will appreciate that it offers more Scala/Java translations and gets into programming classes and objects a lot sooner than other Scala titles

If you want to learn Scala quickly and you want to be able to retain what you read, and if you need a reference long after you read the book initially, this is a great title to have in your library.

The reviews that say the title is misleading completely miss the point. Scala is a great language for current programming, but not because it's packed with libraries for managing concurrency. Lea's book and Goetz's excellent Java concurrency books do a good job of taking this approach, but that's because Java's concurrency model demands such an approach to the problem. Functional languages that are constructed like Scala can effectively sidestep many of the concurrency pitfalls precisely because they take a different, simpler approach to the core programming problem, addressing concurrency where other languages fail: mutable state.

This book does an excellent job of building foundations for building applications in the right way, using the functional paradigms. With a hybrid object-oriented/functional language, this is the strongest approach to the problem.

600 page reference tomes are dead. They're obsolete before they hit the shelves. Modern languages just move too fast. The best books get you relevant information quickly, in a form that can let you digest a complicated topic in a reasonable amount of time. Google will always be a better reference.

This is a great book for a good price.

In Programming Scala, author Venkat Subramaniam answers this question with a definitive, "No." He says, "The benefits [of Scala] have removed a huge burden from your shoulders. With Scala, you can focus on your application logic instead of worrying about the low-level threading concerns."

As a Groovy/Java developer, I found much to like about Scala. Scala classes compile down to java.lang.Objects, so interoperability with Java is baked-in. The syntactic sugar shared with Groovy (triple quotes, optional semicolons/parentheses/exception handling, sensible defaults for class/method accessibility, etc.) makes me feel right at home. This allowed me to focus on the semantic differences that Scala brings to the party -- tuples, companion objects, and the ever-present val (an immutable variable).

You see, the complexity of multithreading on the JVM largely evaporates once everything is immutable. As he says, "In functional programming, functions are pure. The output they produce is based solely on the input they receive, and they are not affected by or affect any state, global or local." The book starts with that basic premise, and then proceeds to walk you through simple examples that reinforce that notion. Each chapter builds on the next until finally you have a finished application at the end of the book, complete with XML handling, calls to RESTful web services, and GUI to boot.

Does Venkat supply the complex problems for you to solve? No -- you probably already have them at work. Does he supply a clearly written, easy to follow introduction to Scala that gives you the skills to solve them yourself? Absolutely. But he says it best: "If your objective is to learn everything that there is to learn about Scala, you will not find that in this book...What you will see in this book are essential concepts that you need to know to start using Scala." I'm ready to start using Scala, and I can't think of an easier (or more enjoyable) way to get up and running quickly in a promising new language.

This book is a great introduction to Scala, but the title may mislead some of the readers. I love Venkat's books including the Groovy book he wrote and of course the Practices of an Agile developer. They are well written and are fun to read and aren't the typical dry programming book you usually encounter. This is usually the case with the Pragmatic publishers though. I love theirs books!

The reason I was saying that the title may mislead developers, is that they may be expecting a whole book devoted to only figuring out how to handle multi-core complexities. And I have to say that the book does do that. It may not be in the format that people may have expected. The way that the content was presented was that everything should be treated as immutable, therefore allowing for concurrent programming without deadlocks and race-conditions. This does eliminate a lot of the intrinsic complexities (because of mutable state) and makes programs concurrent when using Actors. So the title does deserve to have tackling multi-core complexities.

The chapters introduce many of Scala's concepts and provide nice examples. I did not get a chance to read the Programming in Scala book yet and I don't have much Scala experience. So based on that I do not really know if the author went through all of the concepts of Scala, but he certainly appears as if he went over all of the major features. Those features are probably the most profound and would probably be used most day-to-day.

On the features of Scala that were presented, I really liked the function objects. They are pretty much like closures in Groovy, except that they're not dependent on outside variables (like closures).
Groovy doesn't discriminate on whether there are external variables or not. You can choose to use them in your closure or not.

I have to admit, I was a bit skeptical of Scala as a replacement for Java, but after reading this book, I do believe that the set of features (particularly Erlang style message passing via Actors), give Scala a huge advantage. The one thing that Scala does not provide is meta-programming capabilities, but in that sense Groovy could fill the void.
It would be awesome to have Scala/Groovy programs in the future as both complement each other in huge ways. Those two may become the de-facto languages on the JVM very soon.

I was going to give this book only four stars, mostly because I think it could've went a bit further into some of the features. That however, would've made the book longer and not a short-fun read that it is.

Thanks Venkat for another great book!

For several years it has been obvious that Java (the language) is in a crisis. In order to deal with modern software development problems, the complexity of the language has grown, made even more complex by the legacy of Java (the language) itself.

With the rise of JRuby, Erlang, Clojure, and Scala, Java (the platform) is vibrant with compelling languages that solve very specific kinds of problems. Best of all, its all Java (the bytecode and libraries), so it all interoperates.

Scala is a great example of the 'new thinking'. Once upon a time, the concurrency capabilities in Java were pretty revolutionary to have at the language level but still left the developer with a complex set of problems to solve (just look at the book Java Concurrency in Practice to see why). As core counts go up on our computers, this will only get more complex. Scala's concepts of enforced immutability, message passing and thread-based Actors reduces concurrency to a tractable problem... So much so that other reviewers seem upset the book doesn't cover it in more detail. I don't think it needs to... A "Scala Concurrency in Practice" book would be pretty small, and of pretty limited value. And thats the point - by reducing it to a tractable problem, you spend less time worrying about the mechanics and edge cases, and more time solving problems related to your core business.

"Managing multi-core complexity" is clearly a killer use case for Scala, and as a subtitle for this book gives a Java developer the reason why Scala should be in their developer's toolbox. You can't use Scala without knowing the language, its idioms and design motivations, and this book gives you all of that. Venkat's writing style (and book organization) are top notch.

Even if you can't use Scala in your day job, the principles you'll learn from learning Scala will influence the way you write your day-to-day Java.

Coming from a Java/Groovy background, I have looked for a good introduction into the language and scanned through various books. For my purpose, this one delivers best!

It has a very encouraging and motivating tone but avoids to be overly fanboyish. In fact, it doesn't shy away from sweeping through some dark corners of the language, which I found particularly useful.

I also appreciate that it is short - less than 200 pages - but still gives a comprehensive overview.

The examples are not always easy to understand (for someone like me), but that seems to be rooted more in the nature of language than the quality of the book. Very good: no "foo/bar" examples! I would have liked, though, to have more introduction to each example instead of explaining them afterwards, which easily leads to head-scratching when reading the code and turning back to the code every so often when reading the explanation.

I was inclined to give it 4 stars, but then I wanted to counter-balance some of the overly non-justified low-star reviews. This book has a unique quality and I recommend it for all readers that seek information what that language is all about to put the current buzz in context.

disclosure: I must confess that I'm a colored pencil addict...

Reasonable book about Scala that gets one star for misleading title. This book IS NOT about multicore and concurrent computing. This is general (but short) book about Scala, with one chapter (Chapter 10, 23 pages) about concurrent programming. This chapter presents Scala constructions supporting concurrency illustrated using extremely simplistic examples. I was expecting something like Lea's books on concurrency in Java. Since I have enough books about general programming in Scala and much better than this one, this book is returned back to Amazon.

However, I DON'T claim that this book is bad or useless - actually, this is pretty good introductory book. My complain is that the content has nothing common with the title

This book is a great introduction to Scala and how it helps developers address the problem of concurrent programming on the JVM. Just like his other books, this one is written in Venkat's style, heavy on the coding examples. If you've ever heard him speak, you'll be able to hear him on every page of the book. :)

Scala is one of the best up and coming JVM languages. If you haven't taken the time to check it out, this is one of the best places you can start. Highly recommended.

As a few others have pointed out, the title is misleading, there is little in the book on the actual subject of "solving multi-core" complexity. Instead, treat it as a good introductory book for a Java programmer. The book covers all the major API's, language constructs and syntax in a concise form, without overloading the reader with unnecessary detail. It's an easy read if you're looking to capture the high-points of the language.

Courtesy of Pawel Stawicki from Szczecin Java User Group:

"Courtesy of The Pragmatic Bookshelf I was able to read "Programming Scala" by Venkat Subramaniam. If you are a Java programmer, this book is a great introduction to Scala for you. It is packed with knowledge. There was not even one chapter after reading which I could say "well, this was quite obvious, I could expect this". Book is targeted for experienced Java programmers, so author does not cover things we already know. This was great for me, my time was not wasted learning what I don't need. Instead, I was led from easier topics in Scala (like classes, typing, closures) to more difficult ones (pattern matching, actors and concurrency) at a nice pace. Most topics are explained quite clearly and understandable. There are few which I had difficulties understanding and I needed to fiddle with some code to get it. But fiddling with code is fun for programmer, isn't it? One of such topics were actors, which is a great feature in Scala and something completely new for Java programmer (unless he knows Erlang too ;)). It took me some time with IDE to understand actors, but it was also fun.

The book not only teaches how to program in Scala, but also shows tools to run these programs. Knowing that Scala doesn't necessarly need to be compiled to run and that it can be run as a script can be very useful if you need to do some simple job on your system. Author shows how to use it as a scripting language. I also liked the last chapter in which author creates Scala application using various features covered in the book. It was a good way to sum up.

The only weak point of this book are examples. Especially at the end of the book they become more and more difficult and not always clearly explained. Another disadvantage of examples is their little connection with reality. Have you ever need to count letters in blog URL? In some cases they even show bad practice like throwing general Exception. I know it's only example, but educational book should not promote bad practice even there.

Said all this, I would recommend this book to every Java programmer who wants to learn Scala. If you are not afraid to fiddle a little with code (and you should not be, you are a programmer after all;) ) it is a very good book for you and you are it's perfect target.

Last but not least, not only author, but also editors deserve praise. I have PDF edition and I can login on [...] page anytime and download it. I don't have to worry that if I loose it - it's lost for good. Moreover there are .mobi and .epub formats available. I could read the book on my phone on a bus or a tram which was very convenient. And there is even more - the books are DRM free, which shows publishers not only care for readers comfort, but also trust us. I appreciate that."