Facebook Twitter Pinterest <Einbetten>
EUR 41,72
  • Alle Preisangaben inkl. USt
Auf Lager.
Verkauf und Versand durch Amazon. Geschenkverpackung verfügbar.
Akka Essentials ist in Ihrem Einkaufwagen hinzugefügt worden

Um Adressen zu sehen, bitte
Bitte tragen Sie eine deutsche PLZ ein.
Möchten Sie verkaufen?
Zur Rückseite klappen Zur Vorderseite klappen
Hörprobe Wird gespielt... Angehalten   Sie hören eine Hörprobe des Audible Hörbuch-Downloads.
Mehr erfahren
Alle 2 Bilder anzeigen

Akka Essentials (Englisch) Taschenbuch – 26. Oktober 2012

2.5 von 5 Sternen 2 Kundenrezensionen

Alle 2 Formate und Ausgaben anzeigen Andere Formate und Ausgaben ausblenden
Neu ab Gebraucht ab
Kindle Edition
"Bitte wiederholen"
"Bitte wiederholen"
EUR 41,72
EUR 38,71 EUR 35,00
9 neu ab EUR 38,71 4 gebraucht ab EUR 35,00
click to open popover

Wird oft zusammen gekauft

  • Akka Essentials
  • +
  • Akka Concurrency
Gesamtpreis: EUR 80,11
Die ausgewählten Artikel zusammen kaufen

Es wird kein Kindle Gerät benötigt. Laden Sie eine der kostenlosen Kindle Apps herunter und beginnen Sie, Kindle-Bücher auf Ihrem Smartphone, Tablet und Computer zu lesen.

  • Apple
  • Android
  • Windows Phone

Geben Sie Ihre Mobiltelefonnummer ein, um die kostenfreie App zu beziehen.

Jeder kann Kindle Bücher lesen — selbst ohne ein Kindle-Gerät — mit der KOSTENFREIEN Kindle App für Smartphones, Tablets und Computer.



Über den Autor und weitere Mitwirkende

Munish K. Gupta

Munish K. Gupta is a Senior Architect working for Wipro Technologies. Based in Bangalore, India, his day-to-day work involves solution architecture for applications with stringent non-functional requirements (NFRs), Application Performance Engineering, and exploring the readiness of cutting-edge, open source technologies for enterprise adoption.

He advises enterprise customers to help them solve performance and scalability issues, and implement innovative differentiating solutions to achieve business and technology goals. He believes that technology is meant to enable the business, and technology by itself is not a means to an end.

He is very passionate about software programming and craftsmanship. He is always looking for patterns in solving problems, writing code, and making optimum use of tools and frameworks. He blogs about technology trends and Application Performance Engineering at http://www.techspot.co.in and about Akka at http://www.akkaessentials.in

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


2.5 von 5 Sternen
5 Sterne
4 Sterne
3 Sterne
2 Sterne
1 Stern
Beide Kundenrezensionen anzeigen
Sagen Sie Ihre Meinung zu diesem Artikel


Format: Kindle Edition Verifizierter Kauf
The book's topic is a fascinating one. Akka is truly an impressive framework for distributed and fault-tolerant middleware development, however, this book suffers from one simple problem: [...] is doing an extremely good job regarding the documentation.

Unfortunately, the author chose to write the book in a way that simply repeats this documentation. Most of the book follows this simple recipe: Akka provides feature X, this is how it looks like in Java, this is how it looks like in Scala. And that's it.

For this reason, I have to advice others to read the original (and obviously much more up-to-date) documentation on akka.io instead of wasting money on this book. I was expecting the book to give me actual insights beyond the mere documentation. Instead of telling me how to do this or that with akka, I expected to learn why one should do it this or that way. What are the pros and cons of various approaches, what are best practices, etc. etc.? Rarely did I even find a single sentence that goes beyond simply explaining what a feature does.

While it's nice that the book covers both Java and Scala, it is extremely annoying to find that the author repeats each and every code listing in both languages. Instead of explaining how to get from one to the other in general, and then sticking to one in the examples it's all redundantly copied. Sometimes even the explanation paragraphs are repeated for the listings in both languages. In essence, you can easily subtract one third from the number of pages due to that redundancy. Do I even need to mention that you can find code samples for all these features on akka.io in both languages anyways?

I was also sceptical at first about the language quality of the book after reading a few articles on the author's blog.
Lesen Sie weiter... ›
Kommentar 3 Personen fanden diese Informationen hilfreich. War diese Rezension für Sie hilfreich? Ja Nein Feedback senden...
Vielen Dank für Ihr Feedback.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte erneut versuchen
Missbrauch melden
Format: Taschenbuch Verifizierter Kauf
Die Akka-Technologie fuer Nebenlaefigkeit (Concurrency) mit Aktoren und ausgetauschten Nachrichten (Messages) eignet sich hervorragend um skalierbare Applikationen zu implementieren. Dies ist das erste Buch, das diese neue Techologie sowohl fuer Java als auch fuer Scala beschreibt. (Da kann man als alter Java-Hase gleich noch ein bischen Scala mitlernen.)

Die Freude an dem Buch wird nur dadurch etwas getruebt, dass es zu viele kleine Fehler enthaelt. Die haette ein guter Lektor (oder der Autor selber) bemerken muessen.
Kommentar War diese Rezension für Sie hilfreich? Ja Nein Feedback senden...
Vielen Dank für Ihr Feedback.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte erneut versuchen
Missbrauch melden

Die hilfreichsten Kundenrezensionen auf Amazon.com (beta) (Kann Kundenrezensionen aus dem "Early Reviewer Rewards"-Programm beinhalten)

Amazon.com: 3.3 von 5 Sternen 9 Rezensionen
8 von 8 Kunden fanden die folgende Rezension hilfreich
2.0 von 5 Sternen Better off visiting the Akka website 22. Juli 2013
Von dal - Veröffentlicht auf Amazon.com
Format: Kindle Edition Verifizierter Kauf
The book does not really provide Akka essentials more like mini introduction to Akka. I got the Kindle version and found that the explanation and the code samples also have a lot of errors and incomplete information-- at least the downloaded code samples seemed to rectify it a little bit since it is somewhat different from what was used in the book. I used it briefly for intro but most of the time I found myself visiting the Akka website and related forums to get more information and understand the concepts being discussed more thoroughly. If I have to visit the web sites a lot anyway, might as well do my research there and in the end didn't use the book a lot.
2 von 3 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen A "Started Reading" perspective 12. April 2013
Von Amazon Customer - Veröffentlicht auf Amazon.com
Format: Taschenbuch Verifizierter Kauf
So far I'm impressed because the author takes the time to explain in baby steps how each aspect of Akka works and why. Full Scala examples (the best reason to buy this book) so if you're looking for this aspect just skip past the Java code. However, I've found several code errors and they always follow this pattern. Perhaps in the Kindle Edition only I'm not sure.

- Author describes a small piece of code or class and defines it (errors exist here, incorrect names, etc)
- seems correct in the final listing of all code

Minus a star for this reason, but workable just skip ahead to the master code pages and you'll be fine. I also wish they'd just split this into 2 books (java & scala) but it works.

Also a word of warning, if you're unfamiliar with the actor model you may need even smaller "baby steps" before reading this book. You might understand the concept of hardline multithreading but this is really different, you have to abandon many of those practices. I recommend reading the chapters on Actors from "Scala for the Impatient" or "Programming in Scala: A Comprehensive Step-by-Step Guide, 2nd Edition" as a companion. I've read both of these books and they are worth buying outright, ("Scala for the Impatient" appears to be listed at a good price for the Kindle lately)

Keep in mind, Akka is now set to replace the Scala's version of Actors in 2.11 (they are not exactly the same) - however, it helped me to learn Scala's simple approach first.
3 von 5 Kunden fanden die folgende Rezension hilfreich
3.0 von 5 Sternen Useful with one issue 22. November 2012
Von Richard Searle - Veröffentlicht auf Amazon.com
Format: Kindle Edition Verifizierter Kauf
The book is up-to-date and provides a broad coverage of Akka.
It is a useful addition to the excellent Akka documentation.

The coverage of STM is a great deal more detailed and is perhaps the most useful chapter.

However there is an unfortunate error.
The BurstyMessageRouter example is not thread safe.
The text implies a router is a form of actor and hence is intrinsically thread safe.
The Akka documentation indicates that is not true:"..the code which decides which route to take is invoked concurrently from all possible senders and hence must be thread-safe,.."
2 von 5 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Excellent introductory book 24. Februar 2013
Von Gabriel Ciuloaica - Veröffentlicht auf Amazon.com
Format: Kindle Edition Verifizierter Kauf
The book is an excellent introduction into Akka framework. Easy to read and follow the examples in both Scala and Java. Examples and the provided source code are not based on latest versions of Akka framework or Scala. Trying to compile and run first example using Scala 2.10 it will fail, because changes into the language, but to is easy to fix it.
22 von 23 Kunden fanden die folgende Rezension hilfreich
1.0 von 5 Sternen many flawed concepts like a plague 25. Juni 2013
Von Giovanni Azua - Veröffentlicht auf Amazon.com
Format: Taschenbuch
This book has some useful information I agree and this is why I am giving it one star. However, it has many fundamentally flawed concepts and flawed examples which are extremely irritating. How come an author covering an advanced topic in parallel computing does not know the most basic principles of concurrent programming and gets to publish such rubbish? the answer to that is beyond me.

For example the paragraph:
"We have Thread.sleep() because there is no guarantee in which order the messages are processed. The first Thread.sleep() method ensures that all the string sentence messages are processed completely before we send the Result message."
Complete rubbish! using Thread.sleep() as means to synchronize concurrent threads. The list goes on and on.

I approached the book because I was interested in a MapReduce solution with Akka. Indeed this book covers MapReduce but it is completely flawed and the result is non-deterministic from run to run! I have discussed the two main concurrency hazards in stackoverflow (http://stackoverflow.com/questions/17291851/mapreduce-implementation-with-akka).

All in all I really do NOT recommend this book. I have no idea where the reputation of this publisher is going to by publishing this rubbish.
Waren diese Rezensionen hilfreich? Wir wollen von Ihnen hören.