Scala in Action: Covers Scala 2.10

Java is definitely a prerequisite here - not so much for the code fragments - but the discussion of the philosophy of Scala that sometimes goes into some detail.It isn't a structured introduction by any means and Developers without core OOP/Functional background will certainly struggle a bit - I found my (rusty) Computer Science degree extremely useful to fill in missing gaps, even then this isn't an easy read.. Unlike the previous reviewer I would respectfully say novices to Programming would feel completely out of their depth very fast and even those with some programming skills would benefit from a basic theoretical computer science course.However it thoroughly covers Scala (2.10) and made me feel a lot more confident in developing under Android.I haven't read the Odersky book so can't contrast - but the emphasis on real world applications does make it a really useful addition to the albeit few books out there at the moment.Highly Recommended for those who know some Java, others might not I feel get the maximum benefit this book provides.Added to say: I have spent some time with the Odersky book which seems a far gentler introduction - in fact considerably so. I'd recommend Odersky for beginners and those with some imperative experience and this book for those with at a reasonable grasp of Java or with a classical computer science education.

I didn't feel that the content in this book flowed very well, and it was littered with basic spelling and grammar errors that really should be picked up by the editor prior to publishing. I get the sense that some aspects were a bit rushed, and was quite disappointed with my purchase.Something that attracted me to this particular book was that it is quite recent and covers Scala 2.10 - but in hindsight, I'd rather buy a better (albeit slightly dated) book and fill in the gaps myself.I usually find myself addicted to my tech books, battling to put them down... this one didn't quite live up to that standard. Can't say I'd recommend it.

In a nutshell: This is a great book if you are looking for a rapid introduction to Scala with a very practical focus - where else would you be building a Scala-based RESTful API and MongoDB driver within the first few chapters, and have fun doing it! Although the book states that the target audience is open to all levels, I believe that programmers with some previous exposure to an OO language will get the most out of it. That's not to say novice developers won't enjoy the book, but they may find it quite fast paced.'Scala in Action' will offer seasoned developers much to think about, as this book is very focused in teaching you pragmatic (and idiomatic) usage of Scala. The fact that Scala manages to blend both Object Oriented and Functional programming styles means that learning this language provides a great transition into the differing approaches offered by these styles, and every good programmer knows that the more tools he/she has available, the more productive (and elegant/expressive) they and their code will become.In addition to the topics mentioned above this book also covers concurrency using the Actor model with Akka (to which I am becoming more and more of an advocate!), testing and TDD (which I believe is mandatory in any new technology book) and the interoperability between Java and Scala.I haven't fully digested all of the book yet, and I believe I'll be reading it several times (and more imporantly, experimenting even more with the code samples). However, 'Scala in Action' has been a perfect companion in my first serious voyage into learning this language, and it comes highly recommended for anyone else attempting the same task!

416 pages can have an impact on your life - regardless of what book you're reading. When it is to learn a new programming language, you'd be better off spending these pages in a pleasant and comfortable way. I think the book "Scala in Action" by Nilanjan Raychaudhuri (Manning), can be a vivid example thereof. I recommend reading the book, but only as the second or third book about Scala as it may be too practical or too tools-packed at times, that can lead to confusion for people new to Java tools and frameworks. I think it's not very rarely when one can drift away from the main track - to learn Scala, esp. at the end of the book.The book is however very good at leading a reader throughout Scala by many examples to eventually become one - hence the title "Scala in Action".The book starts with the quotation from James Gosling, the creator of Java, who once said: "If I were to pick a language to use today other than Java, it would be Scala". It sets the course for the entire book that's certainly not about Java (which should come as no surprise given the title), but Scala and aims at convincing you to use Scala as your next language (should you need one).The cover says "Covers Scala 2.10" and I remember that was my first thought about the book - how much of Scala 2.10 can I read about in this book? Would the new features of Scala 2.10 be somehow explained in details? Scala 2.10 was covered...partially. It's not certainly a book to cover the latest and greatest of Scala 2.10, but Scala in general, regardless of the version you use. When you attempt to match "New features in the 2.10 series" to what the book offers you may get a bit surprised how little the book covers - no value classes, no implicit classes, no dynamic and applyDynamic, Akka Actors are still a dependency in sbt of the projects in the book, and finally no macros. The book was indeed "updated to reflect the newest changes in Scala version 2.10" (page xvii), but lacks many of them not to mention their thorough explanation. While 2.10 found its place in Chapter 3, Summary mentioned just 2.8. Section 4.7 also uses 2.8 to refer to the new Scala release. It may be confusing for newcomers when they attempt to "repeat" the book in a development environment.Reading of the book was quite often mind-boggling and took extra steps to ensure I did not get lost while moving from basic (OOP in Scala) to more advanced topics. The book was my third book in a row about Scala (after "Atomic Scala" and "Scala for the Impatient") and yet I found the reading challenging because of the knowledge I had not learnt before. The book was more advanced than the other two books and required more patience and thinking to absorb the wisdom. There're very few pages that were left out without any section or sentence highlighted for later use.You don't have to read the book chapter by chapter, but the author made sure that it might help if you follow the pattern. I did and only now can I consider re-reading the chapters in no particular order. I'm a big proponent of reading books from cover to cover, and it worked so well in this book. There were few moments where I was confused when I had to read about a topic again, esp. Akka actors in Chapters 7 and 11, but the material ultimately turned out different (and confusion vanished pretty soon).As Chad Fowler said in Foreword: "Reading the book is like having an experienced mentor accompany you every step of the way". No doubt, he's right! I myself had a great time learning Scala with this book and lost no minute while reading it.The book's aim is to learn you Scala and how to use the language to develop real-world applications. Previous experience with Java is not required, but since many of the Java frameworks - Spring Framework, Hibernate, Maven, JUnit - are used, it does help here and there.It seemed as if the author had still remembered his past days when he was learning Scala as there're times during the reading when I asked a question and the answer came just right after I turned the page.Figures, side notes, hints, references to external articles and blog entries, tables, and many other layout-improving decisions made the reading very pleasant. After all, that's what makes Manning stand out in the publishing crowd. Be prepared to visit GitHub for a complete experience, code-wise.There're many personal advices and observations. The author often uses "I used..." or "I tend to..." in the book so one can learn from his experience.Here come more tailored descriptions of every chapter.Chapter 1 is very short and informatory. It may very well be used as a pitch about why Scala (but I doubt there're buildings as high to let you use it in an elevator).Chapter 2 sets the pace for the other chapters so you can easily write Scala programs in Scala REPL as you read the book. The Scala version the author uses is 2.10.0 as the REPL says. The chapter was pretty long and required a lot of patience to read. It's meant for Scala beginners who want to find out how to get started developing basic applications in Scala.In Chapter 3 the author presented user stories as a vehicle to develop a MongoDB driver. The writing style changed and so did the reading. It was quite interesting experience. I found there lots of useful content. It may very well serve as a useful refresher for more advanced Scala programmers and excellent introduction into Scala for less experiences as they could be guided by the example.Chapter 4 was really heavy and interesting. I wish it'd been longer.No comments about Chapters 5-7 as I seemed to have been completely immersed in absorbing the knowledge and had no time to write summaries.Chapter 8 was the most informatory and helpful for me to extend my knowledge of Scala. It was not how to use Scala with tools and frameworks in mind, but how type-safety (and hence the compiler) can help build modular systems. It was very heavy knowledge-wise with material I won't likely understand soon. It was very advanced and thorough. I wish the author had spent more time and devoted more space to cover the nuances of working with type system in Scala with more examples. I highly recommend the chapter.Chapter 9 was an interesting reading. It's a bit too short, but since the topic itself is quite large, one chapter would always be too short, regardless of the number of pages. The flow was pleasant and steady. Actors and futures included.Chapter 10 was a mixture of libraries and features of Scala, esp. for dependency injection. Succinct and comprehensive.It's not very rarely when the author tries to explain a term and it does it in a way that's more confusing than helpful, e.g. algebraic data types or variance. These parts certainly beg for a heavy rewrite.As a final remark - have you ever heard about Clean, the language? The author did and had a word about it (page 124). I'm always glad to be told about other exotic languages as I seem to be getting more interested in programming languages lately.Thanks Nilanjan for a very informatory reading! I'm looking forward to reading the 2nd edition of the book. Don't let me wait long, please.

Pros:1.This book focuses on how to build a real working Scala application with plenty of examples.2.This book covers comprehensive topics around Scala: the basics of Scala, FP v.s. OOP, Web Apps in Scala and Akka.Cons:1.Not too much detail about Scala. You need to go further reading like "Scala in Depth" to truly understand the whole Scala.2.The book lacks examples using latest Typesafe stack like Slick for ORM and Play! for Web app. You need to get another book for that.Overall:It's one of the best book for people to jump into the Scala world!

Il libro spiega in maniera esaustiva molti argomenti di scala, non prende in esame tutti gli aspetti, ed è in inglese, ma per chi comincia e mastica bene l'inglese è un buon libro a mio avviso.

This is an advanced book for advanced developers. Do not buy this book as your first book about Scala; it is a very poor introduction. Example: here are the two definitions offered for Closure >> Closure is a first-class function with free variables that are bound in the lexical environment.... A Closure is any function that closes over the environment in which it's defined. << If those definitions make sense to you, then OK, buy the book. Me, I'm not smart enough, I had to go to Wikipedia in order to understand what Closures are. Need another example? Pattern-matching looked pretty easy at first, because it looks so much like the Java Switch statement (and they can be similar). But then the author drops this on the reader: List(1, 2, 3, 4) match { case f :: s :: rest => List(f, s) case _ => Nil } result: List[Int] = List(1, 2). If that makes sense to you, then OK, buy the book. The author gives almost no explanation, writing only: >>Think of it as what it will take to create a List of 1, 2, 3, and 4 from the expression f :: s :: rest, and then this will make more sense.<< There are other examples. I have many years in software development but this book is not helping me understand Scala. And the author claims you'll enjoy learning this fun language! Maybe it's just me, maybe developers more clever than I can get some benefit from this challenging, high-level approach.

This book is definitely not for beginners. Do not buy this book if you are new to Scala. I struggled mightily reading this book. Time for me to buy a different book.....and maybe come back to this when I already know the language...