Customer Reviews

Programming Microsoft Composite UI Application Block and Smart Client Software Factory (Pro-Best Practices)

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

 

 

Holly smokes!!!! I have never owned such a thin book with so much white space on the 199 pages that are there. I would estimate removing all the white space would bring this book down to about 120 to 150 pages.

This book does not do what I had hoped for. I posted in my blog that I was hoping for insight that did not already exist, and that is not the case. This book is a high level overview of the CAB and SCSF. The material that is there is good. The problem is there just isn't very much material, and what is there is not in depth.

I was nervous about the description of the book because it described the book as a learning workshop style of writing, but ordered it because it was written by David S. Platt. He has written some good books in the past.

I gave this book 2 stars out of 5 because if you don't want to weed through all the help documentation on the CAB and the SCSF, this book will give you a nice overview of what is available. But to get down and dirty you will need to refer to the help documentation.

This book should have been a free download labeled "CAB and the SCSF Hands on Lab".

Of course they would have to complete the code samples, which currently are labeled under construction on the author's book download site.

It irks me to say it but this book is essential.

I must quickly add that this book is also an incredible disappointment. The other reviewers in this space are 100% correct and justifiably outraged. You will not learn much at all about programming CAB. This book deserves no better than 2 stars; it deserves zero stars.

However, the fact remains that there is no other CAB book. It is a breezy read, passably accurate (as far as it goes), and there simply is no other orientation to CAB/SCSF as good as this one.

Damn faint praise. But be honest: the CAB/SCSF help files are awful, Mario Szpuszta's white paper is a free, wonderful tutorial - but it doesn't cover the core components, and the Wiki + web-based commentary are a grab bag of point topics that presuppose general CAB knowledge.

The discussion board is full of remarks like "Hi - I'm a novice and I've read all the help, and done all the labs, yet I can't make any sense of CAB. Can someone help me?" Well, Platt is for those folks. We who think CAB is fundamentally good architecture must be grateful to anyone who can make it approachable and intelligible. Platt succeeds in doing that much.

Sure, Platt seems to have phoned this one in - the pages look like slightly warmed over copies of his lecture notes - and he could have delivered this .. this .. this pamphlet .. a year ago - but it is (sigh) still the best orientation available.

Therefore, I have to urge anyone who is considering CAB or learning CAB to buy this book. It won't be the worst $25 you ever spent.

I was looking forward to this book being published as there really isn't very much documentation available for either the Composite UI Application Block or the Smart Client Software Factory. Microsoft's own documentation is quite weak, and to use these technologies you find yourself repeatedly referring to the code itself or community blogs and websites.

However I have to say Platt's book isn't the answer to these problems. Firstly it's very short. It's true that there are nearly 200 pages, but there's a lot of white space, big diagrams and padding throughout the book. The CAB/SCSF is now quite a large and complex piece of software and inevitably Platt can only skim the surface of the technology in such a short book.

Secondly Platt makes no real attempt to explain some of the core concepts behind the CAB/SCSF. For example, the CAB uses dependency injection and DI containers heavily, and many Microsoft developers will not have met these concepts before. Platt makes no real attempt to explain what these things are and why we might want to use them in a smart client application. This is also a criticism that can be levelled at the Microsoft documentation. Platt is better on why we might use the CAB to achieve loose coupling between parts (`modules') of a smart client application. But in general developers coming to the CAB struggle with the concepts more than the code and Platt has focused heavily on the code.

Thirdly Platt is quite selective on which parts of the framework he covers. For example there is a chapter on the Action Catalog, which is quite an esoteric part of the SCSF technology. However there's no real discussion of WorkItem State, which is a much more core concept and causes a lot of confusion. The Action Catalog is just one of several new services in the latest SCSF, and Platt doesn't discuss the others in the same detail (e.g. WorkspaceLocator, EntityTranslator).

On the plus side the book is an easy read, and it does have a strong introduction where in 30-odd pages Platt gives a good initial overview of the subject. On the subjects he does cover Platt is factually accurate and informative. Having read the book I do feel I have a better understanding of how the technology works.

In the absence of any real alternative, and given that it is quite cheap, this book is worth purchasing for a quick read to give you a selective overview of the subject. Hence I've given it two stars. But it is too short and unfortunately it's far from being the definitive guide I was hoping for.

The anticipation for the book was quite high by me and my team. We are building an application on this complex yet flexible framework and have been searching for complete, robust documentation for the last 6-7 months.

Unfortunately, this book is no better than the downloadable "Designing Smart Clients Based on CAB and SCSF" paper by Mario Szpuszta (and that was just a light architectural white-paper!). Between that paper, the included documentation and walkthroughs, and the SCSF website, this book becomes superfluous.

Save your money and wait for something with a little more meat than 200 pages of half-filled pages.

Wow, what a surprising let down this one was. I have been waiting since this book was announce (prior to publishing). I had hoped it had more concrete examples, some more thorough indexing of relevant topices (like inheritance, base views etc), how do deal with web services and disconnected services.

DON'T BUY THIS BOOK. Mine's going camping with me to start the fire-pit!

David's book provides a necessary foundation for anyone wanting to become proficient with CAB programming. Unless you are already an experienced CAB developer or are looking for low level CAB framework details, this book will be of great benefit. A real asset in helping you understand the complexities of CAB, the SCSF and get you started toward successful CAB development.

Its not a bad book but its not exactly what I was looking for. Having said that there are not many books telling you what this does, so it becomes a must buy.

Many of us who are developing applications using CAB/SCSF could use a comprehensive "How To" book on this topic. Unfortunately, this book didn't sieze the opportunity to deliver such a book. There is *some* good information in the book, and the Introduction chapter nicely whets the appetite. Unfortunately, the rest of the book falls far short of providing the necessary guidance and examples to make it truly useful. There is certainly enough information in CAB/SCSF to fill a book with at least twice the content of this one. It makes me wonder whether the book was rushed to market or whether the author and editors just lacked the will and fortitude to write the type of book that this could have been.

If you are looking for a 3k page bible on SCSF and CAB, move along partner, because this ain't it.
If, however, you have been wanting to work with SCSF but couldn't find a good starting point, this is your book. If you've heard the alluring call of SCSF's decoupled architecture and want to get your feet wet, this is your book. If you've done The Walkthrough and found that you still didn't understand what it really *meant*, this is your book. If you are developing in the SCSF but want to read about pitfalls, tips and tricks from someone who has already traveled that road, this is your book.
This book begins top down by explaining the decoupled architecture and its benefits. It then dives down a level and explains how the WorkItems, Collections and Services work together to enable the decoupling. Finally it dives one more level and hits upon some key Services, Event Brokering, Action Catalog and some of the other "big" pieces of SCSF. At key points you get prudent advice about how real products are using SCSF features in deployed applications in the real world.

To summarize: If you are already an SCSF god, there is nothing new here for you. If you are an SCSF neophyte, this book is a worthwhile read to shortcut the SCSF learning curve.

I found this book to be well worth the money. I guess it depends on where you are coming from regarding the Smart/Mobile Client factories. I started work with the MCSF a number of weeks ago and had worked out a fair bit of it, but there were a lot of holes in my knowledge. This book filled in many of those holes.

As other reviewers have said, the official Software Factory documentation. code examples and white papers do not give the whole picture. Neither does this book, of course, but IMHO it supplies a valuable part of the jigsaw.

For example, if you read the code examples supplied and available on the net, some use WorkItems and others WorkItemControllers. Nowhere could I find an explanation of the differences or why you would use one over the other. David's book clearly explains the history as to how they started with WorkItems and added WorkItemControllers when real world experience found that WorkItems were outgrowing their original purpose. There are other similar examples where his experience with the product supplies valuable information available nowhere else.

I even appreciated the layout. David's explanation as to why he chose this style of presentation made sense to me both before I started and after I finished reading the book. Yes, there is a lot of white space but its a very readible book. I have bought other, much longer books and have never gotten around to reading every page for one reason or another. I read this book from cover to cover in a week of train journeys to work. In fact the layout encourages you to read it in bite-sized chunks like this.

There is certainly a need for more detailed documentation and David shows in this book he has the knowledge and experience to write an advanced tomb on this very topic. Perhaps then he will be able to please everyone.