5 comments about Agile Retrospectives: Making Good Teams Great.

1. I refer to the activities in the book all the time. It really gives a fresh look at the retrospective and keeps the team engaged. It's very easy to come out with some actions to carry forward which the team is committed to doing.



2. This year, I found myself leading an agile development team. While I've been in the software industry for several decades, I'm new to agile. I was lucky enough to attend the Agile 2007 conference, where I participated in a session with Esther Derby and Diana Larsen. That's where I first learned about retrospectives - from the co-authors of this book.
   
   First, the idea of retrospectives, as opposed to post-mortems (are our projects really dead?), as an ongoing process is challenging and exciting. Rather than waiting until the end, reviewing not just progress but the state of the team makes great sense.
   
   Then, the way that they put it all together - stating the value of the process, giving an outline for how to conduct a retrospective - makes it something you can indeed do right from the book.
   
   But as much as anything, the exercises/activities that make up a large part of this book are a tremendous value. Rather than trying to figure out "what should we do/say in a retrospective?", we are guided through combinations of activities to help us achieve the most effective results.
   
   And it's not just about agile. While the concept has developed through the growth of agile development practices, this is a tool that can benefit any organization of any type doing anything.
   
   It's a quick read with benefits that far outweigh the time it takes to read it. Ready to change the life of your organization? Introduce retrospectives.



3. This is a really useful book. Most practical. Being into scrum (sort of) for 3 months, we've tried to change our retrospective meeting agenda applying methods from this book. We did this just once as yet, and applied only a single combination of methods from virtually countless variants possible. The result is great: retrospective meetings became more meaningful and fun.
   
   Every scrum master (and anyone leading retrospective meeetings) should read this book.



4. I have read at least 10 books of the Pragmatic Series and this is the first one I couldn't finish because it was so terrible (I actually threw it out). This book is exactly what is wrong with corporate culture. Placating overly sensitive employees who need emotional coddling instead of trying to improve the process of software development. I prefer to work with adults, that have the maturity to get their emotional needs fulfilled outside of work, so time at work can be spent being productive. This book should have been titled "Cloy Retrospectives" or "Agile Dianetics". If you are looking for a worthwhile, and even entertaining, book on software management see Managing Humans by Michael Lopp.



5. This is one of those "common sense" books. It's full of really obvious practical advice. The difference I found however is in the multitude of simple and practical exercises it contains.
   
   The book is a really quick and easy read. It's now constantly on my desk as a reference. I plan to use a few of the exercises in our next retrospective in a week.
   
   Whilst this is an agile/scrum focused book, many of the exercises could be easily adapted to other "review" type situations in business and teaching.

5 comments about Structure and Interpretation of Computer Programs - 2nd Edition (MIT Electrical Engineering and Computer Science).

1. So there I was, 18 years old, having been raised on a toxic stew of MS-BASIC, Apple II assembly and some MPW Pascal. My mind was poisoned. Everything I knew about programming was wrong. I read book after book on programming and CS, but none of them really seemed to make a real dent in my style.
   
   Enter SICP. In a few months, this book reshaped my concept of what it meant to program a computer. It does not spend time teaching a language; Scheme is presented precisely because its syntax and commands can be covered in about ten minutes, and its structure becomes absolutely transparent within a few days of looking at Scheme code. It does not spend time walking the reader through common coding tasks, as a Learn X In 24 Hours text might.
   
   SICP teaches the fundamentals of programming mastery. Abstraction, modularity, design paradigms, compilation and interpretation, and more topics are presented in a style which is exactly as simple as it can be, and no simpler. Scheme allows these topics to be covered without becoming mired in details which would otherwise plague the implementor.
   
   It will not show you how to write a GUI, scrape a web page, develop a social networking website or create a network server. It will, however, guide a dedicated reader through an exploration of immensely powerful programming technique, and it will prepare the reader to solve any problem in any language for the future.
   
   SICP is not a machine gun, putting power into casual hands. It is a light saber, rewarding discipline and practice with unstoppable capability.



2. If you disagree, hopefully you're thinking Knuth. But consider this: Knuth is a wonderful bestiary of important programs and proofs; SICP is about the very nature of programming and programs.
   
   If you're not thinking either, and no offense to K&R et al: Do yourself a favor, watch the videos. Sussman & Abelson are entertaining teachers. SICP is a difficult book, and seeing Sussman in a fez after the metacircular evaluator just... helps.
   
   But of course Graham's and Norvig's reviews are gems of their own.



3. My first encounter with SICP was in the second year of university, where I took a course named "SICP 1. I already had working programming experience by that time, so the course wasn't hard, but I was struck by the beauty of the subjects it taught, by the Scheme language it used and by the long and interesting homework assignments it had. This course woke my curiosity about functional programming, and the Lisp family of languages in particular.
   
   A few years later, with much more experience behind my back, I've decided to tackle SICP seriously and read the whole book, solving the vast majority of the exercises. This endeavor took about 10 months, and I enjoyed it immensely. I think SICP is a wonderful book, a seminal work in the field of programming. It is one of those rare books every programmer should read. In this review I'll try to explain why.
   
   In contrast with most introductory books about programming that just teach you a language, SICP takes a far better approach. The main goal of the authors is not to teach Scheme, it is to teach programming. From the beginning, the book takes an integrative path, where the basic axioms of programming are presented, and later are fortified with examples and exercises. SICP teaches about computational processes - iterative and recursive. How to use them best in each situation, and how to implement them. It also explains abstraction by functional composition. These are topics rarely presented in programming books, but SICP puts them rightly in the first chapter, because they are the real stuff programming is based on.
   
   The example programs developed in the book are real, large, and exciting. You'll get to develop a powerful picture language, a generic object-oriented arithmetic package including complex and polynomial arithmetic, a simulator for digital circuits, a symbolic differentiation package, an interpreter for Scheme written in Scheme, an interpreter for a logic programming language similar to Prolog, a virtual machine for a simplified pseudo-assembly DSL, an interpreter for Scheme written in this pseudo-assembly, and finally a compiler from Scheme to the assembly language. All these examples are real, well-thought out exercises for skill, taken from beginning to a very complete end. In no other book such a wealth of topics is addressed in an accessible manner.
   
   A word about exercises in SICP. They are numerous, some of them are hard, but the exercises are the best way to really understand what the book tries to teach. In a manner, they're as integral part of the book as the text itself. The exercises are very well prepared and lead the reader through the examples coded by the authors into greater understanding of the topics taught. At times, it feels like the exercises are specifically designed to force you to think about the essence of the topics, and not just grasp them superficially.
   
   SICP commonly suffers from the criticism that it's too hard for beginners. Maybe this criticism is rightful, and universities should give a simpler introductory course to programming before SICP. But this is an aspect of the educational systems, not pertaining to the book itself. I wouldn't know, I never read SICP as a beginner. However it is being taught, SICP is an amazing book. It is by far the best programming book I have ever laid by hands on, and I seriously doubt that it will be surpassed any time soon. Reading SICP will enlighten you as a programmer, and make you a better one. I can't imagine one programmer who won't gain something important by reading SICP.



4. i bought this after wanting to brush up on theory, algorithms, programming concepts and all the other Compsci stuff but didn't want to go back to skool.
   
   this book really helps brush up on what you need to know and I would recommend that anyone taking compsci today get this book and work thru it in conjunction with your regular classes.
   
   those of you who didn't go to compsci should get this book too.
   You will learn a lot..but not how to spel!



5. I read this book because it was assigned for a course in school and I feel that working through the book greatly increased my ability. Now that school's out I find myself wanting to conjure the spirits of the computer with my spells and asking people to `read SICP' in all kinds of conversation.

1 comments about Beginning Groovy and Grails: From Novice to Professional (Beginning: from Novice to Professional).

1. I come from a strong Django background and when I recently inherited the role of Lead Developer I had the power to make decisions for a small start-up. There were two requirements for the product the customer needed: database independence and it must be based on a java framework. Additionally, the team would be fairly small and we would have less than 4 month to deploy. Needless to say I felt Grails would make my life livable.
   
   This book does a wonderful job introducing you to the Grails framework. To be honest, its hard to pick up Grails based on the documentation out on the net unless you already have experience with a similar framework. I had several members on my team that failed miserably with Grails who came from a Spring/Struts background. However, those who had Rails and Django experience could hit the ground running.
   
   If this book came out earlier, I'm sure the 'other' developers could've had less headaches. The book holds you hand and introduces you to the simplicity this technology offers. Give Grails a shot and get this book! Yes, the framework and language isn't quite mature yet and does have a number of 'gotchas.' But with its glowing community I can see it easily improve and become a very popular choice in the job market.

5 comments about EJB 3 in Action.

1. This is THE BOOK for EJB 3.0. Covers everything about EJB 3.0.
   Also outlines migration from EJB 2 and integration with ORM tools.
   It's a highly organized and well written book.



2. I have been working with Enterprise Javabeans for many years. This really is by far the best resource to date on Enterprise Javabeans. One of the many strengths of this book is to show how the Springframework blends into the EJB framework. I have had a lot of success in blending these frameworks. The authors really believe in the EJB framework unlike another major author of EJB books.



3. This is my third book on EJB 3.0 and in my opinion the best one. I'd recommend it to anyone who wants to learn Enterprise Java Beans and Java Persistence API.



4. I was not that enthusiastic about EJB at all during the EJB 2 era. Then I knew about the EJB 3 specifications and that made me read this book. I have to admit that after reading the book I became very much interested in EJB 3 mainly because of its removal of legacy EJB2 boilerplate mechanisms and the introduction of "Spring" like features. The book is very cleverly written and easy to read. The authors make every effort to make the readers completely engaged on the topic. Although I don't use EJB3 for my day to day work, this book clearly gave me new perspectives on how Java EE is driven going forward.



5. My company's library basically gives me access to all books I want, so I used to have a big stack of big EJB3 books on my desk. But during 2 months of daily work with EJB3 I often found this book helpful where others weren't and almost never found it the other way 'round. Only exception: Enterprise JavaBeans 3.0 (5th Edition) That book sometimes just has a broader coverage, delivering details that "EJB3 in Action" doesn't. But still, "EJB3 in Action" remains the best-understandable EJB3 book with (almost) the best coverage of topics. I have now returned all other books than the 2 mentioned here to the library, and I always look in this book first.
   
   While I agree with Rob on the language issue, what counts is the result, and that is usually the best with this book.

5 comments about Dynamic HTML: The Definitive Reference (Dynamic Html).

1. I bought this book , and i wait it about 1 month for arrive to me , but i am not lucky , the book contains more than 1300 pages , but i didn't find any thing benefit for me .
   I advise any one in beginner Level to keep away from this book .you must save your money .



2. The finest review of this book I can give is simply this: I bought the first edition in 1999, the second edition in 2003, the third edition in 2007, and as long as Danny Goodman and O'Reilly keep up the good work, I'll buy the fourth edition in 2011. There is no more indispensible book available for the Web GUI professional.
   
   One caveat: This book is not for beginners. If you don't already know how to build a modern DHTML/CSS/JS/Ajax interface, this book will likely be a waste of money. Moreover, if you're looking for how-tos and recipes, look elsewhere. This is a comprehensive encyclopedia of the DHTML universe, nothing more and nothing less.



3. The ONLY DHTML reference you need. This book has everything covered from Javascript, HTML, CSS, DOM, Ajax, Web 2.0. This is the only book that I always have by my side while developing.



4. I used to have the previous edition. I could quickly find objects and properties in the books index and just go to what I wanted. This new edition doesn't even have the event handling properties such as onmouseover and such. Its also missing some minor properties for css or html. I know the big ones, its the minor ones that i need help on. Its great that it takes into account safari, mozilla and opera compatibility, but they really did a crappy job on the index. Apparently they wanted to safe paper and removed some things from it. so, now I use the old edition and new edition. A big inconvenience.



5. A generally good reference book, but lacks a thorough index, and the page headings lack detail. Plan on spending lots of time flipping through the "input" and "document" pages looking for the page you want.
   
   The book notes browser compatibility for each item, but its hard to not feel drowned in the clutter of useless "IE n/a NN n/a Moz n/a Saf n/a Op 9 DOM n/a" entries.
   
   What I really wish I had was a "DHTML Best Practices" book where the primary useful, portable, and recommended tags/classes/events/whatever were highlighted and the deprecated/incompatible stuff was just summarized in a secondary section.

5 comments about ActionScript 3.0 Bible.

1. I am an experienced programmer who knows Java very well, and I was looking to learn ActionScript 3 so as to be able to build Flash applications. I found this book very easy to read and to understand, and the examples easy to put in practice. Sure, there are a few errors here and there (including in the code, which may confound a truly inexperienced programmer, but also make him think a bit to find the errors... a good exercise), but the overall tone is nice. I took my time, going through about one chapter a day (having other things to do as well), so I finished the book in about a month. Someone dedicated can probably read the whole book and play with all the examples in about a week. I especially liked the fact that the book introduces the reader to almost all Flash APIs: graphics, animation, user interface, XML parsing, file management, networking, image processing, printing, JavaScript interaction, etc. It does not go in depth into most APIs, but by the time you're done reading the book, you have a great overall picture of what you can do with Flash, and you can now explore the APIs in depth by yourself to build more complex projects (using the very comprehensive integrated help that comes with Flash CS3 Professional). You know where to look. I took notes while reading the book every time I learned a new concept, and now I use a highlighter to cross individual notes out as I put the concept in practice into my code and memorize it for good. I hope to have crossed out all my notes in the coming weeks. Anyway, one month after having finished the book, I consider myself quite familiar with ActionScript 3, and I have been writing some good code. So I would say that I am very happy that I purchased this book.



2. The Flash 8 Actionscript bible was an amazing reference, and covered just about every feature. This book is nothing like that. The examples are ok, but the whole way it is written and the index in particular feels kind of rushed. I need a good reference book!



3. It's surprising that nobody has published a simple language reference for ActionScript 3.0 yet; until that day comes, this book is my most often visited reference when programming Flash projects.
   
   Great job by the authors.
   
   My only complaint: The examples are good, but would be of much more use if they also included classpaths (e.g., the correct "import" statement) within them. As they are, I often find myself searching Adobe's online references for the correct package/class to import before trying them out.



4. In my opinion there are three things to look for in a Computer Language book. Exhaustive reference, truly illustrative examples and applicable conventions and design patterns.
   
   Unfortunately this book failed on all counts, so I rarely open it anymore.
   
   I also have "Essential Actionscript 3" and "Actionscript 3 Cookbook" in my library. I use these a lot more frequently.



5. Contradictory to most "Bibles" this book is not a thorough reference guide, meaning it does not break down every function or object with all of the property and methods. However, the examples are very clear and it's an excellent book to learn what you need and why you want it about Actionscript. I really enjoyed the simple explanations and for each topic I think just the right amount of information is presented without overloading you or leaving wondering what you're missing. Given that there is a wealth of detailed "reference" material at Adobe's site and built into Flex Builder, I think this book is an excellent complement to those materials. I recommend this book to anyone with a little programming experience looking to add ActionScript to their knowledgebase.

4 comments about An Introduction to Systems Biology: Design Principles of Biological Circuits (Chapman & Hall/Crc Mathematical and Computational Biology).

1. A superb intro to the field. The math is moderate and helpful. Network concepts and their ties to examples and theory are clearly and succinctly presented. This is a textbook but reads easily like a book. Covers key elements while connecting them by at least mention to up-to-date further research. The basics and the grandeur of systems biology. I am trying to remember now anything on the negative side and cannot.



2. The history of science over the past few centuries is to become ever more specialized. The physicists, becomming ever more concerned with the very large (stars, galaxies, the cosmos) or the very tiny (first atoms, then atomic components, now sub-components. The biologists on the other hand were studying much larger things, such as the cells that make up life. Both sciences developed techniques to facilitate their study.
   
   In recent years, researchers have discovered that sometimes these specialized techniques can be used to develop greater insight into what is happening in other sciences.
   
   In this book, Dr. Alon uses his training in physics to examine certain aspects of biology and to use the terminology and mathematics to describe the way these biological networks work.
   
   The goal of the book is to begin the formulation of general laws that apply to biological networks. This is done by providing a mathematical framework in which some of the design principles of biological systems can help to understand biological networks. In looking at the results, an underlying simplicity not seen before appears in biological systems.



3. I'm a Ph.D. student in biophysics. This is the best treatment of systems biology that I've encountered. It treats both the math and the biology with clarity, rigor, and respect. It simplifies without dumbing down. It's beautifully written. If you doubt that systems biology is a real scientific discipline, this book will change your mind.



4. I am a macromolecular crystallographer interested in theoretical systems biology, and this book is a real goldmine. It explains all the concepts behind biochemical systems and networks in a clear, lucid language. This book is a pleasure to read, for both biologists and mathematicians alike.

5 comments about MCSA/MCSE Self-Paced Training Kit (Exam 70-284): Implementing and Managing Microsoft® Exchange Server 2003 (Training Kit).

1. Before I started on my MCSA path, I had basically zero hands on experience with server. I picked up this book along with the book for the 70-290 test and these are ALL I used to pass both the tests.
   
   Just read and make sure you UNDERSTAND what you are reading and do all the exercises and practice quizzes/tests. You really need 2 computers to do all the exercises.



2. This was a great book for the 70-291 exam. Most people refer to this one as the hardest in the MCSE 2003 track so I spent some extra time pouring over this particular book. The information was comprehensive and I'd say it was one of the best in the series in terms of learning that just keeps on giving. I'm studying for the Server 2008 upgrade now and it's nice to see that a lot of the concepts covered in this book are still valid. Passed this exam using the book and a little experience with a healthy margin.



3. Probably you have heard this is the hardest windows server 2003 exam, then i will say that it is. The good news are really study this book and of course really do practice this material on a virtual machine or a test enviroment. Why may this book will not be enough to pass the exam, it is because you will get simulations (you'll have to configure dns, dhcp, etc) and that's why you will need lot of practice. But the book will help you along the way.



4. I only used this book for passing the exam and it is worth it, it covers many topics in "no deep " detail but if you have been in the field for a while you know what the important stuff is. It is good but not the best, I think they over load aa bunch of useful but useless info at the same time, beyond the exam tipics, like scripting.



5. I used thisbook as the only source to take the 70-291 Exam.
   
   I had read reviews on the exam and people were taking up to the third go to pass it... Needless to say I was nervous taking the exam.
   
   I read this book from cover to cover twice for the two days prior to the exam.
   Completed the labs and took not of all the tips in the book.
   Combined with a few years of on the job experience I passed first go. I found that the text covered all the information required for the exam (and there is a lot to be covered in this one!)
   The chapters on DNS I found very well written and also the RRAS chapters in particular.
   
   I would recommend this to anyone wanting to preapre for 291.

5 comments about HTML 4 For Dummies, 5th Edition.

1. I found this item to be informative, easy to follow and well worth the price that I paid for it. The book arrived when I expected it.
   I would recommend this book, as a starting point, to anyone who is interested in learning HTML.



2. Caveat emptor to the absolute beginner. This book is not written for the beginning web page creator. It is not written in a tutorial style. It is good as a reference source as you study a true tutorial type book. It discusses tags and their attributes one at a time without showing you how they fit into your web page code. The beginning chapters throw lots of advanced features at you and tell you they will be discussed in chapter 19 etc.
   I was completely overwhelmed after 20 min of reading. So what's a beginner to do? I recommend Create Your First Web Page in a Weekend. By the time you get half way through that book then you can use this dummies book as a reference.
   william



3. As a novice or someone thinking about working with HTML, I think this book was over my head. If one had some background in HTML they could probably make full/better use of its content. Pork Chops and Applesauce: A Collection of Recipes and Reflections



4. This is not a book for jumping into WEB development. It claims to be but it really is not.
   
   It's a good intro book for HTML for the absolute beginner. But, I must mention you have to be a reader versus an examples person. There is a great deal of discussion and only so much code examples. However, it did answer a couple questions.
   
   I found this book good for getting to know what is out there. The book offers useful links to sites for getting more information. This saved time and it offers a "warm fuzzy" since it is suggested versus wandering around the Net.
   
   The book also suggests some tools to use which again saved a little time.
   
   I don't know if I would call this a good reference book. For example, it lightly touches CSS, XHTML and CGI and the design suggestions? Well you probably could get a design book to handle that better as I think they are rather basic in this book.
   
   If you can get it from the library or get it used, it might be worth a look.
   
   If you understand basic HTML, you might avoid it.



5. I'm never disappointed with Dummies books and this one is no exception. Great read, easy to learn.

5 comments about MySQL Stored Procedure Programming.

1. It walks you through writing, maintaining, and debugging stored procedures. It can be used as a reference and tutorial.
   I found Part IV Optimizing Stored Programs particularly useful.



2. This book has an excellent coverage of the MySQL 5.0 stored routines (stored procedures, stored functions and triggers).
   But it also provides with invaluable hints and guidelines for general MySQL practices.
   
   The book starts with PART I: covering the syntax and rules for stored routines. This part is straightforward and a very fast read. The authors tend to repeat themselves on occasion, though only when relevant.
   
   PART II looks more closely at the particular rules for stored funtions and triggers. It also offers a transaction managing chapter, which describes transactions in MySQL in general, and in stored programming in particular. This chapter is very informative.
   
   PART III discusses the use of stored routings from external programs: PHP, Java, Perl, Python, .NET. The authors establish their view of correct usage and provide with general recommendations.
   
   In general, these three parts cover the stored routines material.
   However, here comes a nice surprise: enter Part IV, which is a real gem.
   This last part of the book discusses in depth MySQL query optimizations, indexing methods, performance issues, most unrelated with stored programming.
   Why? The authors explain (and I agree with them), that most stored routines code will usually have SQL queries DML statements in them. It is their opinion, then, that to write good, efficient, stored procedures, one must be aware of how MySQL optimizes and handles complex queries.
   I am not new to MySQL, yet have learned quite a few new things from this last part.
   The book ends with a "best practices" chapter, which mostly provides summary for all issues discussed in the book, including some general recommendations for best practices in programming (which could have been left out, in my opinion).
   
   All in all, this book is certainly a very good reference for anyone wishing to write stored functions/procedures/triggers in MySQL. The authors certainly have a strong expertise on the subject, and have a lot to tell.



3. Being fairly new to MySQL (but not to programming) I needed to develop an application using PHP/OOP with MySQL and stored procedures. This book is pretty concise and got me going quickly. At the time, I searched the Amazon book offerings and also books on the shelf at Barnes & Noble. This book is the only one providing clear and concise material on the subject.
   
   I do wish the coverage would have been more detailed using PHP data objects (PDO) in combination with stored procedures that use various combinations of INPUT, OUTPUT and INPUT-OUTPUT parameters in addition to exception processing, etc. That would have been great but then, this isn't a PHP book. Too bad most PHP books seem to focus more on the basics of the language and don't delve into the weighty matters of real-world commercial application development.



4. The good: I found to book to be generally useful. The approach the book takes is good. Lots of examples are provided along with a good amount of explanation.
   
   
   The not-so-good: There seem to be quality or editorial issues with some of the examples. When I run them through the query browser in MySQL version 5 I have problems with some of them. For example Example 2-7 calls another procedure new_salary, which doesn't seem to exist by that name in the book or on the website. This makes it much more time consuming for a newbie to actually run and digest the examples than it should.



5. I have been working with MySQL for several years as a database back-end for Java, Ruby and C# programming projects. After upgrading to version 5, I have been meaning to look into MySQL's support for stored procedures.
   
   The MySQL Stored Procedure Programming book was my first read on the subject and I found it quite useful. It covers not only stored procedures, but also functions and triggers, collectively called 'stored programs' in the book. While there are many books on MySQL, this book is dedicated to the stored programs domain and provides a lengthy treatment of the subject.
   
   During the introduction, the authors provide a veritable laundry list of MySQL resources including many books and websites. The basic tools for creating stored programs in MySQL are visited and help set the groundwork for a 'read, type in the example and run it' feedback loop. Throughout the book, the examples are clear and easy to follow.
   
   The introduction is followed by a brief tutorial, highlighting stored procedures, functions and triggers. What follows is two sections of chapters, over 200 pages in length, diving into the details of the stored procedure language fundamentals, blocks, conditional statements, iterative programming, error handling, the creation and maintenance of stored programs, transaction management, MySQL built-in functions, stored functions and triggers.
   
   The next section of the book is of particular value to software developers that use MySQL in their applications. Over 150 pages showing you how to use MySQL stored programs from PHP, Java, Perl, Python and .NET. The Java section even shows the basics of using stored procedures with Hibernate and Spring.
   
   After that, you'll be greeted with a 110 page medley of options to help you optimize your MySQL stored programs. The subject of tuning your SQL is addressed over the course of three chapters, from basic through advanced tuning topics. Additional optimization techniques such as reducing network traffic with stored programs, optimizing loops, recursion, cursors, trigger overhead and more are found in the final chapter of this section.
   
   The book closes out with a chapter on best practices in MySQL stored program development. MySQL Stored Procedure Programming has earned a space on the MySQL shelf of my technical library. It's a fine book that will help you take your MySQL programming experience to another level.