Customer Rating:  
Summary: Useful book!
Comment: This book is centered around a Simplied Application Framework (SAF) consisting of some domain specific components (exchange and processing of business components) and some more or less generic components (configuration, event notification, etc.). Each of these components is discussed in detail and explained with code samples which can be downloaded from the publisher's website. Various .NET concepts like Remoting and Reflection are discussed at the components where these concepts are exploited. The design patterns from the book of the GoF (Gang Of Four), 'Design patterns, Elements of Reusable Object-Oriented Software' are extensively used throughout the book. It gives some practical applications of these patterns and that's what I liked most about it.
A minor point is that the source code contains some spelling errors and a naming error (The Visitor class of the Visitor pattern has a method named 'Accept' method, whereas its obvious that the method should be named 'Visit') which is a bit disturbing, although the source code will probably still compile ;-) Despite of this I recommend it for both software developers and architects.
Customer Rating:
Summary: Very helpfull
Comment: This is not only helpfull for architects, but for programmers responsible for planning and scoping projects in general. The writing is to the point, and provides very solid foundations for writing high level framework strategies. The only thing lacking would be that I think it is geared toward 1.1 framework, would be great to see how 2.0 could enhance this. The frameworks in the book are great starting points which can be enhanced based on your own business requirements.
Customer Rating:
Summary: Good for beginners
Comment: The problem with this book is that SAF, the sample framework, is a toy just for demonstration purpose. The book gives insight on why and how to construct a framework, very good in this aspect, but it doesn't give you a real framework you can adapt or use.
What's is the point of writing your own framework from the base, if frameworks are supposed to be so generic that can be used in disparate applications, a framework written by a real expert would be good for you too, or at least an excellent starting point.
I think a really useful thing would be a open source project, community supporting and a book.
Lhotka does something like that, but his framework is focused in implement a configurable dataset, very good, but frameworks have lots more aspects.
This book teach the basic well, .net technologies, gof patterns with examples. A must read for beginners, not very useful for more advanced people.
Customer Rating:
Summary: Interesting
Comment: I have been developing application frameworks for several years. This book is a good read about them. It covers many of the issues related to application frameworks including class factories, configuration and security. Each chapter contains information about the 'theory' related to these topics and information about the .Net implementation. I learned about .Net classes I was not aware of.
Although I recommend reading the book, I want to warn potential readers about two issues:
- The book ignores some aspects of application frameworks. Missing for example is logging, which is very important in practice. Users of your framework will want to monitor it and logging will be an issue you have to deal with.
- Sometimes the author is more concerned with showing a clever implementation than a practical one. I find the hierarchical cache interesting but in practice there are bigger issues: how efficient is the cache (creating the xml document seems a performance killer), how are cached elements evicted (this brings issues about timing and locking that are ignored in the book), etc. Similarly, I have rarely seen the need for all the configuration-based customization that the author shows. I would have appreciated if each chapter discussed the goals of the implementation (e.g., performance vs. ease of use) and its trade-offs.
I recommend the book but think twice about your goals before copying the implementation.
Customer Rating:
Summary: Overall Good Reading
Comment: As one would say that mere coders think in terms of ad-hoc one time solutions while developers and software engineers think how to incorporate these best practices in the form of an application framework. Xin Chen has done a good job explaining big picture thinking i.e. how a set of libraries or classes that are used to implement the standard structure of an application are made to collaborate in the form of a reusable framework.
I'm personally a big fan of application frameworks which provide extensibility along with good foundation support for example Rocky Lhotka's CSLA (Component-based Scalable Logical Architecture). Xin Chen does the similar job building one chapter at a time. He is walking the reader through step by step building of the framework and keeping the big picture in sight. The book is divided into 15 chapters in which Xin elaborates on application frameworks, dissect them, discusses class factories, caching, configuration, windows services, message queuing, authorization, authentication, cryptography, transaction, document layer and work flow services. The author has high degree of familiarity with GOF design patterns so reader will see the degree of reusability and patterns & practices in action. Application event logging and exception handling is an inherent part of any application framework however I was disappointed to see not much discussion about it in the book. Also, during the discussion of real world business problems, author did not discuss rules engines or provide guidance about integrating dynamic logic into your framework which I strongly feel should be an integral part of an enterprise level architecture. The current business models as we know them thrive on change and we cannot isolate development designs from user's needs.
Having said that, if you are looking to build a large amount of reusable code into a framework to save development time for yourself and fellow colleagues / developers, this book will provide you enough good pointers for this purpose. Author recognizes that the frameworks cannot be built in the air and hence provided us with concrete examples. I'll also recommend reading "GOF Design Patterns", Rocky Lhotka's "CSLA.NET 2.0 (Expert C# Business Objects)" and "Framework Design Guidelines: Conventions, Idioms, and Patterns for Reusable .NET Libraries" along with this if you are serious about developing application frameworks for your enterprise.
|
|
