Customer Reviews

Parallel Programming with Microsoft .NET: Design Patterns for Decomposition and Coordination on Multicore Architectures (Patterns & Practices)

5 star:		(3)
4 star:		(1)
3 star:		(0)
2 star:		(0)
1 star:		(0)

 

 

This is a book of patterns that achieve potential parallelism. It is very important concept that all developers should have a decent grasp on. The patterns teach you how to write programs that run faster when parallel hardware is available and about the same as an equivalent sequential program when it is not.

The book starts with an introduction to potential parallelism, tasks, coordinating tasks, shared data, and the limits of parallelism. It then has a chapter on each pattern which include Parallel Loops, Parallel Tasks, Parallel Aggregation, Futures, Dynamic Task Parallelism, and Pipelines.

It continues with some awesome appendices- Adapting Object-Oriented Patterns, Debugging and Profiling Parallel Applications, and Technology Overview. It ends with a nice glossary, references, and indexes.

The book does a nice job of giving examples in PLINQ (Parallel LINQ) and TPL (Task Parallel Library).

There is a great companion site located on CodePlex. You can download Answers to end of chapter questions, C#, F#, and VB code samples, Appendix B Color Figures, and a nice demo application.

The book is very well written and the authors do a great job of making what would seem like a complex topic easy to understand.

The thing I like most about this book is that there is no fluff. The book is all about getting you up and running, but up and running the right way with the right tools.


This book is a must read for anyone considering moving into parallel programming with the .NET framework.

This was a relatively short read, and packed with best practices, examples, and further reading. It's hard to imagine a quicker way to get up to speed on the basics of parallel programming using the .NET 4.0 features. This book was so good I thought I'd check out another "patterns and practices" book from MS; their Prism 4 book. The advice on AgggregateException handling alone is worth the read, but there is so much more. I've been writing software since the 80s, and I'll rate this as "Highly Recommended".

I have to admit that I was disappointed in the book not covering .NET multi-threading outside of of the PCL library. It would have been nice to have some notion how to do parellel programming outside of the .NET 4.0 framework (which was why I bought the book). There were no design patterns to speak of that did not deal with PCL or PLINQ. It was, however, useful in understanding what is possible in .NET 4.0 and what the general layout should be used for various situations for parellism. I initially had troubles digesting the functional programming associated with PLINQ. It took me a bit to grasp what was going on. I must admit, however, that once I got an idea of the syntax of LINQ and PLINQ, the utility of PCL became clear, not just in the book's limited context but for parellism in .NET in general. Once I got over the hurdles, this quickly became a 4-star book. Once I get to .NET 4.0, I look forward to using PCL and PLINQ, and this book is a great introduction.

Parallel Programming with Microsoft.net: Design Patterns for Decomposition and Coordination on Multicore Architectures offers programmers using Microsoft.net a fine collection of proven patterns and practices for blending into any project. Quality source code and documentation are developed for software development teams using parallel programming and offers proven keys to frequently used patterns. Technical computer collections need this!