Seven Concurrency Models in Seven Weeks: When Threads Unr... und über 1,5 Millionen weitere Bücher verfügbar für Amazon Kindle. Erfahren Sie mehr
EUR 23,95
  • Alle Preisangaben inkl. MwSt.
Nur noch 19 auf Lager (mehr ist unterwegs).
Verkauf und Versand durch Amazon.
Geschenkverpackung verfügbar.
Menge:1
Seven Concurrency Models ... ist in Ihrem Einkaufwagen hinzugefügt worden
Ihren Artikel jetzt
eintauschen und
EUR 10,30 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

Seven Concurrency Models in Seven Weeks: When Threads Unravel (The Pragmatic Programmers) (Englisch) Taschenbuch – 10. Juli 2014


Alle 2 Formate und Ausgaben anzeigen Andere Formate und Ausgaben ausblenden
Amazon-Preis Neu ab Gebraucht ab
Kindle Edition
"Bitte wiederholen"
Taschenbuch
"Bitte wiederholen"
EUR 23,95
EUR 20,94 EUR 30,49
70 neu ab EUR 20,94 2 gebraucht ab EUR 30,49

Wird oft zusammen gekauft

Seven Concurrency Models in Seven Weeks: When Threads Unravel (The Pragmatic Programmers) + Seven More Languages in Seven Weeks: Languages That Are Shaping the Future + Seven Web Frameworks in Seven Weeks: Adventures in Better Web Apps (Pragmatic Programmers)
Preis für alle drei: EUR 71,95

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

  • Taschenbuch: 275 Seiten
  • Verlag: O'Reilly Vlg. Gmbh & Co.; Auflage: 1 (10. Juli 2014)
  • Sprache: Englisch
  • ISBN-10: 1937785653
  • ISBN-13: 978-1937785659
  • Größe und/oder Gewicht: 23,5 x 19,1 x 1,6 cm
  • Durchschnittliche Kundenbewertung: 5.0 von 5 Sternen  Alle Rezensionen anzeigen (1 Kundenrezension)
  • Amazon Bestseller-Rang: Nr. 14.270 in Fremdsprachige Bücher (Siehe Top 100 in Fremdsprachige Bücher)

Mehr über den Autor

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

Produktbeschreibungen

Über den Autor und weitere Mitwirkende

Paul Butcher has worked in diverse fields at all levels of abstraction, from microcode on bit-slice processors to high-level declarative programming, and all points in between. Paul's experience comes from working for startups, where he's had the privilege of collaborating with several great teams on cutting-edge technology. He is the author of "Debug It!."

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

Kundenrezensionen

5.0 von 5 Sternen
5 Sterne
1
4 Sterne
0
3 Sterne
0
2 Sterne
0
1 Sterne
0
Siehe die Kundenrezension
Sagen Sie Ihre Meinung zu diesem Artikel

Die hilfreichsten Kundenrezensionen

Von Andreas Maier am 19. Dezember 2014
Format: Taschenbuch Verifizierter Kauf
Der Autor der Buches ist leider ein Clojure-Fanboy und macht daher einige ziemlich unfaire Vergleiche zwischen Java und Clojure, die die angebliche Überlegenheit von Clojure gegenüber Java zeigen soll. Auch ist Clojure die einzige Sprache, die in drei von sieben Kapiteln zum Einsatz kommt, was ich etwas einseitig finde. Für eine Neuauflage des Buches würde ich mir wünschen, dass zumindest das Kapitel über Communicating Sequential Processes (CSP) anhand von Go demonstriert wird. Vermisst habe ich auch die Erwähnung von MPI (Message Passing Interface). Für eine Neuauflage des Buches würde ich mir auch ein Kapitel über Fork/Join (vielleicht auf Basis von Cilk oder Java) wünschen, allerdings müsste man dann wohl den Titel des Buches ändern.
Aber ansonsten muß man dem Autor zu diesem Buch gratulieren. Es ist ihm gelungen in gerade mal 270 Seiten nicht nur die wesentlichen theoretische Grundlagen, sondern auch anhand von ausführbaren Beispielprogrammen die wichtigsten Concurrency Modelle vorzustellen. Besonders interessant fand ich die Kapitel über GPU Programmierung mit OpenCL und auch das Kapitel über die Lambda-Architektur. Auch dürfte das Buch eines der ersten sein, in dem die Sprache Elixier (im Kapitel über Aktoren) zum Einsatz kommt. Sehr fair zeigt sich der Autor auch bei der Bewertung der Concurrency Modelle. Nach jedem Kapitel gibt es eine kleine Zusammenfassung mit den Stärken und Schwächen des jeweiligen Modells. Daran sollten sich andere Bücher ein Beispiel nehmen. Abgerundet wird das ganze durch eine Übersicht über Themen, die der Autor weglassen musste. Dort findet man Referenzen selbst zu so exotischen Themen wie Grid Computing oder Tuple Spaces.
Lesen Sie weiter... ›
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: 17 Rezensionen
15 von 16 Kunden fanden die folgende Rezension hilfreich
About concurrency, but more about Clojure 6. November 2014
Von Passek - Veröffentlicht auf Amazon.com
Format: Kindle Edition Verifizierter Kauf
It is a little different from what the title suggests - it is supposed to be about concurrency models, and it actually is, but it covers more about Clojure than concurrency models themselves. In other words, this book is mainly about how to use the concurrency models in Clojure (and why some features are/aren't included in Clojure itself). If you are familiar with Clojure, this book would be the best. If you are not, however, you can feel uneasy in many parts of this book, even if you are interested in studying it - though this book covers many features of Clojure, it is not enogh to learn Clojure with this book alone.
6 von 6 Kunden fanden die folgende Rezension hilfreich
Well-done, good pacing, thoughtful and engaging and never dry or dusty 27. Juli 2014
Von Robert Mccarthy - Veröffentlicht auf Amazon.com
Format: Taschenbuch
More than likely you're browsing here and reading reviews because you have some practical experience in software development. And likely that means you've had to slog through some ponderous textbooks in the past, either while at university or when your job has tasked you with a need for some knowledge. Thankfully, this book will never give you flashbacks of those times falling asleep face first into a small puddle of drool in the third chapter of some dusty textbook recommended by your professor.

This is a well-paced, smart, engaging....fun?? (can I say fun in relation to learning?) book that made me feel like I was hanging out with a brilliant guy for a few hours each week who can "talk the talk and walk the walk", so to speak.

There is balance to each of the modules: theory, practice, and self-learning, and there is a tone set very early in the book: (1) here is an idea and a practical analogy, (2) here is what will be taught in the following few chapters, (3) here is a wrap-up with strengths and weaknesses, and (4) here is where you can find more information on this and other relatable topics. In between there are break-out discussions, there are real code samples that make sense(!), there are self-learning suggestions, and there are basic hands-on exercises that (almost) anyone can do.

And all of this is done with a steady, easy pace, mapped out (if you prefer) in calendar time so that its not overwhelming and fits into the busy lifestyles of the very people that should be reading this book...now!

I learned a lot, more than I thought actually, especially because of the use of languages like Clojure and Elixir, which gave me a view of the world of concurrent programming that I could never hope to find with basic Javascript and C. Read the book. Embrace the models. Do the exercises. You'll be a stronger and more intelligent programmer in a matter of (seven) weeks because of it.
5 von 5 Kunden fanden die folgende Rezension hilfreich
This book was fantastic for going through the different approaches 11. Juli 2014
Von Paul Beardow - Veröffentlicht auf Amazon.com
Format: Taschenbuch
I work in communications software and have experience of concurrent programming through Erlang, but needed to extend my knowledge out to other areas of real-time processing. This book was fantastic for going through the different approaches, the pros and cons and gotchas along with insights into low level things that go on inside the VM and operating systems. It's easy to read, but also stretches you. Great book.
7 von 10 Kunden fanden die folgende Rezension hilfreich
An excellent overview of concurrency models 13. Juli 2014
Von Alex Nixon - Veröffentlicht auf Amazon.com
Format: Taschenbuch
I wouldn't hesitate to recommend this text to both new and experienced software engineers alike.

For the former, Paul gives a solid introduction to a variety concurrency models, leaving you with a broad understanding of which technologies exist and their trade-offs.

For the latter, the book shines in its emphasis on practical issues. Practicalities are explored which a more theoretical book would shy away from - such as OpenCL's memory model and Clojure's macro system - leading you to quickly realise that if you want to understand how concurrency tools work in real life and use them to their fullest, this treatment of gnarly details is essential.
1 von 1 Kunden fanden die folgende Rezension hilfreich
Great survey for new learners or for broadening existing experts 11. Juli 2014
Von Freeland - Veröffentlicht auf Amazon.com
Format: Taschenbuch
This is a solid survey of different tools to approach concurrency. It is VERY good at that, but once you've chosen a specific toolkit for whatever problem you are solving now, there are going to be other resources that can help you get deeper into the specifics of any particular model. So I would recommend this book both to anyone beginning with concurrent and/or parallel programming, but also to more "expert" programmers who might already know a couple of the models in depth but want to learn concepts they might borrow from the others---specific languages may, for example, have built-in support to favor specific models, but they can all be adapted to your own environment. So even if you feel comfortable using Java's concurrency tools, for example, you may want to implement MapReduce or Actors for yourself, even though those are "most commonly" associated with Hadoop or Erlang, and so Paul's examples use those. Doing so keeps his example small and focused on the use of the models, but knowing about the model lets you use its ideas in whatever your work environment.
Waren diese Rezensionen hilfreich? Wir wollen von Ihnen hören.