Scala for the Impatient und über 1,5 Millionen weitere Bücher verfügbar für Amazon Kindle. Erfahren Sie mehr


oder
Loggen Sie sich ein, um 1-Click® einzuschalten.
oder
Mit kostenloser Probeteilnahme bei Amazon Prime. Melden Sie sich während des Bestellvorgangs an.
Jetzt eintauschen
und EUR 6,76 Gutschein erhalten
Eintausch
Alle Angebote
Möchten Sie verkaufen? Hier verkaufen
Der Artikel ist in folgender Variante leider nicht verfügbar
Keine Abbildung vorhanden für
Farbe:
Keine Abbildung vorhanden

 
Beginnen Sie mit dem Lesen von Scala for the Impatient auf Ihrem Kindle in weniger als einer Minute.

Sie haben keinen Kindle? Hier kaufen oder eine gratis Kindle Lese-App herunterladen.

Scala for the Impatient [Englisch] [Taschenbuch]

Cay Horstmann
4.0 von 5 Sternen  Alle Rezensionen anzeigen (3 Kundenrezensionen)
Preis: EUR 30,95 kostenlose Lieferung. Siehe Details.
  Alle Preisangaben inkl. MwSt.
o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o
Nur noch 6 auf Lager
Verkauf und Versand durch Amazon. Geschenkverpackung verfügbar.
Lieferung bis Freitag, 11. Juli: Wählen Sie an der Kasse Morning-Express. Siehe Details.

Weitere Ausgaben

Amazon-Preis Neu ab Gebraucht ab
Kindle Edition EUR 16,58  
Taschenbuch EUR 30,95  

Kurzbeschreibung

6. März 2012
Scala is a modern programming language for the Java Virtual Machine (JVM) that combines the best features of object-oriented and functional programming languages. Using Scala, you can write programs more concisely than in Java, as well as leverage the full power of concurrency. Since Scala runs on the JVM, it can access any Java library and is interoperable with Java frameworks. Scala for the Impatient concisely shows developers what Scala can do and how to do it. In this book, Cay Horstmann, the principal author of the international best-selling Core Java(TM), offers a rapid, code-based introduction that's completely practical. Horstmann introduces Scala concepts and techniques in "blog-sized" chunks that you can quickly master and apply. Hands-on activities guide you through well-defined stages of competency, from basic to expert. Coverage includes * Getting started quickly with Scala's interpreter, syntax, tools, and unique idioms * Mastering core language features: functions, arrays, maps, tuples, packages, imports, exception handling, and more * Becoming familiar with object-oriented programming in Scala: classes, inheritance, and traits * Using Scala for real-world programming tasks: working with files, regular expressions, and XML * Working with higher-order functions and the powerful Scala collections library * Leveraging Scala's powerful pattern matching and case classes * Creating concurrent programs with Scala actors * Implementing domain-specific languages * Understanding the Scala type system * Applying advanced "power tools" such as annotations, implicits, and delimited continuations Scala is rapidly reaching a tipping point that will reshape the experience of programming. This book will help object-oriented programmers build on their existing skills, allowing them to immediately construct useful applications as they gradually master advanced programming techniques.

Wird oft zusammen gekauft

Scala for the Impatient + Scala in Depth + Programming in Scala
Preis für alle drei: EUR 101,85

Die ausgewählten Artikel zusammen kaufen
  • Scala in Depth EUR 30,95
  • Programming in Scala EUR 39,95


Produktinformation

  • Taschenbuch: 360 Seiten
  • Verlag: Addison Wesley Pub Co Inc; Auflage: New. (6. März 2012)
  • Sprache: Englisch
  • ISBN-10: 0321774094
  • ISBN-13: 978-0321774095
  • Größe und/oder Gewicht: 23,2 x 17,8 x 2 cm
  • Durchschnittliche Kundenbewertung: 4.0 von 5 Sternen  Alle Rezensionen anzeigen (3 Kundenrezensionen)
  • Amazon Bestseller-Rang: Nr. 39.209 in Fremdsprachige Bücher (Siehe Top 100 in Fremdsprachige Bücher)
  • Komplettes Inhaltsverzeichnis ansehen

Mehr über den Autor

Entdecken Sie Bücher, lesen Sie über Autoren und mehr

Produktbeschreibungen

Über den Autor und weitere Mitwirkende

Cay S. Horstmann is principal author of Core Java(TM), Volumes I and II, Eighth Edition (Prentice Hall, 2008), as well as a dozen other books for professional programmers and computer science students. He is a professor of computer science at San Jose State University and a Java Champion.

Welche anderen Artikel kaufen Kunden, nachdem sie diesen Artikel angesehen haben?


In diesem Buch (Mehr dazu)
Ausgewählte Seiten ansehen
Buchdeckel | Copyright | Inhaltsverzeichnis | Auszug | Stichwortverzeichnis
Hier reinlesen und suchen:

Kundenrezensionen

4 Sterne
0
3 Sterne
0
1 Sterne
0
4.0 von 5 Sternen
4.0 von 5 Sternen
Die hilfreichsten Kundenrezensionen
2 von 2 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Good introduction to Scala with Java background 14. Oktober 2012
Von Joe
Format:Taschenbuch|Verifizierter Kauf
I just purchased the kindle edition of this book and within a matter of minutes, I could get hands on with Scala. Coming from a Java background, I find this book easy to learn. Most of the examples here relate to some concepts that differ in Java. When you see this difference, you could take in the concepts easily. Rather than being a book which slowly introduces the concepts, this book hits spot on. Of course it is assumed that you have some experience or familiarity with OO programming and it helps if your OO Programming experience is with Java.
War diese Rezension für Sie hilfreich?
1 von 1 Kunden fanden die folgende Rezension hilfreich
2.0 von 5 Sternen Eine Ansammlung von Blogs ist kein Buch 20. März 2014
Von Dr. Christian Donninger TOP 1000 REZENSENT
Format:Taschenbuch|Verifizierter Kauf
C. Horstmann schreibt auf seiner Homepage unter What you get:

"Blog-length chunks of information that you can digest quickly."

Leider habe ich diese Information erst gelesen, nachdem ich mir das Buch gekauft habe. Ich bin davon ausgegangen, dass auch dieses Buch so sorgfältig wie die beiden "Core Java" Bände des Autors gemacht ist. Es ist jedoch tatsächlich eine Ansammlung von Blogs. Es findet im Laufe des Buches keine Entwicklung statt. Es ist jedes Kapitel vom Anfang bis zum Ende gleich oberflächlich. Ein gutes Programmierbuch fängt mit einer Übersicht an und dringt dann immer mehr in die Tiefe ein. Es gibt auch keinerlei längeren Programmierbeispiele.
Das Buch ist für einen ersten Überblick noch halbwegs brauchbar. Richtig verstehen wird man aber die Sprache danach nicht.
Wer sich ernsthaft mit dieser neuen - meiner Meinung nach etwas gehypten - Sprache auseinandersetzen will, kommt um das dicke, fette "Programming in Scala" von Martin Odersky nicht herum.
War diese Rezension für Sie hilfreich?
1 von 1 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Kompetent und knackig 7. November 2013
Format:Taschenbuch|Verifizierter Kauf
Das Buch ist für - wie der Titel schon sagt - etwas für den Ungeduldigen. Der Ungeduldige sollte allerdings über mehr als Anfängerwissen in der objektorientierte und funktionalen Programmierung verfügen. Warum mich Scala interessiert? Scala ist zwar eine schöne, moderne Sprache aber der eigentliche Grund liegt in Figaro begründet. Figaro ist eine probabilistische Programmiersprache in einem experimentellem Stadium. Sie ist in Scala eingebettet. Insofern ist Scala nur Mittel zum eigentlichen Zweck Figaro. Deswegen fühlte ich mich vom Titel angesprochen. Zudem hat Martin Odersky - der Erfinder von Scala - das Vorwort geschrieben. Damit ist der Autor geadelt, was seine Scalakompetenz betrifft.
War diese Rezension für Sie hilfreich?
Die hilfreichsten Kundenrezensionen auf Amazon.com (beta)
Amazon.com: 4.4 von 5 Sternen  48 Rezensionen
48 von 50 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen A Pragmatic Tour of Scala for Serious Programmers 26. April 2012
Von K. Ferrio - Veröffentlicht auf Amazon.com
Format:Taschenbuch
For the Impatient:

There's really only one reason to read book reviews, and that's to find out if you should invest your time in another book. The short answer in this case is "Yes!" -- provided you are an experienced programmer seeking greater expressiveness -- and "Yes!" -- if you are have stared in bewilderment at Scala code which seemed like a Byzantine Type Zoo. This book will sort you out and put you on the path to productivity.

For the slightly less Impatient: (Ok, I'm going to run long. I really like the book.)

If you're not using Scala yet but you've been reading about it online, you've probably noticed a lot of discussion and speculation online about which companies and how many people are actually using Scala in production. It's clear that Scala is generating a lot of interest, and similarly clear that many people haven't quite figured out whether Scala is suitable for them and their projects. "Scala for the Impatient" can help you decide for yourself and your teams. And if you decide to adopt Scala for a project, this book will also help get you going.

Let's get one thing out of the way from the start. "Impatient" is not a euphemism for "unprepared." Bring your A-Game. This is a book for programmers who are serious about their craft. It has been intelligently written and carefully edited to enable experienced programmers to quickly learn what's essential and what's extra in Scala. There's no fluff here. If you have little patience for undifferentiated repetition and like the idea that every sentence matters, you're in the right place.

But impatience is not the book's only virtue. As I write this, a wave of Scala books is coming to market. I've read several, most of which I'm unlikely to pick up again. Scala for the Impatient is different, thanks to a unique design and mission. Despite being a young language, a strong dogma seems to have grown up around how Scala is to be taught by books. Not all dogma is bad. But Scala for the Impatient deliberately breaks away from the pack in three remarkable ways:

i) not jumping immediately into functional programming;
ii) thoroughly establishing common ground with experienced Java (and C++) programmers; and
iii) dispatching re-mappable differences before introducing really new concepts

What?!? We could be forgiven for thinking that functional programming is the most important thing about Scala. That might be true, but then why has Scala -- a relative latecomer to the family of functional languages -- generated so much excitement? Perhaps there's more to Scala. Indeed, there is so much more that functional programming makes mostly cameo appearances before finally taking center stage in Chapter 12. That's right: Chapter 12. And I assure you, the first eleven chapters are not slow.

On the contrary, Horstmann swings for the fences on every page, because there's a lot of work to do. Not the least of this work is establishing common ground with experienced Java programmers. If you've ever wondered how much of the "chattiness" of Java is imposed by the JVM, now you know: none of it. Scala is capable of great expressiveness in good hands, so it makes sense to take a fresh look at types, objects and control before applying them functionally. You won't be bored. Like learning a foreign language, you may find that learning Scala gives you a deeper appreciation for the languages you already know.

The third remarkable trait of this book is that Horstmann deliberately addresses what I call re-mappable differences between Java and Scala. Because there is so much genuinely new about Scala, it's important not to be distracted along the way by things which may look new but really are simply remapped. Scala for the Impatient is the only book I've seen so far which demonstrates that the author really understands this. Moreover, Horstmann writes plainly about what you *must* know to be productive in Scala and which are the truly esoteric bits and when you would need them.

I won't read the table of contents to you, but I do want to mention three chapters which really stand out. You've probably heard that Scala has strong support for XML. This gets a whole chapter, and I think you'll be amazed at how natural it feels. Scala makes working with XML fun -- ok, tolerable -- for humans. Another brief but technically solid chapter is devoted to Actors which provide the clean, baked-in concurrency which is a major driver for Scala adoption. And there's even a chapter on the parser library embedded in Scala, which is very useful when you need to parse protocols or storage structures for example. Since parsing theory is a specialty likely unfamiliar to many readers, the essentials are summarized. While the Scala parser library won't replace traditional language recognition tools, its internal domain specific language for parsing may save you from having to jump in and out of Scala for many common tasks.

Finally, the exercises are excellent. Don't skip them! In fact, some of the exercises would make good interview questions.
50 von 58 Kunden fanden die folgende Rezension hilfreich
3.0 von 5 Sternen No time to learn... just tell me what to do 6. Mai 2012
Von Doug Pardee - Veröffentlicht auf Amazon.com
Format:Taschenbuch
[Disclosure: I received a free review copy of this book from the publisher.]

My background: I've been a Java developer for twelve years, and I've been following Scala for over four years. I'm not a fanatic about functional programming. My primary interest is in applying Scala in corporate production software development.

"Scala for the Impatient" is to Scala as a recipe book is to cooking. You're not going to learn the basics from it, and you won't learn much of the theory behind Scala, either. It's mostly a collection of short how-to items. The back cover says as much, that it "concisely shows developers what Scala can do and how to do it." In most cases there's no explanation of why something works, how the technique fits into Scala or into various programming styles, what the advantages and limitations are, when you'd want to use it, when you wouldn't want to use it, nor what alternatives you might have.

I have no idea what the purpose of the first few chapters was. They're disorganized grab-bags of mostly the extreme basics (how to call a method) with occasional advanced topics mixed in (implicit conversions and operator overloading, on page 5). If you have even a basic knowledge of Scala, you're not going to learn much until somewhere around Chapter 6. If you're a beginner, these early chapters will leave you totally confused. I'm stunned that the "def" keyword is simply used without any discussion. I'm even more stunned that on page 33 we get, "Alternatively, you could write a.filter(_ % 2 == 0).map(2 * _)" when there'd been no prior mention of closures or anonymous functions, much less the underscore shortcut syntax, nor any mention of the filter and map methods.

Around Chapter 5 or so, the chapters start focusing on specific topics and the book becomes more coherent. Early on there tends to be a problem with organization, where special cases are described first and the topic ends with a description of the everyday usage. This is especially noticeable in Chapter 7 (Packages and Imports), where the chapter drags you through the various ways that you can use nested package definitions before acknowledging that sticking a single package statement at the beginning of the file, the way it's done in Java, "is the preferred notation." Here again, the organization improves in later chapters.

The really good stuff is toward the end, starting at about Chapter 15. Here the chapters are focused on topics that are specialized enough that they're only going to be used on occasion, so there's not as much value in understanding compared with just doing. For example, if you need to write a parser for a domain-specific language, there's not much point in learning all about combinators. You just need to know how to use Scala's combinator parser library, and that's what this book tells you.

Any Scala developer who's trying to write reusable generic classes will run into problems dealing with derived types, and Chapter 17 provides help in heading those problems off. Chapters 18 and 21 show how to deal with even deeper typing problems, plus how to use implicits to make it easier to use your new class library. Understanding the theory behind Scala's type system would be nice, but sometimes you just need to get your danged library working.

"Scala for the Impatient" mostly avoids getting into functional programming. It does, of course, cover closures and the higher-order functions that use them. Beyond that, though, there's not much FP until the latter parts of the book, where there's a glimpse at currying, a sub-section on tail-recursion, a section on higher-kinded types, and a chapter on continuations. The for-comprehension is treated as the equivalent of the Java enhanced for-loop, with a brief mention of the "yield" variation. Other reviewers have also noted the absence of FP cheerleading in this book, which might be even more remarkable than the "for the Impatient" style.

Typical for tech books, the number of typos and factual errors is disappointing (the factual errors are relatively minor and don't significantly diminish the value of the book). It might take a publisher about a year and a half to get a novel into print, but tech books would be obsolete by that time. So they're rushed out the door with a link to the online errata. Unfortunately, the online errata for "Scala for the Impatient" also has typos and errors. Even with the rushing, tech obsolescence already has hit "Scala for the Impatient": Chapter 20 is about actors, but Scala's actors are now essentially deprecated in favor of the Akka library -- Scala 2.10 is currently planned to be the last version containing the actors described in this book.

Also typical for tech books, the index is hit-or-miss. That's particularly unfortunate for a book like this that's mainly a bunch of disconnected tips. The table of contents is going to be the primary tool for locating the desired tips; fortunately, it seems to handle the task pretty well.

Aside from the first few chapters, "Scala for the Impatient" isn't a bad book. But neither is it a great book. I know that different people have different learning styles, and certainly there are those who will appreciate the "just do this and don't ask questions" approach. But for right now I wonder how many people who are considering Scala are the sort who don't want to understand what Scala is about and instead prefer "monkey see, monkey do" recipes. I suspect that by the time a second edition comes out with the typos and errors fixed and -- I would hope -- the first few chapters dropped and the other early chapters reorganized, it'll have a much bigger audience.

The last third of the book, from about Chapter 15 onward, will probably be useful for the Scala programmer who needs to get involved with any of the covered topics: Scala's annotations, XML handling, dealing with the many complications of creating generic libraries in a statically-typed language, parsing of domain-specific languages, the (now deprecated) actor library, creating implicits of various types, and continuations. The middle, Chapters 6 through 14, could be useful to the fairly-new Scala programmer, although I personally don't think the "for the Impatient" style serves well -- I'd rather see a lot more discussion. Chapters 1 through 5 are pretty much a waste of perfectly good trees; although there are a few useful morsels in there, they're hard to find amidst the chaos.
18 von 19 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen From the perspective of a Java programmer 11. April 2012
Von Wesley Freeman - Veröffentlicht auf Amazon.com
Format:Taschenbuch
I started learning scala "by fire", enjoying the succinctness of the language before really learning what any best practices are, or what it can do--just trial and error. I definitely am happy that I picked up this book, and have learned a lot reading through it. After reading, I feel a lot of refactoring coming on for some of the code I've written.

The information is pretty dense (as you might gather from the title), so I would recommend it for at least an intermediate level programmer. I was a bit shocked to see that the book is ~400 pages, being "for the impatient", but no complaints on the content.

The author continually states "if you're coming from C++/Java, this will make sense to you" or "this might confuse you...", so it seems at least partly aimed toward that audience, which probably makes sense. I felt like I was getting a brain dump customized for me as I read through it.
7 von 7 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Perfect for any Java/C# developer or Scala novice. 14. September 2012
Von Heavy Reader - Veröffentlicht auf Amazon.com
Format:Taschenbuch|Verifizierter Kauf
This is the perfect learning resource for those who are comfortable with Java or C#.

Most programming technologies are better learned with various web resources rather than a paper book; this is a case where a book is much more appropriate. The complexity of the material is suited to a full written explanation rather than merely a web search and the volume of concepts and features in the Scala language and library easily justifies the length of this book without any padding.

So far, every chapter is genuinely useful. I can feel actual learning benefit from everything covered. Nothing is annoyingly basic: this book assumes you are comfortable with Java or C# and know all about classes/interfaces/inheritance/exceptions/packages/static/scoping/etc. This book is also actually entertaining. This is partly because Scala is so well designed. Once I get an understanding of a new Scala feature and I can see why it's an improvement and it is genuinely fun. But this book does a great job of organizing the material and walking the reader through everything.

I have written a few personal projects in Scala before reading this book, but this book has been excellent at helping me learn the Scala language/library feature set properly rather than just using it as a Java++.

I'd absolutely recommend this to anyone interested in Scala or any Java/C# developer who wants to keep up with the newer developments of the software field.
8 von 9 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Scala first, functional programming second 1. Mai 2012
Von esebesta - Veröffentlicht auf Amazon.com
Format:Taschenbuch
This book is a fantastic introductory text to a sometimes-intimidating language, and IMO the perfect companion to the more official text, Programming in Scala: A Comprehensive Step-by-Step Guide, 2nd Edition.

Learning Scala is often entangled with learning "functional programming", since an easy (though not very fair) way to describe Scala is "Java + functional programming". The author chooses to keep his focus on Scala itself, and leaves explicit discussions of functional programming to small asides throughout the book. I think this is a wise move, because part of the beauty of this language is that you can start using Scala in a "imperative" style familiar to many programmers, and learn to embrace the functional programming features of Scala over time.

Pros:
Very concise introduction to Scala syntax and concepts unfamiliar to Java/C++ programmers (pattern matching, closures, currying, etc.)
Doesn't preach functional programming dogma, and lets the features of Scala SHOW the value of a functional style.
Clear explanations of some of the more advanced concepts in Scala (existential types, structural types, type projections, etc.)
Exercises at the end of each chapter are fantastic, focused, and aren't condescending CS101 trivial problems.
More than a "read, discard" programming book - the content is organized well enough to serve as an effective reference text.
Very well edited - especially for a first printing.

Cons (of a sort):
The book has to move very quickly, and some covered only briefly. The impatient programmer will become conversant in Scala quickly, but will eventually benefit from more thicker texts like "Programming in Scala", above.
Waren diese Rezensionen hilfreich?   Wir wollen von Ihnen hören.
Kundenrezensionen suchen
Nur in den Rezensionen zu diesem Produkt suchen

Kunden diskutieren

Das Forum zu diesem Produkt
Diskussion Antworten Jüngster Beitrag
Noch keine Diskussionen

Fragen stellen, Meinungen austauschen, Einblicke gewinnen
Neue Diskussion starten
Thema:
Erster Beitrag:
Eingabe des Log-ins
 

Kundendiskussionen durchsuchen
Alle Amazon-Diskussionen durchsuchen
   


Ähnliche Artikel finden


Ihr Kommentar