Customer Reviews

Principles of Transaction Processing for the Systems Professional (The Morgan Kaufmann Series in Data Management Systems)

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

 

 

This book was written in 1997 which is often considered ancient in "Internet-years" but it is still very relevant because it focuses on fundamental principles of transaction processing (TP) rather than the latest whiz-bang technologies that optimize TP.

For those of you who aren't TP experts, a transaction is a computer operation that meets the ACID test. ACID here stands for:

Atomic - the steps that comprise transaction succeed or fail as one, there is no partial success.

Consistent - the internal data structures of the system(s) remain consistent with business rules.

Isolated - the data read or manipulated by the transaction is not altered during the duration of the transaction's execution.

Durable - the results of the transaction are persisted

Why does this matter to the system user or stakeholder? The canonical example is that of the ATM machine (or the "handy bank" if you're Australian). When you withdrawl money from an ATM, it has to go out and validate you have enough funds to meet the withdrawl, reserve those funds, and dispense cash - all within the same transaction. If the ATM failed after your bank account had been debited but before you'd gotten your money, you'd be very upset; conversely if the cash was dispensed but the debit procedure failed, the bank would be very upset. Ted provides very amusing analogy for this using a wedding ceremony but you can read that in his book.

There's a whole lot more to transaction processing beyond ACID and the ATM example, including two-phase commit (TPC), high-availability, massive concurrency, and crash recovery. To find out about all of these topics, read the book. One thing to remember though is that most application developers will never have to deal with the extremely complex details of providing a working and robust transaction management implementation, but like any technology it's important to understand the technology's fundamental principles and mechanics to effectively use it.

The book itself is extremely dense. The content of the book is "only" 324 pages long but covers a large amount of ground in a good amount of detail. Definitely read in a quiet place free of interruptions with a strong cup of coffee.

One shortcoming of the book is that it was written in 1997 so it doesn't cover TP implementations in Java (e.g. JTA, EJBs, etc.) but it was nice to finally find out what the heck IBM's CICS and IMS products are.

Interestingly enough, I have never had to deal with complex transaction processing (i.e. two-phase commit) in my short IBM career. This is probably because I've worked on business-to-consumer (B2C) applications where only one data source is involved rather than a business-to-business system where multiple data sources are involved. I'll have to ask the B2B guys if they get heavy into two-phase commit or if it's not an issue.

The reason I read this book is because I've always been a bit mystified by Enterprise JavaBeans (EJBs). When I joined IBM, I knew the word, but I was not familiar with such topics as object-relational persistence, object remoting, and transaction processing, so to me EJBs were simply things that took four classes/interfaces to do what I could do in one simple POJO. Ted Neward, in a very interesting web interview on the Serverside.com mentioned that he used to think EJBs were completely worthless, but during the process of writing Effective Enterprise Java came to realize that they were not worthless but rather over-marketed. He said that they should have been called Transactional JavaBeans rather than Enterprise JavaBeans because transactions are what EJBs did very well. So, hearing this from Ted I decided to read a book on fundamentals of transaction processing, so that I could understand EJBs better. Now that I've read all about TP principles, I pick Richard Monson-Haefel's book again, and all of a sudden EJBs start to make a lot more sense.

I have been using this book in the advanced undegraduate class series on Transaction Processing. Since this book, as emphasised in the preface has eveolved from the class material, it is exemplerary suited for that purpose. But not only in academia, this book has enought coverage to provide a first reference point in such topics as TP monitors, queue design, locking solutions, HA and recovery in databases, 2PC. Additionally, VERY usefull (if somewhat dated) industry survey of Transaction Monitors (this will really benefit to the other edition perhaps including app servers and EJBs). Highly recommended.

This book is a very good introduction to transaction processing. It did a wonderful job of explaining concepts, and gave concise, clear examples. I would recommend this book as a primary text for anyone wanting to get an overview of the main TP ideas, with the Gray & Reuter book as a supplemental text. The book is very readable, too.

Transaction processing is a daunting topic, and this is one of the few books that provides the basics in a clear, understandable manner without overwhelming the reader. Most of the book is focused solely on transaction processing, but it touches on queuing as well, which makes it the ideal first book for anyone who is seeking details that extend beyond pure TP.

I like the way that the authors use real products to reinforce key points made throughout the book. While some of the products are no longer mainstream (indeed, some were never mainstream), the fact that real world implementations are used makes the information realistic. If you are using CICS, MQSeries, Tuxedo or similar products this book will have even more value. I also like the way difficult topics, such as locking, high availability and database recovery are given entire chapters because these topics need to be thoroughly understood in order to completely understand transaction processing.

After reading this book you will be armed with sufficient knowledge to make intelligent choices in selecting the right approach for transaction processing in a system design, or to understand the nuts and bolts of any TPM that you are supporting. I also agree with Cem Kaner's earlier comments that this book is an ideal resource for software test professionals who need to understand the entire environment that they will be testing. If you want to go deeper into TP, I recommend "Transactional Information Systems: Theory, Algorithms, and the Practice of Concurrency Control" by Gerhard Weikum and Gottfried Vossen, which drills much further down into the details of both transaction processing and queuing systems.

This book has a special place in my heart, since I read it front to back on a plane before an interview with my current employer. The information I picked up was timely to say the least.

Even if you are not interviewing for job, this book will be a very useful for those unfamiliar with basic to intermediate TP concepts. While the products the book covers are not as snazzy as the OTS systems and EJB, they are the rocks that are keeping everything working today while these newer technologies get their kinks worked out.

This should be required reading for any project that is developing a big system. I read it again recently and found that I had missed a lot from the first read. To me, this book is as important as the Design Patterns book.

This book is my first "real" visit to transaction processing. As a host, this books welcomes me very well. When I knock its door, the preface says welcome in in a very friendly matter, and the words from Jim Gray's is a nice one to get to know each other with the book very well. The first conversation between us in the first two chapters make me very anthusiast to continue the conversation the next day.

The next day (ch.3 &4) , well, we don't know why we have to talk about RPC and Message Queueing. I am wondering if the chapters are interesting for other visitors, for me..., it is a little dry...

And after a little tea, the book shows its photo album. It shows some of its good friends, from the war veteran CICS, Tuxedo until some more sexies friends like Encina, OTS, and MTS...

Then..., we talk more seriously after the chapter. But still the discussion is not too difficult to follow... Who would say that Locking (ch. 6), high availability (ch.7), database recovery (ch.8), two phase commit (ch.9), and replication(ch.10) are easy topics ? Fortunately, the book is friendly enough not to tell all the detail of the locking, commit, and replication in detail..., it asks me to visit its old friend: Jim Gray book and rich of its friends in bibliograpy...

Excellent print and illustrations. No ambiguous or misguiding explanations. It will broaden your horizons and greatly improve your understanding of Compouter Science. The book stands to it's title, yes, the principles, many topics are discussed in abstract, patternized way. No 'SELECT * FROM CUSTOMER' stuff. Get it. It may be off-topic but it sits right with "C++ Programming Language", "Essential COM", "Programming Perl", "UML Distilled" and "Design Patterns". Cheers.

Just because you've had a PC in your bedroom since you were 8 and can think in x86 assembler doesn't mean you have a clue about the really big systems. Transaction processing is what characterizes true enterprise environments, and if you think that CICS is just some dumb old dinosaur mainframe technology, WAKE UP and read this book (especially if you are going anywhere near banking, retail, big e-commerce, or airlines).

This book provides a pretty good introduction to transaction processing in easy to understand language. However, if you are planning to get into the more technical aspects, I suggest going straight to Jim Gray's Transaction Processing because it has basically has everything this book has, and a lot more.

I'm reviewing books with the question, "What will be worthwhile for people who are testing web-based applications?" This is a solid and useful introduction to the person who is trying to figure out how a system is supposed to work together, where it might be broken, and therefore, what test cases might be interesting.

This is not to say that the book is written with a testing focus. It's just a clear, readable, approachable introduction to transaction processing.