Scala is an object-oriented programming language for the Java Virtual Machine. In addition to being object-oriented, Scala is also a functional language, and combines the best approaches to OO and functional programming. In Italian, Scala means a stairway, or steps--indeed, Scala lets you step up to a programming environment that incorporates some of the best recent thinking in programming language design while also letting you use all your existing Java code. Artima is very pleased to publish a new edition of the best-selling book on Scala, written by the designer of the language, Martin Odersky. Co-authored by Lex Spoon and Bill Venners, this book takes a step-by-step tutorial approach to teaching you Scala. Starting with the fundamental elements of the language, Programming in Scala introduces functional programming from the practitioner's perspective, and describes advanced language features that can make you a better, more productive developer.
Programming in Scala: A Comprehensive Step-by-Step Guide
and over one million other books are available for Amazon Kindle. Learn more
| ||||||||||||||||||
New! Introducing the tech.book(store), a hub for Software Developers and Architects, Networking Administrators, TPMs, and other technology professionals to find highly-rated and highly-relevant career resources. Shop books on programming and big data, or read this week's blog posts by authors and thought-leaders in the tech industry. > Shop now |
Book Description
Frequently Bought Together
Product Details
Would you like to update product info or give feedback on images? |
More About the Author
Discover books, learn about writers, read author blogs, and more.
Customer Reviews
Most Helpful Customer Reviews
63 of 66 people found the following review helpful
Format:Paperback
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.
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.
54 of 56 people found the following review helpful
Format:Paperback
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.
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.
21 of 22 people found the following review helpful
By Larry
Format:Paperback|Amazon Verified Purchase
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.
Most Recent Customer Reviews
5.0 out of 5 stars
The Way Forward
With Scala, the JVM platform now has the premier general purpose language it deserves. It has excellent Java interop plus loads of functional programming facilities. Read more
Published 9 days ago by Materialist Formalist
5.0 out of 5 stars
Great introduction to the Scala language
Mr. Odersky knows the why's of every design decision taken on the Scala language creation and development and present it clearly to the readers.
Published 22 days ago by Roberto de Aguiar Bergo Duarte
5.0 out of 5 stars
Comprehensive tour of language
This is a pretty comprehensive tour of the language. It is a bit disconcerting reading through it
because of all the forward references. Read more
because of all the forward references. Read more
Published 27 days ago by lists.arun
5.0 out of 5 stars
great book from The Man
awesome book to get started with scala, and go through the whys and hows of the language design
full of precise explanations and great examples
full of precise explanations and great examples
Published 1 month ago by Stefano
5.0 out of 5 stars
Really clear thinking
This book is so well written. Odersky is a master teacher. He knows just the right time to bring up a topic and knows just how far to push that topic. Read more
Published 1 month ago by Qaezel
5.0 out of 5 stars
Excellent book
Very readable, and explains scala thoroughly. It walks you through scala one step at a time, but not so slowly as to be boring.
Published 1 month ago by Thayne
3.0 out of 5 stars
The Kindle edition is broken for Cloud reader and retina macbooks
The book uses images for code snippets.
These don't display correctly on high resolution displays (such as Retina).
e.g. [... Read more
These don't display correctly on high resolution displays (such as Retina).
e.g. [... Read more
Published 1 month ago by Cosmin Lehene
2.0 out of 5 stars
I think that I'll buy "Scala for the Impatient"
I find it remarkable that this book got so many good reviews. The book is extremely wordy and is not well organized. Read more
Published 1 month ago by Ian Kaplan
5.0 out of 5 stars
By far the most well written technical book I've ever read
Reading the book felt like having the author reading it to me. Whenever, I had a question, I found the answer in the next couple of lines, as if I was asking and getting an answer.
Published 2 months ago by Ioannis Canellos
5.0 out of 5 stars
Best Source for getting Started
Very focused and well organized book. While it is now out of date given Scala is not at 2.10 this book provides a great document for getting quickly ramped up on the syntax and... Read more
Published 3 months ago by TechMizer
