Microsoft Silverlight Books

5 stars are not enough

Simply put, Joe Duffy is a world-wide authority on this topic. I don't just say that based on working with him (his office was 5 offices down the hall from mine), but also based on the conversations I've seen him dominate with other visionaries inside of Microsoft. If you don't take my word for it, just look at how elegant the Parallel Extensions to the .NET framework are that Joe was the dev lead and architect on. If you want to see examples of how clearly he can put his thoughts to writing, just visit his blog (http://www.bluebytesoftware.com/). 5 stars are not enough for this seminal piece of work.

Daniel Moth
21 May, 2009

concurrent programming

good material for beginner and advanced threaded developer. concepts are easy to test compared to other materials on same concept.

P. Marule
24 April, 2009

Everything about concurrency, and then some

This book provides an exhaustive treatment of everything concurrency in .NET and Win32.



It's organized very clearly into multiple sections: Concepts, Mechanisms, Techniques, Systems, and Appendices, and isn't missing a single thing. From background information about the roots of present day parallel algorithms and architecture, to how Windows and the CLR work internally, to higher level application models and best practices, it's all there...



As other reviewers said, this is the only book you'll need on the topic. The competition just doesn't have the broad coverage and incredible level of depth as this one. The book can be daunting at first, mostly because of its size (almost 1000 pages), but I found it surprisingly well written and enjoyable to read. Much better written than most techie books. It took me a few months to finish. I guess the author could have shortened it, but I don't know what content could have gone; the book just wouldn't be as great without every nugget of information that's in there right now. Some of the sections (like the ones on concurrent containers, detailed parallel algorithms like sorting, and memory models) took multiple reads for everything to sink in. I'm still not sure I've absorbed it all, but thankfully the book's organization makes it suitable as a reference too.



The target audience for the book as stated is any .NET or Windows programmer. Realistically, it's best for senior architects and developers, but could also be used to teach a university course or be read by less experienced developers too. I actually ordered copies for my whole team of 30 developers, all ranging in seniority, and it's basically required reading at this point. The author makes the point that concurrency is everywhere, and it's true. So the book isn't only for advanced new-age parallel programs on multi-core, but also server-side programming (web, app, SQL, map/reduce, data mining) and web apps. Really, everybody needs to know this stuff to be taken seriously. I've started using lots of these topics as interview questions.



What's best, the book is written by a Microsoft guy who runs the team building new concurrency APIs in .NET and Win32 today. (See his blog at http://www.bluebytesoftware.com/blog/ -- there's even a sample chapter there.) This gives the book far more authority than any other on the topic. I've downloaded CTPs of the .NET 4.0 parallel extensions (really amazing stuff), and the book demonstrates in detail how a lot of it is built. There's even an appendix covering the new APIs, so not only does it help build real parallel applications today, it also shows what's coming down the road.



In summary: A fun, enlightening read! I'm actually considering rereading the full 1000 pages again come this summer...



DEH
02 April, 2009

A must for any Windows developer

Multithreading programming is hard and requires a lot of knowledge of the various platforms and a lot of concentration. This book provides a very complete and dense picture of what means multithreading in Windows, elegantly covering both managed and native code. This is definitively a book for programmers, who are eager to not only understand how but also why.

P. Greborio
05 March, 2009

One of the best books on the topic

I'll split my review into 3 parts:

Know what you get (book's goals): 4/10. The book is a bit "all over the place". It's hard to understand the intent of the book -- it's a bit too theoretical for a "pragmatic concurrent development" that it claims to be which makes the entire book a bit fuzzy and way too long. The problem with this kind of books that you usually can't read all (reading 800+ pages is too much for most people) and you're afraid of missing important parts.

Coverage: 9/10. This book is a great "ref" book in my bookshelf, it explains high level architecture to very deep bits&bytes usage in a very readable fashion. I've got a list of pages that I recommended every one of our developers to read, starting from basic things and dive into data structures, interesting pitfalls and solutions and specific tips & tricks that I found very interesting during my reading.

Relevance: 10/10. This is a must have book for windows developers (especially for .Net developers). It contains crucial basics with an amazing list of examples and best practices (need to be pulled out carefully, but it's there).

I'm still missing a well organized "common concurrent pitfalls & solutions" chapter for the pragmatic developers (assuming that the background exists).

All in all, I highly recommend this book! nice work!

Oren Ellenbogen
04 March, 2009

The definitive reference

No need for any other book about concurrent programming on .net. This book have everything you need to become a master in multi-thread programming on Microsoft .net framework. A must have!

Christiano C. Moraes
10 February, 2009

Get it! Read it! Enjoy it!

Concurrent Programming on Windows (Microsoft .NET Development Series)
I think this book is probably the most important book on concurrent programming on Windows since Pham & Garg wrote their book way back when the world looked quite a bit different. I think this book exhibits the right combination of theory that puts you back on the bench in school and the practical implementations that bring you back to the real world. I have been using this book both as a reference type book and as a means of satisfying my curiosity.
I think any developer that has intentions of writing serious, performing and scalable code for Windows will want this book as his/her best friend. Your copy will be used so much that it will be able to open itself by it self.

Boaz Lev
07 February, 2009

Concurrency Master

I follow Duffy's blog posts on concurrency and find it exceptionally informative. I haven't read the book, which I plan on purchasing in the future, but I believe that much of the content is a compilation of his articles that I have read in MSDN magazine and his blog.

Not only is Joe the Developer knowledgeable about the subject, but he works on concurrency libraries at Microsoft and is a leading thinker, affecting the future of concurrent programming.



Wesner Patrick Moise
29 January, 2009

Disappointing

I really wanted to like this book, but in the end I couldn't. It seems to me to be at least twice as long as it needs to be, extremely poorly and confusingly written, and a mish-mash of random odds and ends. I don't think the author has really worked out who his target audience is. Is it people who have a serious interest in the logic of concurrent programming - in which case you'd be better off reading the original papers by the likes of Dijkstra and Hoare, or the much much shorter book by Ben-Ari? Or is it aimed at people who want to write concurrent programs that work on Windows? In which case you'd be better off reading the much shorter book by Beveridge and Wiener.
Proof-reading and quality control is shoddy. For example, I have the distinct impression that at some point some-one has done a global replace of "task" with "thread" in the text, resulting in jibber-jabber such as "though it's highly unlikely that anybody reading this book will have to take on such a thread" on page 60, to cite one example out of several that I noticed.

Winston Kodogo
27 January, 2009

Must have book for anyone doing concurrency on Windows.

While there are many books on the mechanics of threading and synchronization this is the first book I have found that brings together the paradigm of parallelism and the mechanics of how that is supported for Windows. I especially appreciate the insights Mr. Duffy provides regarding the workings of Windows thread pools.

D. Long
14 January, 2009

Wow! A must read

I am not yet done reading the book entirely. However, it contains so much wealth of information, one can study each chapter for a month. Overall, the book gives enough overview for anybody embarking to use parallelism within software development. This book is within ranks of Windows Internals!!!

Roman Rozinov
12 January, 2009

Right mix of theory and practice with lots of Win32, Vista, and .Net API Usage examples

This book has just the right mix of theory and practical advice to help one learn how to write safe and reliable concurrent applications for the Windows Platform. It is organized into five parts. Part One consists of two introductory chapters on program state management concepts such as synchronization etc. Part Two discusses mechanisms available in the Windows Platform to support concurrent programming: from heavier-weight kernel objects such as Mutexes and Semaphores to lighter-weight and higher-level abstractions such as Monitors, Thread Pools, and Asynchronous Programming Models. Part Three delves into concurrency hazards (e.g., race conditions, deadlocks) to watch out for and data structures (e.g., parallel containers) and techniques that one can use for certain kinds of problems. Part Four culminates in detailed discussions of asynchronous mechanisms for dealing with potentially expensive I/O and GUI operations. Finally, Part Five consists of two appendices: The first appendix pulls together in one chapter all advice and recommendations mentioned in the book as well as additional guidelines for writing safe and reliable concurrent applications, and the second appendix briefly discusses the Parallel Extensions to .Net library. Although the author is more of a .Net expert, he gave roughly equal attention to Win32, Vista, and .Net APIs. The book provides a lot of code samples, which according to the author, would be available for download from the book's related website: http://www.bluebytesoftware.com/books (as of Dec. 18, however, this has not happened). Overall, I think the book is very well written and explains a lot of difficult concepts very well.

Techie Evan
18 December, 2008

Essential

Make no mistake about it, Joe's book on concurrent programming is essential reading for any Windows developer planning on continuing to code for work and pleasure over the next 10 years. If you're learning parallel programming on Windows for the first time, or have been practicing it for years and *think* you know all about it then this book should high up your `must read' list. Joe's official position at Microsoft enables him to write with real authority and a sense of `rolled up sleeves engineering' on the subject. Personally speaking this is a book I will asking about in future when interviewing developers. Let's face it, when a book opens with praise from Chris Brumme you know you're in for an enlightening engineering read.

T. Kirby Green
30 November, 2008