MapReduce Design Patterns und über 1,5 Millionen weitere Bücher verfügbar für Amazon Kindle. Erfahren Sie mehr
EUR 27,95
  • Alle Preisangaben inkl. MwSt.
Nur noch 2 auf Lager (mehr ist unterwegs).
Verkauf und Versand durch Amazon.
Geschenkverpackung verfügbar.
Menge:1
MapReduce Design Patterns... ist in Ihrem Einkaufwagen hinzugefügt worden
Ihren Artikel jetzt
eintauschen und
EUR 6,25 Gutschein erhalten.
Möchten Sie verkaufen?
Zur Rückseite klappen Zur Vorderseite klappen
Anhören Wird wiedergegeben... Angehalten   Sie hören eine Probe der Audible-Audioausgabe.
Weitere Informationen
Alle 2 Bilder anzeigen

MapReduce Design Patterns: Building Effective Algorithms and Analytics for Hadoop and Other Systems (Englisch) Taschenbuch – 31. Oktober 2012

3 Kundenrezensionen

Alle 3 Formate und Ausgaben anzeigen Andere Formate und Ausgaben ausblenden
Amazon-Preis Neu ab Gebraucht ab
Kindle Edition
"Bitte wiederholen"
Taschenbuch
"Bitte wiederholen"
EUR 27,95
EUR 25,18 EUR 20,00
58 neu ab EUR 25,18 4 gebraucht ab EUR 20,00

Hinweise und Aktionen

  • Große Hörbuch-Sommeraktion: Entdecken Sie unsere bunte Auswahl an reduzierten Hörbüchern für den Sommer. Hier klicken.


Wird oft zusammen gekauft

MapReduce Design Patterns: Building Effective Algorithms and Analytics for Hadoop and Other Systems + Hadoop: The Definitive Guide + Hadoop: Zuverlässige, verteilte und skalierbare Big-Data-Anwendungen
Preis für alle drei: EUR 106,14

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



Produktinformation


Mehr über die Autoren

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

Produktbeschreibungen

Über den Autor und weitere Mitwirkende

Donald Miner serves as a Solutions Architect at EMC Greenplum, advising and helping customers implement and use Greenplum's big data systems. Prior to working with Greenplum, Dr. Miner architected several large-scale and mission-critical Hadoop deployments with the U.S. Government as a contractor. He is also involved in teaching, having previously instructed industry classes on Hadoop and a variety of artificial intelligence courses at the University of Maryland, BC. Dr. Miner received his PhD from the University of Maryland, BC in Computer Science, where he focused on Machine Learning and Multi-Agent Systems in his dissertation. Adam Shook is a Software Engineer at ClearEdge IT Solutions, LLC, working with a number of big data technologies such as Hadoop, Accumulo, Pig, and ZooKeeper. Shook graduated with a B.S. in Computer Science from the University of Maryland Baltimore County (UMBC) and took a job building a new high-performance graphics engine for a game studio. Seeking new challenges, he enrolled in the graduate program at UMBC with a focus on distributed computing technologies. He quickly found development work as a U.S. government contractor on a large-scale Hadoop deployment. Shook is involved in developing and instructing training curriculum for both Hadoop and Pig. He spends what little free time he has working on side projects and playing video games.

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

Kundenrezensionen

4.0 von 5 Sternen
Sagen Sie Ihre Meinung zu diesem Artikel

Die hilfreichsten Kundenrezensionen

Format: Taschenbuch
MapReduce ist ein “Korsett” und zwingt den Entwickler in enge Grenzen. Daher macht es Sinn, dieses Buch zu lesen, damit man schnell die üblichen Tricks und Kniffe kennenlernt. Ähnlich ist es ja beim Lernen von anderen Paradigmen auch, wie z. B. Devide-and-Conquer oder Rekursion. Man begreift das allgemeine Prinzip schnell, man muss aber lernen, wann und wie man es am besten einsetzt.

In diesem Buch werden typische Anwendungsfälle für Hadoop in Java MapReduce implementiert. Dabei liegt der Schwerpunkt nicht auf den eigentlichen Entwurfsmustern (“design patterns”), wie der Titel des Buches suggeriert, sondern auf den konkreten Implementierungen. Wer nur an der Implementierung dieser Pattern interessiert ist, wird mit diesem Buch gut bedient. Man sollte aber vorher schon erste Erfahrungen mit Hadoop gemacht haben und Java gut kennen.

Wer allerdings wirkliche “Entwurfsmuster” für beliebige MapReduce-Frameworks sucht, wird mit diesem Buch nicht 100% glücklich. Die im Untertitel erwähnten “other systems” kommen definitiv zu kurz. Auch wer Hadoop mit Pig, Hive oder Apache Crunch benutzt kann sich das Lesen des Buches evtl. sparen oder nur schnell durchfliegen. Die langen Java-Listings kann man sich dann nämlich sparen.

Wer allerdings wirklich wissen will, was hinter Pig passiert, sei es bei der Fehlersuche oder bei Performance-Problemen, der kann sich hier schon den einen oder anderen Tipp anlesen.
Kommentar War diese Rezension für Sie hilfreich? Ja Nein Feedback senden...
Vielen Dank für Ihr Feedback. Wenn diese Rezension unangemessen ist, informieren Sie uns bitte darüber.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte erneut versuchen
Von haggll am 4. November 2014
Format: Taschenbuch Verifizierter Kauf
I bought this book to get a deeper understanding for the MR-framework and I was not disappointed!
The autor explains every pattern in detail and also gives a lot of additional information like performance optimization, use cases and so on.
This book is for everyone who has the basic unterstandig of MR and now wants to learn more.
Kommentar War diese Rezension für Sie hilfreich? Ja Nein Feedback senden...
Vielen Dank für Ihr Feedback. Wenn diese Rezension unangemessen ist, informieren Sie uns bitte darüber.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte erneut versuchen
3 von 5 Kunden fanden die folgende Rezension hilfreich Von mko am 23. Dezember 2012
Format: Taschenbuch
I admit, this was not a good idea to start MapReduce adventure by jumping directly into Design Patterns. However, I had my goal in it. Long, long time ago in a C++ galaxy far away there was a design patterns related book: “Design Patterns: Elements of Reusable Object-Oriented Software”. And it was good.

“MapReduce Design Patters” tries to be something similar within MapReduce area. However, this book focuses on the implementation too much. If you are not familiar with MapReduced yet, it will not help you becoming fascinated about the whole idea. After reading dozen of pages I had to start from the scratch by looking for some additional MapReduce introductions before I have gotten back to this one.

It’s really hard for me to judge the technical side of the book. This is entirely my fault as I am completely new to MapReduce. Yes, I know, it was like
jumping in at the deep end. However, I was hoping that design patterns will be presented in more general way, more the way design patterns were presented in already mentioned “Design Patterns: Elements of Reusable Object-Oriented Software”. My point is. I don’t claim that MapReduce Design Patterns is written badly. No, not at all. On the other hand, if you’d like to become more familiar with the general idea of MapReduce, this is not a good place to start.

Big plus goes to the authors for collecting various patterns and indexing them in a one place.

And one more explanation. This book is not designed for the complete beginners like me myself. Authors themselves say: “The motivation for us to write this book was to fill a missing gap we saw in a lot of new MapReduce developers. They had learned how to use the system, got comfortable with writing MapReduce, but were lacking the experience to understand how to do things right or well”.
Kommentar War diese Rezension für Sie hilfreich? Ja Nein Feedback senden...
Vielen Dank für Ihr Feedback. Wenn diese Rezension unangemessen ist, informieren Sie uns bitte darüber.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte erneut versuchen

Die hilfreichsten Kundenrezensionen auf Amazon.com (beta)

Amazon.com: 18 Rezensionen
82 von 95 Kunden fanden die folgende Rezension hilfreich
A Case of Appendicitis 20. Januar 2013
Von Mark D. LaDue - Veröffentlicht auf Amazon.com
Format: Taschenbuch
In the 1990s O'Reilly books had a well-earned reputation for quality. O'Reilly authors such as Simson Garfinkel explained technical topics with precision, clarity, and wit. I proudly kept a whole shelf of O'Reilly books at work, and I imbibed copious java from their tenth anniversary mug. I'm sorry to see that O'Reilly's traditional quality has gone the way of the Internet bubble. MapReduce Design Patterns represents the absolute nadir of technical writing, and it never should have been published in its current form.

One of the most poorly written parts of the book is Appendix A on Bloom filters. As I was writing my original review of the book, I thought it might be helpful to point readers to a better explanation of the topic. Turning to Wikipedia as a potential reference, I was struck by the number of similarities between it and Appendix A. It now appears that this appendix plagiarizes the Wikipedia article "Bloom filter." To see this, compare the opening paragraph of the Wikipedia article (January 19, 2013) to the first two paragraphs of the book's appendix (which you can see in the sample pages here):

Wiki: A Bloom filter, conceived by Burton Howard Bloom in 1970, is a space-efficient probabilistic data structure that is used to test whether an element is a member of a set. (Paragraph 1, sentence 1)

MRDP: Conceived by Burton Howard Bloom in 1970, a Bloom filter is a probabilistic data structure used to test whether a member is an element of a set. (Page 221, paragraph 1, sentence 1)

Wiki: False positive retrieval results are possible, but false negatives are not; i.e. a query returns either "inside set (may be wrong)" or "definitely not in set". (Paragraph 1, sentence 2)

MRDP: While false positives are possible, false negatives are not. This means the result of each test is either a definitive "no" or "maybe." You will never get a definitive "yes." (Page 221, paragraph 2, sentences 2 - 4)

Wiki: Elements can be added to the set, but not removed (though this can be addressed with a counting filter). (Paragraph 1, sentence 3)

MRDP: With a traditional Bloom filter, elements can be added to the set, but not removed. There are a number of Bloom filter implementations that address this limitation, such as a Counting Bloom Filter, but they typically require more memory. (Page 221, paragraph 2, sentences 5 and 6)

Wiki: The more elements that are added to the set, the larger the probability of false positives. (Paragraph 1, sentence 4)

MRDP: As more elements are added to the set, the probability of false positives increases. (Paragraph 2, sentence 7)

When confronted with examples like these, authors typically claim that the similarities are due to their unintentionally copying verbatim from their notes. While that may be true in some cases, it is the task of the publisher to see that problems like this are corrected before books are released. Clearly the authors and the editors at O'Reilly have failed to diagnose this problem and provide a timely appendectomy. The result is a book with a fatal case of appendicitis left to die a humiliating death in the marketplace.

Although MapReduce Design Patterns would have benefitted from an appendectomy, such an operation would have been insufficient to restore the book to good health. For much of the book suffers from a sort of write-once-copy-everywhere mentality that leads to dreadful writing and programming. A few choice examples should suffice to illustrate this point.

Until the book's penultimate chapter every example except two includes this pattern of statements:

"The following descriptions of each code section explain the solution to the problem.
Problem: ..."

Apparently it occurred to neither the authors nor the editors that it might be premature to refer to "the problem" and its solution before that problem had been stated. And certainly no one thought to ask whether or not the first sentence of the pattern clearly sets forth what's coming next in the book. Yet through the magic of the Ctrl-C, Ctrl-V sequence, this statement appears dozens of times throughout the book.

The first hint of an editorial hand finally appears at beginning of the Generating Data Examples section of Chapter 7, where at last we find the statement of a problem in paragraph form followed by our now familiar sentence. Unfortunately, the book's remaining four examples revert to the authors' text design pattern with an ungrammatical twist:

"The sections below with its corresponding code explain the following problem.
Problem: ..."

Perhaps a NullWritable object would have made a better editor.

Fortunately, not all of the book's wretched writing is as annoying as this. Some of it, such as this garbled thought from page 185, is hilarious:

"There is no implementation for any of the overridden methods, or for methods requiring return values return basic values."

Programmers may be amused by how the class MRDPUtils seems to appear and disappear randomly with the invocation of the method transformXmlToMap() in the book's code examples. They may also laugh at the erroneous comments in the source code on pages 20, 23, 26, and 29. Since the book's sample code contains the same errors, one might begin to wonder if anyone read or tested that code after it was written. Considering the map() method of the UserIdReputationEnrichmentMapper class given on page 165, that seems unlikely. An astute reader will easily see that this method emits the wrong key, and testing certainly would have revealed it. Since the map() method's actual output clearly contradicts the specification for the reducer implementation on the same page, the problem could have been spotted by a conscientious editor.

Almost two decades have passed since Simson Garfinkel typed "buy more O'Reilly books" in an example in one of his books. After reading MapReduce Design Patterns, I no longer agree with his recommendation. Readers who are interested in this topic will do well to look elsewhere for more information on the subject.
13 von 15 Kunden fanden die folgende Rezension hilfreich
Good introduction, but missing the depth 23. Januar 2013
Von Varun Sharma - Veröffentlicht auf Amazon.com
Format: Taschenbuch Verifizierter Kauf
The book gives a good introduction to MapReduce design patterns. But what i found really missing are good examples.
I had studied Jimmy Lin's book [...]before i read this which gives some really good examples of algorithm design. I was hoping to find something which focussed on how some of the design patterns can be leveraged to implement more complicated and non-trivial algorithms in Map-Reduce more effectively.
But i feel that the book uses some fairly straightforward algorithms to explain the pattern and does not go deep.
Another thing that i did not like is that the book is just too much Hadoop specific and ignores other Map Reduce implementations which are getting very popular.
Overall the book is a good step in introducing patterns and algorithms in a more systematic manner, in the Map Reduce programming paradigm. It gives a good survey of some of the emerging areas in last few chapters. The chapter on Meta Patterns was my favorite as it gives some good introductory material on building more complicated pipelines using Map Reduce, and how one could take steps in optimizing the runtime of bigger pipelines.
10 von 12 Kunden fanden die folgende Rezension hilfreich
Good Book, although need a Good Revision 29. April 2013
Von jcsenciales - Veröffentlicht auf Amazon.com
Format: Taschenbuch
It's a good book that show you a lot of Mapreduce patterns using Hadoop.

But the main trouble it's that you can not trust the examples source code, at all. I Clone the Code Github in my Mac and I've found several bugs..

https://github.com/adamjshook/mapreducepatterns

I'm running the Book's code using a macbook with:

- hadoop-1.0.4
- Mac OS ver 10.6.8
- Java ver "1.6.0_43"
- Eclipse
- Data for running the examples from ( Stack Exchange Data Dump - Dec 2011 _Update_ )

For now, these are the bugs I've found:

Page: 31
The error is in the MedianStdDevCombiner code.
I'm looking for a bug in this full example because when you execute it ,you obtain different result from the previous normal Median and Standard deviation using the same input data. The result obtained is nearly double values from the previous example, when need to be the same results.

Page: 35-36
The error i found is in the Inverted Index Example.
In the Mapper Function if "getWikipediaURL" return a null value then you get a nullpointerException because you need to check if the result of this function is null prior to set the "link" variable value.

Page 117-118
In ReduceSideJoinWithBloomDriver Code from github doesn't exist any reference to load the bloom filter from any argument... [something like DistributedCache.addCacheFile(...... ], this file is nearly a Copy/paste from the previous ReduceSideJoin.java.

Page 122:
In ReplicatedJoinMapper you always get a java.io.FileNotFoundException because this code want to read and decompress a folder , not a concrete "file.gz", inside this folder. You only need to add a index to your files inside the DistributedCache.

Page 144:
In the setup method for the second job, the same error as in page 122, reading from DistributedCache. Indeed, the first job reads this input in a decompressed way and the second job pretend to find this same input in DistributedCache, gzip compressed.
9 von 11 Kunden fanden die folgende Rezension hilfreich
Good resource, though not for the beginner 16. Januar 2013
Von Charles Feduke - Veröffentlicht auf Amazon.com
Format: Kindle Edition
This book is a good catalog of the different patterns any big data solutions programmer should know in order to effectively perform their job. While the authors admit that writing some of these patterns in the context of a map/reduce job on Hadoop with tools like Pig available can be counterproductive they make the compelling argument that understanding these patterns is still important.

The technical examples in the book are sometimes missing blocks of code, which while easily derived may be a source of frustration for some readers. (I have my implementations of the exercises on github, under my username of cfeduke; I learn best by doing, so keying in and executing examples is paramount.)

I've had a moderate level of experience with Hadoop, from 0.18 to 1.x, before tackling this book. I felt that this book taught me a fair amount about the guts of writing a map/reduce job though if I did not have a solid foundation working with Hadoop the examples may have been difficult to grok.

The authors chose to use Stack Overflow community data to demonstrate the patterns presented and I felt that was an excellent decision as its easy to derive other queries to answer - and implement - having some knowledge of the corpus.
2 von 3 Kunden fanden die folgende Rezension hilfreich
Very interesting 18. Februar 2013
Von Dotan Dvir - Veröffentlicht auf Amazon.com
Format: Kindle Edition Verifizierter Kauf
I definitely will use it when designing with Hadoop and other Map Reduce frameworks. The code samples are a bit naive but the ideas are mature and well thought out.
Waren diese Rezensionen hilfreich? Wir wollen von Ihnen hören.