on July 23, 2005
If you are looking for a broad overview of how to develop applications that use databases (typically relational DBs), then this is a great start. Many different topics are covered, including cultural and personal issues in teams, which are very important. The chapter on mapping objects to relational databases was probably the best, and I also found the database refactoring advice useful.
If you are also looking for depth of coverage of the above topics, you will have to look elsewhere, perhaps after reading this book to get a very high-level treatment of the topics. I found myself thinking, "This is great. I agree with this advice. Now what do I do?"
The book doesn't come down to a low enough level to really put you on solid ground, but if what you want is wide coverage of all of the elements that go into developing database-based applications, this is a well-written book to begin with.
I fully agree with the other reviewers who have given detailed and glowing descriptions of this book and why it is an important work that addresses the real challenges of developing to a relational model in OO environments. Agile techniques are also interwoven into this book, but it is in overcoming the relational-OO challenges that I found this book to be most valuable.
The first part of the book, "Foundational Skills and Knowledge", covers the challenges and how to meet them with eight excellent chapters that truly give the foundational knowledge. The next part, "Evolutionary Database Development", is comprised of seven chapters that introduce Agile techniques as they relate to DB development. Among the two strongest chapters in this part of the book are the ones covering DB refactoring and mapping objects to relational databases. This material, to me, clarified a lot of issues I had before reading this book. Part 3 is more focused on development techniques, with excellent information about concurrency control, access controls and related topics. The final part of the book is specific to general Agile implementation. You need not embrace Agile methods to learn an enormous amount from this book.
If you want to know more about this book's contents you will find a great deal of information on the author's Agile Data web site (paste the ASIN, B0000A3527, into the search box at the top of this page, select All Products and click GO). I also recommend Clifton Nock's "Data Access Patterns: Database Interactions in Object-Oriented Applications" (ISBN 0131401572), which augments this book in many respects.
on February 2, 2004
"Agile Database Techniques" is aptly subtitled "Effective Strategies for the Agile Software Developer". Take special note of the word "strategies", because what you will not find within is pages of code and implementation details. This is not a bad thing as there is so much ground to cover that getting caught up in the low-level details of how to implement a particular strategy in language (add yours here) would have limited the scope of the book. Instead, what you will find is a detailed set of skills and development methodologies required by the developer who finds him or herself immersed in the details of modeling, implementing, and/or refactoring the database schema for their current application.
Should you buy this book? Well, try answering the following questions:
- Could you easily create a physical data model of your schema?
- Can you explain the difference between first and third normal form?
- What about first and third object normalization forms?
- Can you list the challenges in mapping an object model to a data model?
Did you answer honestly? Because these are just some of the items covered in Part One of the book and unless you said yes to all of the above, you will walk away with plenty of ideas for improving your development after a single reading. This is the core reason I would recommend this book. It is full of ideas that you might never have thought to include in your development practices, and probably some that you had thought about but were not sure what the best approach might be.
My complaint with "Agile Database Techniques" is that it could use another iteration. In the introduction, the author states "When I first started writing this book, I intended its focus to be on the agile data method... Because I was taking an iterative and incremental approach to the development of the book, I quickly realized that the real value lay in detailed development techniques instead of yet another methodology." While I can agree with and embrace the merits of applying agility to my development practices, I think there is an overabundance of methodology content in the book that only clouds its real value.
In summary, I think this is one of those books that will sit on my shelf for some time to come as a great reference for how to approach any number of application and database development related items.
on January 23, 2004
Agile Database Techniques is a brilliant book. Already after reading the first chapter I felt like I had been run over by a truck, wondering why I haven't paid more attention to these issues before. Yet, it also has its flaws which I will go into further down.
Ambler starts laying out the groundwork for the second part of the book by introducing his Agile Data method, UML and data modeling. He also gives a very useful jump-start tutorial on data and class normalization and discusses the infamous object-relational impedance mismatch. Worth noting is that in each chapter (throughout the book) Ambler makes sure that the reader understands how the subjects relate to the role of an agile DBA and what should he be looking out for. The subjects in part one were introduced so well that I more than once thought, "I've never seen such a well-balanced and informative tutorial."
The second part of the book focuses a bit on how evolutionary software development is the reality and how techniques such as Agile Model-Driven Development and TDD can assist in surviving in this climate. The chapter on database refactoring is intriguing and the more comprehensive list of database refactorings, found in the appendices, is something I'll definitely Xerox and keep with me in my traveling tool bag. The second part also covers database encapsulation strategies and approaches to mapping objects to relational databases which, again, is a delightfully comprehensive tutorial, as well as touching on the topic of performance tuning.
The third part is a seemingly random collection of subjects such as finding objects in a relational database, referential integrity, concurrency, security, reports and XML with databases. The text is again of high quality and provides an entertaining walk through the woods, but I feel that these chapters had very little to contribute to the subject of the book. This disconnect is made even more clear when Ambler finishes with a 10-page guide on how to become agile and to introduce agility into the organization.
After reading the book, I feel confused. On the other hand, this book is full of little islands of useful insights that I wouldn't think twice recommending for others to read. On the other, the book as a whole is very fragmented and pretty far from what the book's title might suggest. If you pick up the book with an open mind like I did, you'll gain plenty. Otherwise, you'll probably be disappointed to find out that one half of the book probably talks about something you weren't expecting based on the title. After a long struggle, I'm giving this book "only" fours stars despite that it contains some very, very high quality material.
on December 16, 2003
Scott Ambler is uniquely qualified to write this book. He started his software life as a data modeler, and is now an industry thought-leader in agile, object-oriented software development practices. He wrote Agile Database Techniques to address a single issue that he is obviously passionate about: is it possible for data professionals to develop their data in an evolutionary way? Ambler answers this question with a resounding "yes"! And his book is a manifesto on how the data and object communities can lay down their weapons and join forces to create better software.
Part One addresses the basics of agile development, database concepts and data normalization, object concepts and object normalization ¯- which may be a new concept to some readers. If you are not a data person, you will get a good introduction to the data world-view. If you are not an object person, you will gain insight into why object people see the world from a behavioral view, not the data-centric view. What I found appealing was Ambler's willingness to leave out all the fluff and deliver just enough detail to equip us to move to the next part of his presentation: Evolutionary Database Development.
This second part of the book covers *a lot* of ground. After a well-crafted appeal for flexibility as a major success factor in software development, Ambler introduces the principles and practices of his own "Agile Model-Driven Development" approach, then a concise discussion of Test-Driven Development, also known as "test-first programming". This is a very brief chapter, and I wish Ambler had developed these concepts a bit more, but he has much bigger fish to fry in this book. His discussion of the need for, and practices of, database refactoring will be provocative for many data people. In my own consulting experience the "rot" or "smell" of database entropy is everywhere. The rigor of the original data models is lost under the pressure of schedule, or the inertia of inexperienced persons not taking the time to think about the downstream effects of reusing a table column for an obscure and transient purpose...which soon becomes permanent. The most significant chapter in the second part discusses mapping objects to relational databases. Ambler has written often and extensively about the object-relational "impedance mismatch", and this chapter offers the programmer and DBA much to think about.
A theme that runs throughout the entire book is what Ambler calls the "role of the agile DBA". These brief discussions, almost sidebars in their presentation, are aimed squarely at DBAs working on agile, OO projects. Most OO developers will kill for a DBA who actually supports the software effort rather than being an institutionalized impediment. Ambler's tips to the "agile DBA" are worth the price of the book, IMHO.
Part 3 is a collage of database concepts that are essential for software developers to understand if they are to be successful as a programming and data team. The topics include referential integrity, access control, concurrency issues and control, transactions and their ACID properties, with a brief discussion of both database transactions and object transactions -- and they are not the same. Very important stuff, and it is my experience that many application programmers have only the barest understanding of these critical technical issues--especially data-specific issues such as two-phase commits. It's all here.
The last part of the book reflects the beginning: how can you become agile, and how can you bring agility into your organization? Ahh, this is going to be hard for some people, and some companies. But it can be done, if approached patiently, with sensitivity for your existing corporate culture. And the reality of the cultural mismatch is something Ambler addresses throughout this book. This is why he calls the agile DBA a "peacemaker". This is why he calls upon us to be "generalizing specialists", so we can see that there is more to software than objects, and certainly more than data alone.
on October 21, 2003
This is the best book I've bought in years. It starts with an overview of agile software development, something that every single IT professional needs to understand these days. It also overviews basic skills such as data modeling, object modeling, and normalization. Ambler is absolutely dead on with this material: everyone needs to understand the basics of both object development and database development if they're going to get the job done. I'm really surprised how few object and data books actually deal with these basics, they always seem to focus on only one part of the overall picture. Why hasn't someone written just this section before?????
More importantly the book has chapters on agile model driven development and test driven development, two topics that are critical to your success as an agile programmer. Anyone doing XP needs to be up to speed on both these techniques. in particular TDD but just as importantly AMDD.
A really cool chapter talks about database refactoring, which is basically refactoring for relational databases. Anyone who wants to be an effective DBA needs to learn this stuff. There's also an appendix with a catalog of DB refactorings. This material alone is worth the price of the book.
I didn't think that the chapters on basic programming issues such as concurrency control, referential integrity, database access, and reporting would be of interest. Man was I wrong. Ambler takes what I thought were dry subjects and shows how many implementation choices you actually have. I can't remember how many arguments I've gotten into with DBAs, or programmers, who thought there was only one way to do these things. Most importantly he discusses the tradeoffs of each strategy and tells you when they work best. If you're designing a new application this material is critical.
If you're struggling to find ways for programmers and DBAs to work together effectively you really need this book. It shows how to overcome the "people impedance mismatch" that you see in most companies. DBAs need to work in agile ways, and this book tells how to do exactly this.