This is another book from my undergrad days, never thoroughly read at the time. It was written to accompany the lecture course of the same name by the author. If I remember correctly, the course was not terribly highly regarded, and I think the reason for that is also reflected in the book.
First though, the subject matter! It's incredible what's changed since the late '90s. The current example of big distributed system, the large website, was not around. The insane scalability of Google, Amazon and the rest just wasn't at this scale, and that area certainly hadn't become academic. It's now hard to buy a machine which isn't multicore, and massively multicore is lurking around the corner. Software transactional memory is now very trendy, but not mentioned at all in the book. The overriding memory assumption from the time was that physical memory was much smaller than VM - typical memory at the time of writing was 16MB. The book emphasises the slowness of hard disks and increasing performance gap compared to main memory, but improving SSDs could really be a game-changer here. Even the talk of modern RISC CPUs looks sadly dated in light of the modern x86 farce.
So, the book's obviously got to be read in the context of its time, but most of the academic points still stand. It's obviously an introductory text - the preface makes some reference to being usable as a jumping-off point for postgrads, but I think that's pretty laughable. To put it in perspective, the book often refers the reader to other undergrad books for further information. We're not talking an awful lot of depth.
However, that's not the point. What it's after is a unified framework for discussing 'concurrent systems'. This covers OSes, databases and distributed systems as the main examples. The OS material feels weak, covering just enough to bring up issues of concurrency, but nothing more. Perhaps it would have been better to make a simple OS course a pre-requisite?
The book suffers from a woolly style. When discussing design choices in the introductory section, bets are hedged to an almost useless level. 'Requirements' are talked about in a way that hints at the common implementation, without discussing it. No technical details or judgements are given, so the reader is left with an uneasy sense that they've just had the obvious explained to them, slowly. There is excessive recapping - after a section, it'll tell you just what you've read and how it relates to what you read previously. The chapter summary will then do the same, very blandly. It's like it's expected to be dipped into, one paragraph at a time, by the terminally dumb.
Interestingly, this has been an excellent example of reading style to me. I sometimes write technical documents in a not dissimilar style, and this, well, it shows me how and why not to do it that way!
This review so far has been harshly negative, but it's not a bad book. Once you get past the introductory generalisations, it picks up. The tone is mostly non-specific and high-level, but occasionally it throws in and discusses fundamental concurrent algorithms - things that are very tricky to get right. The explanations of correctness may be unconvincing (I'm starting to believe concurrency primitives need to be model checked - a heavy eyeballing is insufficient), but there are neat snippets of hardcore algorithms.
The core of concurrency primitives and transaction mechanisms are pretty reasonable, although I occasionally found I'd picked up the wrong end of the stick from her text. Whenever she returned to distributed systems, the text bogged down and waffled again.
The book ends with a series of case studies, which I hoped might be a high point. The discussion of traditional (non-modular, uniprocessor) Unix was pretty good, but the NT case study felt badly copied from a real guide to NT. The Java/middleware example was depressing, and the transaction processing example, based on cash machine networks, was almost entirely information-free - a very sad end to the book.
I don't have a good alternative to this book - my library is understocked on the transactions-and-concurrency front - so there's not much else I can recommend, but... I'm afraid I certainly don't recommend this book.