Seven Concurrency Models in Seven Weeks: When Threads Unravel (The Pragmatic Programmers)

This book is a concise and clear picture of the major options available to solve problems of concurrency. Today if you want to understand computing solutions that tackle the toughest problems you need a clear picture of what really work. This book is an excellent navigator regarding the choices programmers faces at the beginning of inspiring data projects.

I find this a worthy high-level treatment of concurrency and parallelism using some modern languages. The author seems most comfortable in the Functional Programming world, and lots of the examples are in Clojure. Be aware of that going in.I led a book club at work through this book, and let me first say: Don't Do that. As with the other "Seven ____ in Seven Weeks" titles, interest is high in the beginning, then wanes and the last few chapters are just a slog. This isn't the book's fault; the structure isn't well-suited to a brownbag format where people might miss a chapter.Further, as noted on the rear cover, this is a book targeted at experts. You should be well-versed in sequential programming and able to teach yourself new syntax quickly.All that said, the book's a great broad + deep dive into topics. For me, I was well versed in Threads and Locks, and aware of Actors from Elixir/Erland, but the FP stuff and GPU programming was wholly new and considerable fun. Elixir was a great choice for the Actors chapter, and Clojure is a wonderful LISP dialect which runs in most places consistently thanks to the JVM underpinning.For the second edition, I'd consider using #golang for the CSP section, since that's Go's and the syntax is ALGOL-like.In sum this a great book, sure to teach you SOMETHING you didn't already know.

Very readable and pleasant compared to other material on the subject that I have found. I found it to be an excellent introduction. The scope is well-constrained, as well as the depth of each subject.

Good book

I thoroughly enjoyed this book, I highly recommend it to any serious developer.

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.

I thought this would be a good book about java threading - or generic design - but it's caught on clojure and other niche languages - although i guess if you are really concerned about parallelism - those would be the languages you would use

so interestinga must to have!

Ho comprato questo libro perché sto cercando di comprendere a fondo le differenze tra parallelismo, concorrenza e asincronia. Qui si parla di almeno sette implementazioni di modelli che costituiscono un mix di questi concetti, a partire dal più classico e rischioso, thread e lock, che a quanto pare ha più problemi di quanto credessi. In realtà in alcuni capitoli ce n'è più di una, e dico implementazioni perché spesso il diavolo è nei dettagli... e il libro non lo nasconde, purtroppo.L'autore, è chiaro, sa un sacco di cose su questi argomenti, e il compito di riassumerle in meno di 300 pagine è arduo. Il ricorso a più linguaggi è obbligato, e quindi anche se per tre volte su quattro si tratta di Clojure pazienza: sarebbe stato peggio doverne imparare anche altri (tipo Go o Rust - che al tempo non esisteva!).Questo forse è anche il problema principale: l'approccio pratico. Ad esempio, Clojure è un linguaggio insolito ed è molto facile venire distratti dai dettagli. Suggerisco di prendere un po' di confidenza con i linguaggi prima di affrontare i relativi capitoli. Generalmente, preferisco chi mi spiega i concetti in maniera diretta (visto che anche in questo libro sono ripetuti in diverse soluzioni, v. map/reduce...). D'altro canto, sono sicuro che le cose che ho provato davanti al PC le ricorderò meglio (per Clojure, consiglio VSCode+Calva).Ci ho messo molto più del previsto a leggere questo libro, ho praticamente saltato il capitolo sulle GPU e ad un certo punto ho smesso di provare le cose, o non ne sarei più uscito. L'incontro con Clojure è stato forse il risultato più interessante, superate le resistenze.In generale, qualcosa di più chiaro di prima ce l'ho. Onestamente speravo meglio, ma riconosco che è probabilmente uno dei libri più difficili da scrivere che ho letto. Forse più in là, rileggendo più velocemente, ne trarrò di più.

Está excelente, aprendí mucho, muy recomendado para todos los que quieran aprender nuevos paradigmas de programación concurrente, inclusive el capítulo de hilos está muy bien presentado, es muy práctico y te ayuda a entender los beneficios de cada modelo de concurrencia.

Nice book. A good read.

An excellent book for experienced software engineers and newcomers alike. The examples are detailed enough to serve their purpose without getting too bogged down with implementation details which would slow the pace of the book. The concurrency models are explained clearly and concisely. Personally I would have preferred the CSP chapters to use Go (they use Clojure with core.async) but this is a book about concurrency not languages so that is irrelevant.If you are looking for an overview of the tools and techniques available now for building concurrent systems this book is for you.

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.Alles in allem ist es ein sehr wichtiges Buch, gerade weil es nicht nur die Stärken sondern auch die Schwächen der jeweiligen Concurrency Modelle diskutiert und man nach der Lektüre besser einschätzen kann, wann man ein bestimmtes Modell einsetzen sollte und wann besser nicht.