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

Venkat Subramaniam (Author)

Book Description

Publication Date: August 4, 2009 | ISBN-10: 193435631X | ISBN-13: 978-1934356319 | Edition: 1

Scala is an exciting, modern, multi-paradigm language for the JVM. You can use it to write traditional, imperative, object-oriented code. But you can also leverage its higher level of abstraction to take full advantage of modern, multicore systems. Programming Scala will show you how to use this powerful functional programming language to create highly scalable, highly concurrent applications on the Java Platform.

The increasing popularity and availability of multicore processors is creating a whole new set of challenges--although you can enjoy true concurrency, you're now faced with higher contention and synchronization issues. Deploying an existing application on a multicore processor may bring out previously hidden concurrency issues. Java's multi-threading facility by itself isn't enough---it's a very low level abstraction. Instead, you need a paradigm that provides a higher level of abstraction to deal with concurrency. It's time to embrace Functional Programming.

Scala is a hybrid Object-Oriented/Functional Programming language on the JVM. Using Scala, you can create traditional imperative programs, intermix them with Java code, and at the same time take advantage of higher levels of abstraction. You can use features that lead to concise, highly expressive code that remove the pain of dealing with concurrency.

Programming Scala will show you the fundamentals of functional programming using Scala. Very quickly, you'll learn how this statically typed language can give you dynamic capabilities to create concise, scalable, highly capable concurrent code.

Pragmatic programmers always use the right tool for the job. For concurrent programming on the Java VM, Scala is the tool, and Programming Scala by award-winning author Venkat Subramaniam is your guide.

Editorial Reviews

About the Author

Dr. Venkat Subramaniam is an award-winning author, founder of Agile Developer, Inc., and an adjunct faculty at the University of Houston. He has trained and mentored thousands of software developers in the US, Canada, Europe, and Asia, and is a regularly invited speaker at several international conferences. He's (co)author of multiple books, including the 2007 Jolt Productivity award winning book Practices of an Agile Developer.

Product Details

• Paperback: 250 pages
• Publisher: Pragmatic Bookshelf; 1 edition (August 4, 2009)
• Language: English
• ISBN-10: 193435631X
• ISBN-13: 978-1934356319
• Product Dimensions: 7.6 x 9 inches
• Shipping Weight: 14.4 ounces (View shipping rates and policies)
• Average Customer Review: 4.0 out of 5 stars  See all reviews (20 customer reviews)
• Amazon Best Sellers Rank: #706,231 in Books (See Top 100 in Books)

More About the Author

Dr. Venkat Subramaniam, founder of Agile Developer, Inc., has trained and mentored thousands of software developers in the US, Canada, Europe, and Asia. Venkat helps his clients effectively apply and succeed with agile practices on their software projects. He is a frequent invited speaker at international software conferences and user groups. He's author of .NET Gotchas (O'Reilly), coauthor of the 2007 Jolt Productivity award-winning book Practices of an Agile Developer (Pragmatic Bookshelf),
and author of Programming Groovy (Pragmatic Bookshelf).

Most Helpful Customer Reviews

31 of 32 people found the following review helpful

5.0 out of 5 stars Book Structure is Everything.... July 6, 2009

By Daniel Hinojosa

Format:Paperback

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.

28 of 32 people found the following review helpful

5.0 out of 5 stars Great book that hits the spot July 10, 2009

By Bruce A. Tate

Format:Paperback

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.

21 of 24 people found the following review helpful

5.0 out of 5 stars Do complex problems require complex solutions? July 14, 2009

By Scott Davis

Format:Paperback

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. Read more ›

8 of 9 people found the following review helpful

5.0 out of 5 stars Java is dead, Long live Java July 11, 2009

By David Bock

Format:Paperback

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. Read more ›