<< 1 >>
Rating: 
Summary: Traditional data patterns with Object oriented programing
Review: First of all this book is not about object relational mapping (ORM) strategies or patterns, the author provides a pattern that is the interface to a object relational mapping layer and that's it. This book is about traditional input output strategies to relational databases i.e. the layer under the object relational map if you were to build your own. However, if you were to build the data access object with traditional stratergies to the relational database you could use the patterns in this book, especially the cashing patterns which are sophisticated. I find the other patterns in connection pooling, I/O and transactions customary and should be known to most intermediate plus architects or programmers. The book is well documented in the UML with clear writing, good examples (case study) using Java JDBC. The patterns are generic, could be used in both .Net and J2EE. A fourth of the patterns come form Core J2ee or Fowler books.
Rating: 
Summary: Not good enough.
Review: Having read GoF's "Design Patterns" and "Design Patterns Smalltalk Companion" in the series, I grabbed this book as soon as I see it in store. But this book leaves a lot to be desired.There seems to be the problem of having patterns just for the sake of having patterns. For example, why do you want to make queries and database updates into factories? Looking at the sample code, does it really help decoupling? To reviewer zhanggoo> The basic idea of "design to interface instead of concrete implementation" of course is always correct. I actually took the time and tried out the sample code of "input and output patterns" and got those working. However, you must realize that these patterns need a lot of re-thinking, redesign and refactoring once it's outside the realm of toy examples - How to handle domain object or selection criteria based on multiple-table-join (very common)? How to handle database generated identity? What if there needs to have a couple of selection factories for one domain object? Not to mention these patterns are all based on SQL string manipulations, static typing of the parameters all lost. How come you can only get the first page from the "Paging Iterator"? Besides giving hints to JDBC, the pattern gives no control over the rows actually returned from the database. The "Cache Patterns" does not solve the problem of preventing stale entry or even attempt to describe how to invalidate cache entry, so no matter how efficient you get, the cache is not guaranteed to be up-to-date /correct. To reviewer zhanggoo> The author only talked about cache expiration - purge cache entry to enhance performance, but not invalidation (to prevent cache from getting inconsistent). Experienced database developer knows that query tuning is the first thing to look at to improve performance, one should take advantage of db server cache and app server cache as much as possible, as a last resort when you really need to roll your own cache, you need to make sure you get it right. I'm surprised "stored procedure" is not mentioned at all. To reviewer zhanggoo> There're certainly different opinions on "stored procedure". SP is definitely not OO, RDBMS is not OO at all - as long as you're using RDBMS, you have to face the fact that OO cannot be applied everywhere. On the other hand, SP helps greatly in decoupling, since query logic are not embedded in java code, app code and db code have clear interfaces, query optimization usually is easier to do with SP. These are good practices and patterns in my book. The overall organization and format of the book is good, but for experienced database application developers, you might learn more by studying mature object/relational frameworks like EOF (Apple WebObjects) or TopLink.
Rating: 
Summary: Good design pattern book in data access !!
Review: I am in the process of writing a thesis proposal that utilizing JDBC and TableModeler to access various database platforms as a prototype. While prototyping the model, I encountered a lot of consideration of what is the best approach for certain implementation (mainly on JDBC). While looking into a few of designing books, I found this Data Access Patterns book that fits into my research needs. I have read other book such as Designing Flexible Object Oriented System with UML and not able to apply the concept or see solution in it. It is simply a conceptual book. No practical examples at all. Mr. Nock has explained the design patterns very clearly in each chapter by using JDBC as a media. The examples are very easy to understand as compared to Design Patterns Explained. I am not able to understand codes that implementing graphics in that book. Mr. Nock addressed the pros and cons of the patterns. Many techie books do not even bother to talk about pros and cons. The author has chosen the right title for the book, I realized that many times author received a poor rating because reader expect different contents based on the title of the book. The feature I liked the most - the ¡§Applicability¡¨ section on each chapter. Unlike other patterns book, the author explains the concept and gives example of "what" and "when" to use certain design pattern. This section is pretty much the answer for my thesis obstacles. The answer is in this book!! Minor typos do exist such as in page 390 roll back instead of rollback. In concurrency chapter, author may have mis-used the term of updates locking. It should be Lost Updates instead of Missing updates. Concurrency chapter looks like UDB Lock Concurrency architecture. Additional note - would like to see the quality aspect in each of the patterns. Overall, the book is very well structured, explained and thoughtful. Thank you Mr. Nock !! This is a perfect book for my thesis. Looking forward to read your future publish. Regards, EQ
Rating:
Summary: Excellent and Easy To Read
Review: I have to disagree with the previous review. I will try to explain why I think 'b88zhou' review is inadequate after presenting my overview of this book. After reading numerous pattern books, it is nice to see a pattern book with very good organization. Each pattern is presented with the following subsections. * Description
* Context
* Applicability
* Structure
* Iteractions
* Consequences
* Strategies
* Sample Code
* Related Patterns and Technology. I specifically like 'Consequence' section because it outlines the 'bad' consequence of adopting the patter. This goes with the mantra of design patterns - there is no one good pattern. You trade off one design for another depending on the context of your domain. Also each pattern is accompanied by UML class diagrams and UML sequence diagrams - this is a big plus in understanding pattern. The sample code is written in Java/JDBC so you may need to understand Java but I believe this pattern is still relevant to ADO.NET and C++. [ ADO.Net does offer connected and disconnected database operation so some patterns may not be relevant - plus, event/delegate will aid in some patterns.] Specific to what the previous reviewer say - here are my rebuttals. >> Why do you want to make queries and database updates into factories? Looking at the sample code, does it really help decoupling? The previous reviewer mentioned as 'factories' is the derivation of 'AbstractFactory'. If you do not understand why AbstractFactory aids in decoupling from the concrete implementation, I think you should re-read GoF book. The author uses AbstractFactory pattern extensively in context of "Input and Output Parameter" and "Cache Patterns". I do admit that sometimes "Input and Output Parameter patterns" may not need to use AbstractFactory but if you read 'Domain Assembler' pattern you will understand why. From Domain Assembler, you can see the benefit of having AbstractFactories for Selection, Domain Object, and Update -- assembling all these factories via interface not concrete implmentation - a basic idea of design to interface instead concrete implementation. >> The "Cache Patterns" does not solve the problem of preventing stale entry or even attempt to describe how to invalidate cache entry, so no matter how efficient you get, the cache is not guaranteed to be up-to-date /correct. Please re-read 'Cache Collector'. The pattern could have different name like 'Cache Garbage Collector'. He talks about how you can 'purge' old data. Also re-read 'Cache Replicator' for how to sync the cached data in distributed system. >> I'm surprised "stored procedure" is not mentioned at all. I guess you have not done too many DB oriented projects. The stored procedure is evil and add little value to OO programming. But if you want the stored procedure, just replace 'SELECT' or 'UPDATE' statements to whatever stored procedures you want to call. So I don't think you can add much with SP. >> mature object/relational frameworks like EOF (Apple WebObjects) or TopLink This book is not about Java Data Object or OR mapping. Object-Relational mapping tool is another beast. I would recommend this book highly to anyone doing DB application development.
Rating:
Summary: Excellent and Easy To Read
Review: I have to disagree with the previous review. I will try to explain why I think 'b88zhou' review is inadequate after presenting my overview of this book. After reading numerous pattern books, it is nice to see a pattern book with very good organization. Each pattern is presented with the following subsections. * Description
* Context
* Applicability
* Structure
* Iteractions
* Consequences
* Strategies
* Sample Code
* Related Patterns and Technology. I specifically like 'Consequence' section because it outlines the 'bad' consequence of adopting the patter. This goes with the mantra of design patterns - there is no one good pattern. You trade off one design for another depending on the context of your domain. Also each pattern is accompanied by UML class diagrams and UML sequence diagrams - this is a big plus in understanding pattern. The sample code is written in Java/JDBC so you may need to understand Java but I believe this pattern is still relevant to ADO.NET and C++. [ ADO.Net does offer connected and disconnected database operation so some patterns may not be relevant - plus, event/delegate will aid in some patterns.] Specific to what the previous reviewer say - here are my rebuttals. >> Why do you want to make queries and database updates into factories? Looking at the sample code, does it really help decoupling? The previous reviewer mentioned as 'factories' is the derivation of 'AbstractFactory'. If you do not understand why AbstractFactory aids in decoupling from the concrete implementation, I think you should re-read GoF book. The author uses AbstractFactory pattern extensively in context of "Input and Output Parameter" and "Cache Patterns". I do admit that sometimes "Input and Output Parameter patterns" may not need to use AbstractFactory but if you read 'Domain Assembler' pattern you will understand why. From Domain Assembler, you can see the benefit of having AbstractFactories for Selection, Domain Object, and Update -- assembling all these factories via interface not concrete implmentation - a basic idea of design to interface instead concrete implementation. >> The "Cache Patterns" does not solve the problem of preventing stale entry or even attempt to describe how to invalidate cache entry, so no matter how efficient you get, the cache is not guaranteed to be up-to-date /correct. Please re-read 'Cache Collector'. The pattern could have different name like 'Cache Garbage Collector'. He talks about how you can 'purge' old data. Also re-read 'Cache Replicator' for how to sync the cached data in distributed system. >> I'm surprised "stored procedure" is not mentioned at all. I guess you have not done too many DB oriented projects. The stored procedure is evil and add little value to OO programming. But if you want the stored procedure, just replace 'SELECT' or 'UPDATE' statements to whatever stored procedures you want to call. So I don't think you can add much with SP. >> mature object/relational frameworks like EOF (Apple WebObjects) or TopLink This book is not about Java Data Object or OR mapping. Object-Relational mapping tool is another beast. I would recommend this book highly to anyone doing DB application development.
Rating:
Summary: Great book on persistence theory
Review: I'm in the middle of developing yet another persistence framework for a client, having done it a couple of times before. Each time I refine my ideas about how to do it. I must say that this book has a thorough examination of issues and certainly food for thought as well as answers to a couple of questions I've had. However, I wouldn't say it's a complete design (which it doesn't claim to be). I still found myself picking and choosing which patterns to use as is, which to modify to my liking, and which to discard. Also, I was left with the impression that the book didn't give enough coverage to handling collections of objects. The material is mostly geared toward working with a single object, which is understandable. I just think it would have been helpful to have more discussion about handling collections. For example, what should happen when you request to load an object, but the criteria you passed to the loading mechanism results in data for more than one object being retrieved from the database? Hand back the first object? Raise an exception? If it's covered in the book, I missed it. Further, I would like to see more discussion about WHEN to refresh an object from the underlying database and when to save to the database. I always struggle with that timing issue. Having studied EJB, I like how entity beans keep your bean in synch with the underlying database. But the EJB container intercepts calls and makes those things happen. When coding the persistence layer myself, that's not an option. So, again, this is something I'd like to see some light shed on. Overall, though, a great book if you're interested in reading up on persistence layer patterns.
Rating:
Summary: Useful patterns and interesting concepts
Review: The book presented 25 patterns grouped in 5 areas, decoupling (conceptual and architectural level), resource, input/output, cache and concurrency.
The most interesting patterns are in resource and cache. Decoupling and concurrency patterns (e.g., data accessor, active domain object, layers, transactions, optimistic/pessimistic lock etc.) are well known and the contents are a bit too light to be very useful, yet the concepts are giving readers some directions.
In resource patterns, some interesting patterns are presented, particularly resource timer automatically releases inactive resource, retryer enables fault-tolerance for data access operations.
In cache patterns, cache collector purges entries whose presence in the cache no longer provides any performance benefits; cache replicator replicates operations across multiple caches.
There are some areas to be improved, first, author should consolidate pattern names with other pattern authors, e.g., data accessor is also known as data access object, active domain object is similar to active record, paging iterator is close to value list handler (though value list handler is more decoupled from underlying data store), the point is, one of the important benefits and purposes for documenting patterns is to build common vocabularies among designers, using different names for same or similar patterns is defeating this purpose. The same pattern name should be used and may be presented as a variation of the original pattern.
Secondly, the examples given in the book is a bit too simple, sometimes, the examples might not justify or validate the interface abstraction is generic enough to handle real world problems, so some tweaking and modification to the pattern would be expected.
Overall, the book is well organized, and contents are easy to follow, most patterns come with class diagrams and sequence diagrams. Good for designers who want to decouple data access from rest of the application, utilize cache to minimize data access and thus boost application performance, manage resources in an efficient and leaking-proof way.
<< 1 >>
| 
