Programming Scala: Tackle Multi-Core Complexity on the Java Virtual Machine

by Venkat Subramaniam

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.

Genres: Programming, Nonfiction, Computers, Technology

285 pages, Kindle Edition

First published March 15, 2009

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).

Reviews

[Rod Hilton · Rating 1 out of 5]

I have enjoyed Venkat's other books in the past, but I felt that Programming Scala was easily his weakest.

One thing about introducing Scala to programmers is that the author must introduce both functional programming as well as Scala's syntax. Many times, it felt like Venkat forgot that both concepts were likely new to readers. A few places, he provided an example in Scala code to introduce a functional programming construct but made no attempt to explain the syntax of the example. This made learning very difficult.

I thought that the examples, for the most part, were good. All of the examples in the book were very simple, but never felt particularly contrived. One of the stranger aspects of the book was that it never really used what I would consider pure functional style programming. Most examples in the book used to illustrate something about syntax ended with a specific string being echoed to the terminal. While these examples made it easy to understand the concept being introduced, they made it difficult to see value. Typically functions return things in functional programming, but in Programming Scala, hardly any functions ever return anything - they just print. It's the equivalent of teaching someone Java by only using void methods.

As far as the book is concerned, it's decent, but I felt like I survived it only because I have some functional programming background. If I had approached the book without knowledge of either Scala or FP, I think I'd have been lost.

[Jonathan · Rating 2 out of 5]

I did not like the structure of this book much at all. I think it showed a lot of bad features of scala early in the book. this is a problem because they hadn't shown us any of the good features yet, so it created a very bad first impression of the language. I think it would have been much better to leave the warts to an appendix or the inter-op with java chapter.

I also did not like that the book did not build up a sample application throughout the whole book, by using new features as they are introduced. The sample app was created in the last chapter of the book. This is bad because instead of giving practical applications of features as you learn them, you are forced to remember all of the features.

[Denis]

Published almost 3 years ago, this book is still arguably the best introductory read on Scala. Not pretending to be a comprehensive guide, it provides a reader with a brief well-structured overview of the main Scala features. Comparing to the author of the O'Reilly book, which is OK too, Venkat is obviously more fond of Scala idioms and shows good examples of functional style code. To sum up, if you are going to learn Scala, read this book first.

[Lars Westergren · Rating 3 out of 5]

A decent introductory book, but the "Programming in Scala" book goes much more in depth. Also, the chapter on Actors and concurrency is the weakest, which is unfortunate considering the subtitle of the book. The Actors code examples look like the author copy&pasted example code from the net and modified it without completely understanding what he was doing.

[Kimberly Grommes · Rating 5 out of 5]

I had been studying scala for a while and then got busy with life. The first book I read was the Artima book. The Artima book is very good, but it's very detailed. Reading this book gave me a high level overview of everything as a reminder. It was a quick and easy read and it served exactly the purpose I was hoping it would serve. I now feel like I can dive back in and quickly get going again.

[Gergely · Rating 3 out of 5]

Not a bad intro to Scala, but it is getting a bit dated, as the language changes quite quickly. Some good examples, and some weird ones too (e.g. I think there's just too much XML processing in there for this day and age, though maybe it's just that I'm hanging out with a different programmer crowd). Would recommend checking it out, though not relying on it for learning Scala.

[Situagent · Rating 4 out of 5]

A very clearly written book, providing a lot of insight in an efficient way. If you are interested in Scala, this is not a bad book to start with.

[Jesús Navarrete · Rating 4 out of 5]

It is a very interesting book to start with Scala when you are a Java Developer. Concise, easy to read and clear. Very recommendable to read as first Scala book.

[Luca Campobasso · Rating 3 out of 5]

It's very nice as theoretical book, but I expect to find, usually some kind of exercise! As an introductory book, it should have.

[Daniel Aarno · Rating 4 out of 5]

Concise and to the point - unlike many other books on programming. Actually this is NOT a book on program; it is a book on programming scala for people who already know how to write software.