Variants Books

This is one of the best Junit books that I have read. Definitely a keeper in your bookshelf

Before reading this book I seldom wrote unit tests and when I just did it to make the project manager happy. I didn't really grasp what unit test is all about. I suppose many programmers in the industry know that unit testing is important. But they don't write any unit tests as it is boring and the next deadline is very close any way.

I started reading this book because a customer made me frustrated. He complained that stuff which worked in the last release doesn't work any more in the current release. This is of course a very unsatisfying situation. This stems from the fact that every software modification may lead to side effects. E.g. something which was OK before is now broken. Worst of all programmers don't know that something is not working any more. Programmers concentrate on what they are paid for and that is writing code. Most programmers are too optimistic as they assume that everything is working properly. And therefore they rarely test the same features again. How nice would it be to have "something" which tells the programmer that a feature is not working any more !

Well this "something" is called "Unit Testing". This book makes a good introduction to unit testing. It explains why you need less time to fullfill your tasks when you write unit tests and why there are fewer bugs. It is shown how stub and mock classes are used to break dependencies to other classes and other systems. It is pointed out how unit tests simplifies refactoring and how this leads to better design.

This refactoring approach is what me made enthusiatic about unit testing. Let's assume your task is to extend a poorly designed, undocumented application. The programmer who created this application left the company. So you have nothing else than undocumented code. What you do about it ? Well you can start writing unit tests to figure what the application does and how it works. Once you have a unit test suite you start refactoring and documenting the application. Thanks to your unit test suit you can perform the refactoring without fearing to break something which worked before.

Even though all examples are written in java the concepts and ideas layed out can be applied to other object oriented programming languages such as C++, VB.NET and C#.

However, this book fails to mention that unit testing is not a replacement for proper requirements engineering. Even with unit testing you still need to find an agreement with your customer on the features he wants to order.

Besides that, this book provides a good reading on a topic which will become even more important in the future. Let's hope that more programmers will read this book as this will improve software quality in this industry.

I read this book pretty much from cover to cover. I found it to be a nice introduction to the unit testing strategy now widely employed in software development projects. This book does put the testing procedures in perspective and it touches upon different types/levels of testing that need to performed to ensure that the code is as bug-free as possible. I really got interested in writing unit tests after writing this book. The concept of Test Driven Development made a lot of sense and I will certainly try to incorporate this strategy into future projects. Most of the time explanations are consice, clear and to the point. Several open source frameworks such as EasyMock and DynaMock are introduced briefly - although the level of detail is not as good as I would like it to be, it is nevertheless good to know where to look for frameworks (that someone already developed) you might need for your projects.

The only downside to this book is that it is out of date. The JUNIT used in this book (3.8) is not the latest version available. I tested all of the code after downloading it from the web and I found that some of the samples did not work. In some cases, the software is dated. For example, in some chapters, the author uses Maven 1.0 instead of ANT as the build tool. However, for Maven to work, it needs to download several jar files from remote repository to the local repository on your machine. The very first time you run Maven, it is supposed to do this automatically for you before building your project; however, Maven 2.0 is out and the remote repository links with Maven 1.0 is broken which means that you need to download several jar files from google manually and put them in relevant folders - since there are several of them, I eventually gave up after doing a partial configuration. Note that the build files that use Maven 1.0 will not work with Maven 2.0 - you will need to do significant configuration changes in order to get this to work. I am new to Maven (although I am very experienced with ANT), so I did not bother with trying to get these code samples to work. The other thing I noticed is that some of the Cactus examples are not working in this book. In some cases, I had to do configuration changes and in others such as the chapter on unit testing the EJB, I was not yet able to figure out what went wrong. In any case, you can't simply expect to run the code and expect it to work especially in the later chapters!!! Be prepared to spend time to figure out what went wrong and how to fix it.

All in all, it is a nice book on introduction to unit testing and I will certainly recommend it to newcomers to this arena. Also, note that the level of detail and treatment provided in this book is not sufficient for real world projects. I am planning on getting a more advanced book (JUnit Recipies) to complete the picture.

This book is a great intro to JUnit and quickly advances to intermediate level stuff (Cactus etc.). Lots of best practices are littered throughout the book and there's a good balance of code and discussion. A combination of this book with "Junit Recipes" by Rainsberger and "Java Development with Ant" by Hatcher will take you from newbie to JUnit guru in no time. Written in 2004 it's begun to get a little dated with JUnit 4.0 released (using annotations is quite a change) - however I'm sticking with JUnit 3.8 which this book is great for.

With the new Junit4, the book needs a new version.

Young and beautiful Rosemary Barton died while dining at a fine restaurant. Her death was purportedly caused by Rosemary's spiking of her own champagne with cyanide. A year having passed, Rosemary's grieving husband and younger sister are coming to believe that Rosemary's death was not by her own hand. There are, as one might expect, several good suspects and little good evidence. Rosemary's husband has a plan to flush out the killer, a recreation of the fatal dinner. Will the killer be given away or will death be again on the menu?

Remembered Death (or Sparkling Cyanide) has lots of the elements that make a Christie novel identifiably a Christie novel. There are the idle rich, a suspicious death with few and vague clues, a group of people all with good reason to want the murdered person dead and a subtle detective plodding to a revelatory denouement. This book, however, is clearly not one of Ms. Christie's better efforts. The plot lacks forward momentum, the characters are flat and non-compelling and, perhaps worst, the solution isn't entirely persuasive. Go ahead and read this if you're a Christie completist. If not, you're best off picking another.

After the sad suicide of Rosemary Barton, life went on. Her sister, Iris, got used to her absence. Her husband mourned her, but began to pick up his life again. Suicide is difficult to recover from, but it appeared that recovery was in sight for the family. That is, it was until some mysterious notes make a terrible accusation: Rosemary Barton, they claimed, was murdered. Murder, not suicide.

With that suspicion, everything changes.

Sparkling Cyanide is loosely linked to The Man in the Brown Suit through the character of Colonel Race. The plot also has some similarities in terms of the romances between the respective leading ladies and their suspicious men. The Man in the Brown Suit is much earlier and somehow stronger. The rollicking romance of the first book gave way to the claustrophobia and cynicism of the second.

It certainly is not one of the weakest Christie novels, and for the period in which it was released, it stands quite firmly in its shoes. I enjoyed it, as I nearly always do when AC is involved. This was a first time read for me, which was delightful. I had honestly thought that I had read every Christie at one point or another. Nice to discover that I was wrong.

Recommended.

Sparkling Cyanide is definitely one of my favorite Agatha Christie novels. I love the setting in which the big bang of the story takes place: in a fancy restaurant with the lights out after a big musical number. Just imagine the setting as being in those 1950s night clubs, like in the I Love Lucy episodes. The murder takes place during a birthday bash, when the lights are turned off to bring in the cake. Cyanide is dropped into the birthday girl's champagne. Once the lights are turned back on, the birthday girl is found dead, slumped over the table.

You'll have to find out how the story revolves around this murder scene. I thought the pacing was really nice. The characters were very interesting, and if memory serves me right, the novel is narrated from the perspectives of several of the members present at the birthday party. In the end, the husband, of the woman murdered, tries to reenact the murder scene by holding a "birthday" reunion at the same restaurant a year later hoping that he'll be able to catch the murderer the second time around.

What "improvements" have been made for the St. Martin's Minotaur edition? There are already major differences in punctuation, word choices, and scene breaks between the original Collins and Dodd Mead (REMEMBERED DEATH) editions of this novel. There are further differences between the Dodd Mead editions republished by Random House/Avenel and the Dodd Mead editions republished by Simon & Shuster/Pocket. There are further additions still in the Signet, Bantam, Berkley, and Black Dog & Leventhal editions. For every publishing house putting out her works, there seem to be a new batch of editors altering Agatha Christie's words and the sound of her voice. What's the matter with these publishers? Whose voice do they think we want to hear when we sit down to a novel by Agatha Christie? And what will she sound like twenty years from now? It's frightening that her estate has failed to see the importance of guarding her words as she wrote them. Please tell me I'm not the only one here who senses that a crime has been committed.

Charming socialite Rosemary Barton had committed suicide during her birthday party. Or had she been murdered? She had been a bit depressed after a prolonged bout of the flu but Rosemary had everything to live for, she was young, rich, had both a devoted husband and a lover. And why choose a busy glamorous restaurant during a dinner party held in her honor? Over the next few months doubts began to surface over Rosemary's death, but if she had been murdered then who could have done it but a guest at her party - her husband, adoring younger sister, loyal secretary, friend, her lover or his unsuspecting wife? Then the second murder happened.....

This 1943 mystery (also published as REMEMBERED DEATH) is told from the points of view of starting with Iris, Rosemary's younger sister, shifting to the other members of the ill-fated dinner party. The detective called in here to solve the crime is the mysterious Col. Race.

As always with a Christie novel the clues are all fairly laid out for the reader to follow, the mystery is clever with some interesting twists and turns along the way.

Before reading the book I was unsure of where to start. We had a large language, similar to Java which we wanted to parse, and we wanted to do it without using a compiler-compiler. By changing the author's design slightly so that the parsers were singletons and only a single assembly was ever created, we were able to parse large and complex files very quickly. More importantly, the design is such that making changes to your language is a snap. This was a must for us since our language is still in flux. If you have any kind of language you need to parse, Java is your implementation language, and for whatever reason you cannot use a compiler-compiler, then this is the book for you. The author's code included with the book will get you on your feet and running quickly. If Java is not your implementation language then keep in mind that the patterns taught in this book will work in any Object-Oriented language. Thanks to this book we now have an a new programming language which we have open sourced. Five-stars, thanks so much for the great book!

this review is intended to help potential customers better decide for themselves ; i was nearly dissuaded from purchasing a copy due to the reviews by inexperienced ( and apparently lazy ) programmers

the provided code, and related concepts, are examined fully in the text. the code is so OOP-trivial ( this is a good Java design rather than rehashed procedural code clumsily ported to the OO-Language du-jour ) that anyone familiar with the basics of Java, C++ or C# should be able to compose their own library in a short period of time. in the preface the author suggests the reader be familiar with Design Patterns and UML, but he has included sections which address the minimal use he makes of UML. most 'somewhat experienced' programmers will be able to see through the scant UML diagrams to the underlying concepts they address, but he explains the notation anyway. as for Patterns, they are mentioned in passing but are not examined in any way which might hinder the uninitiated

one reviewer laments that ''... the author's explanation of his code library is virtually non-existent -- you're going to have to figure out what he's talking about all on your own'' - this was not the same book i read. in addition to including comprehensive javadoc ( Java documentation in HTML format is provided on the CD as well as his web site, if you're buying a used copy ) to help guide readers interested in ''digging into his code'', the author walks the reader through the concepts presented in this book in an incremental and rather intuitive way. starting from ''the ground-up'' is not always a good idea, and i'm glad this author followed his instincts rather than the herd

the code supplied is working code ( a feat almost unheard of today ), the examination of which helps to illustrate function better than any equivalent volume of text could. in fact the code is so well decomposed in terms of OOP that the text cannot fail to assist even entry-level programmers in the creation of their own parsers using the concepts presented. as for the difficulty of making oneself independent of 'his toolkit', i can only say that more than 95% of the class methods are under ten lines of code ( most are under six ), so it seems that anyone willing to apply themselves should be able to succeed in doing so ; especially considering the fact that his included code covers far more ground than a more sharply focused ( 'real world' ) implementation would ( meaning that, in terms of volume, you would only need to write or implement a tiny fraction of what is included with the book to satisfy any specific implementation )

some reviewers have unambiguously reported putting the concepts presented in this book to work - and quickly - which says a great deal given the perceived complexity of the subject. indeed, creating a parser for a macro assembler for a particular embedded processor was so trivial ( thanks to the concepts in this book ) that i am confident modifying it for other targets will be trivial, as it was modeled after the author's OOP examples. having said that, the OOP perspective this author has provided seems the principal way in which this book is differentiated, making space for itself in an already crowded marketplace

ignorance of the subject matter can be blamed for many of these negative reviews ; some reviewers are so unfamiliar with the subject matter as to call all compiler related concepts 'black-box'. each of the compiler books on my shelf examines a recursive descent parser, but in a far less practical way, and typically in pseudo-code ( including a prominent example claiming to use Java, but instead presenting what i consider to be nothing more than procedural C pseudo-code fragments ). BPWJ follows a preferable route, and anyone who has inordinate difficulty might better fail with a more abstract text on the subject before blaming this author for their own inadequacies

one reviewer complains about the onus of being expected to participate in order to gain comprehension by stating ''To compound it, that code can be a bit perplexing when 95% of his variables have one-letter names -- it just isn't very readable if you're not already familiar with his ideas and approach'', which mystifies me, given that well over 95% of the class methods are under ten lines of code ( most are under six ) ... what kind of neurological damage would account for an inability to retain the type of an identifier within the span of six lines ?

for example :

Token t = new Token();
Assembly a = new Assembly();
String s = "some string given the highly problematic identifier s''

should the time a programmer saves by using OOP be squandered on thinking up unnecessary, lengthy names whose lifespan is less than ten lines ? especially considering that peripheral vision will nearly always encompass the code in question, a scant few lines above ? now ... what was 't' again ???

to round-out his list of disappointments, this same reviewer states ''The good news is that you'll be up and running and writing simple grammars and parsers in very little time. The bad news is that if you're working on anything [...] find yourself forced to peer into the black box to figure what the heck [his code] actually IS doing'', with which i agree - the code included is not geared to any specific project you may have in mind ; rather it is nearly exhaustive so that a working example for you to study is always at hand. warning : you will need to participate if you wish to make use of what you can learn by studying this book. if you are willing to do that, success can be yours ... passively being granted mastery in any area of programming ? i'll take the Vegas odds on that !

another reviewer makes several complaints ... in order : ''(1) ... everything is so dependent on the included framework makes it difficult to learn from. (2) I think the best programming books teach you how to build step-by-step from the ground up. (3) Instead, this book expects you to immerse yourself in the code first''

(1) the code, and related concepts, are examined fully in the text. the code is well designed OOP, rather than a ham-fisted port of procedural code, meaning that anyone with minimal experience in any OO language should be able to write their own, rapidly turning his ''fascinating ideas'' into a coded reality all their own

(2) as for ''learning from the ground up'', the text progresses slowly, beginning with a general overview ( to help readers get their bearings within the overarching conceptual framework being presented ) and moving into actual, albeit initially trivial, examples ( as any good programming book should ) and progresses from that point with chapters focusing on discrete aspects of the subject, as well as considering various implementation domains

(3) good code ( especially *working* code ) helps to illustrate function better than any equivalent volume of text could. having said that, the author forces no one to immerse themselves in code. naturally code is presented - this is a programming book after all, and not a purely theoretical one. the presented code is so well decomposed ( into OO Java ) that the text cannot fail to guide a programmer in the creation of his own parsers using the concepts presented ... so making oneself independent of his 'framework' seems trivial enough, given, again, a minimal competency in nearly any relatively modern OO language. as already indicated, the code is slowly examined initially, and given the brevity of procedures ( mentioned above ) it seems reasonable that anyone willing to apply themselves should be able to master the concepts presented in this book

i cannot abide an above average programming text being trashed by the inexperienced, who might have anticipated possessing ''mad 3l33t haxor skilz'' after flipping through the pages - reviewers reporting having used the material presented in this book tell us more than any failure ever could

warning : anyone who considers studying clear Java code difficult, or is unwilling to expend the effort needed to succeed in learning a new task, should avoid this book and every other book on the subject. perhaps IDG should be made aware of the sales they could expect for a new 'Dummies' title. then these unhappy campers could enjoy cartoons ( ''to spice things up'' ) and be given strained examples, twisted for the sole purpose of setting-up some moronic joke

one note about the code : it was written under an early version of Java ( the book was published in 2001, remember ) and to bring it up to current standards will require hitting the files over the head with a compiler. NetBeans quickly directed me to add annotations, mostly @pragma, which took a few minutes. not a big deal, but now you know

OK, now it's up to you to choose

This book does not assume that you understand compilers or programming language theory. However, the beauty and eloquence of what the book is trying to teach you will be far clearer if you do understand these disciplines. This book teaches you how to build nondeterministic recursive-descent parsers. If you are interested in other kinds of parsers, then you need to consult another source. The classic source on these other kinds of parsers is "Compilers: Principles, Techniques, and Tools" by Aho, also known as "The Dragon Book".

This book explains how to write parsers for new computer languages that you create. Each chapter focuses on either background, techniques, or applications. A chart at the beginning of chapter one shows you which chapter focuses on each topic. Each chapter builds on the material presented in preceding chapters, so you should probably proceed through this book linearly. I review this book in the context of the table of contents:

1. Introduction - Just performs an overview of the book.
2. The Elements of a Parser - Explains what a parser is, introduces the building blocks of applied parsers, and shows how to compose new parsers from existing ones.
3. Building a Parser - Explains the steps in designing and coding a parser.
4. Testing a Parser - How to test a new language's features and also how to use random testing to detect ambiguity and other problems.
5. Parsing Data Languages - Shows how to create a parser that reads the elements of a data language. A data language is a set of strings that describe objects following a local convention.
6. Transforming a Grammar - How to ensure the correct behavior of operators in a language and how to avoid looping in a parser, which can follow from loops in a grammar.
7. Parsing Arithmetic - This chapter develops an arithmetic parser. Arithmetic usually appears as part of a larger language.
8. Parsing Regular Expressions - develops a regular expression parser. A regular expression is a string that uses symbols to describe a pattern of characters.
9. Advanced Tokenizing - Describes the tokenizers that are part of the Java programming language as well as the customizable tokenizer of this particular book. Tokenizing a string means breaking the string into logical nuggets so that you can define your parser in terms of these nuggets rather than individual characters.
10. Matching Mechanics - Explains how the fundamental types of parsers in this book match text.
11. Extending the Parser Toolkit - How to extend a parser toolkit which includes introducing new types of terminals or completely different parser types.
12. Engines - Introduces a logic engine, which is a piece of software that is able to return objects and groups of objects in response to a logical query.
13. Logic Programming - Shows how to program with facts and rules.
14. Parsing a Logic Language - How to construct a parser for a logic language. It shows how to build a parser for the Logikus programming language that was introduced in the previous chapter.
15. Parsing a Query Language - Constructs a parser for a query language. A query language parser translates textual queries into calls to an engine. The engine proves the query against a source of rules and data and returns successful proofs as the result of the query.
16. Parsing an Imperative Language - Shows how to create a parser for imperative languages. An imperative language parser translates a textual script into a composition of commands that direct a sequence of actions.
17. Directions - Points out areas for further reading and programming.

I used this book to create a parser for a visual language, and I found the instructions in this book very complete and helpful. I would recommend the following books if you are interested in getting deeper into the theory behind this book - "Programming Language Pragmatics" and also "Introduction to the Theory of Computation" by Sipser.

One of the best programming related books I have found. It certainly is one of the most original and most enjoyable reading materials I have found. And having read a lot, that says something :)

Steven provides the reader a strong Java framework for building your own language parsers, and contrary to some reviews I've found, he's right to do so, since he introduces a very complex issue simplifying it to the point that in just a couple of days you can write your own parsers.

This book is a member of a very few select of books that should be considered "Must Have". It's one of those purchases you will not regret.

I own arround 80 books about compiler/language design, and this is what I have to say about this book.

It's a FIVE star, if you are looking for a easy cookbook to deal with simple free text input in your application (e.g. a command line to enter commands in your application, or write your own scripting language).

However it's a ONE star, if you want to learn or write your own compiler or want to deal with very complex free format text input (e.g. a real programming language). This book doesn't really cover the theory behind parsing and scanning although there are some chapters about Logic programming.

Everyone can read this book. It doesn't rely on 'higher math'. It is not a dry text. With this book everyone can write a descent text processor.

The problem with this book (which is a advantage for novice people, and a disadvantage for people who want to learn something about compiling), is that this book rely on a parsing/scanning/interpreter framework/library of the author. This framework is not described in this book. You only learn how to use this framework. This is nice for people who only want to build a parser based on this framework, but a disadvantage for people who want to learn something about the theory or the algorithms (used in this framework or in parsers/scanners in general).

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.

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.

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.

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.

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.

Got this book for an object oriented programming class. I have had very little programming experience, but the book has helped greatly in both learning Java and learning some of the fundamentals of coding.

This book has an extremely dry writing style and often does not explain things well to a beginner. Additionally, the book is very "fat" and heavy especially when carrying it around or to class.

I bought this book motivated by the good reviews that i saw on amazon. I was very pleased not only with the wealth of information(Fundamentals, OOP, MVC, JDBC, JSP/Servlets, JavaBeans, Swing/Advanced Swing, Collections etc ), but also from the presantation which is consice and very easy to follow. This was the text that did it for me. I struggled with other texts and the presentation was always missing something to say the least. Thanks to this book i was able to move to the world of J2EE and my biggest problem was dealing with application servers than with the java language itself.
My current position demands some C# .Net development and once again i am struggling with horrible incomplete Books that neglect to provide the hole code assuming previous knowledge.
I thought that may be Liang has written something about C# (Unfortunatelly not), but i was sad to see that there is
some critism which i consider unfair -not so much for the author but -for those who are trying to learn java.
I dont Know how to strech this more but listen: There is no better intro
book in programming. May be an experienced teacher has objections about the right positioning of the chapters but believe it or not after reading the first 7 chapters you are able to skip to any chapter you want(At the beginning of the book there is a flow chart that helps you guide your study according to your needs). Also dont forget that it is a programming book which tries to teach tough theoritical ideas in a practical way and dont fool yourself that there is a
way for doing this without your ability to understand.
Finally i saw that someone suggests a well-Known book instead of Liangs. I already own that book and its really confusing . A ton of information mixing together without making a specific point. If you dont beleive me just check the review for the book.

I saw Dream a Little's review and came to the conclusion it may be peoples learning style that determines if they like this book. I am new at programming and the book used in the college course I took was Deittel's 7th ed. Java How to Program. This book left me with a lot of unanswered questions that other books I had checked out from the library could not answer. I was about to give up when I stumbled upon this book and was amazed and wishing I had found it sooner in the semester.
I found it explained a lot of the basics very clearly. It also had a lot more understandable examples given. Even though Deittel's book is over 1500+ pages it came nowhere near as good as the examples I found in Liang's approx 700 pages.
I was a bit spooked at the price when I bought it, wondering if I was going to regret it. But after using the book I concluded this maybe one of those instances where you get what you pay for.
Liang uses a lot of diagrams to show how the pieces fit together as well as simple to understand explanations.
If you are already a programmer in Java then I doubt this is worth the price, but for the beginner/novice who likes to see how the pieces fit together and wishes to understand why things go in the order they do, then this maybe the book for you.
If I later move to another language, I will be looking to see if this author has anything written in that category as well.

I highly recommend the Deitel Java: How to Program book instead.

Liang over and over again introduces terms that he has never defined. He does not tell you why code is the way it is. He is terse, and there is just no true explanation.

The layout of the text is also in black and green, and that's it. His code is hard to follow compared to the Deitel book.

I'm truly shocked at how people seem to like this book. It's unintelligible in my view. I dread reading it and actually read the Deitel book instead.

I love it; perhaps not at the top of tree, as some experts would say.

But I still think it is wonderful how the Scotland yarder comes to Poirot after "winning" the case on evidence, but still uncertain if he had the right man.

What "improvements" have been made for the Berkley edition? There are already major differences in punctuation, word choices, and scene breaks between the original Collins and Dodd Mead editions of this novel. There are further differences between the Dodd Mead editions republished by Random House/Avenel and the Dodd Mead editions republished by Simon & Shuster/Pocket. There are further differences still in the Signet, Bantam, and Black Dog & Leventhal editions. For every publishing house putting out her works, there seem to be a new batch of editors altering Agatha Christie's words and the sound of her voice. What's the matter with these publishers? Whose voice do they think we want to hear when we sit down to a novel by Agatha Christie? And what will she sound like twenty years from now? It's frightening that her estate has failed to see the importance of guarding her words as she wrote them. Please tell me I'm not the only one here who senses that a crime has been committed.

Hercule Poirot is bored, so he is delighted when he is visited by his old friend Superintendent Spence of the Kilchester Police. Spence has recently conducted an investigation into the murder of an old charwoman Mrs McGinty, in the village of Broadhinny. her lodger, James Bentley has been convicted of the murder and is due to hang, but Spence is convinced Bentley is innocent, and wants Poirot to investigate.

Poirot goes to stay in the village of Broadhinny, and soon begins to uncover reasons why other people might have wanted Mrs McGinty dead. While investigating the murder, he has to cope with staying at the dreadful guest house run by the Summerhayes, a couple who have no idea of how to keep house or cook an edible meal.

The scenes where the sufferings of Poirot at the guest house are described are among the most amusing in this very amusing book. There are many interesting characters, particularly the scatty but charming Maureen Summerhayes, whom Poirot likes in spite of her atrocious cooking. And there is the maddening James Bentley, the convicted murderer, whose unprepossesing character only makes Poirot more determined to prove him innocent.

One of the most amusing exchanges in the book occurs near the end: ' "Mon Dieu, how stupid I have been," said Hercule Poirot, "The whole thing is simple, is it not?" It was after that remark that there was very nearly another murder - the murder of Hercule Poirot by Superintendent Spence.' Enjoy it.

The large cast and the large list of suspects in this book make it quite different than most of Agatha Christie's works. It also has a very convoluted plot that is difficult to follow. In spite of that, I still give it four stars because it is written by Agatha Christie in her usual creative style. The book will certainly keep the readers guessing as they set out with Poirot to get to the bottom of an old murder case that has already been tried by the courts. A man has been convicted of killing Mrs. McGinty, but Poirot and Inspector Spence don't think he did it. When Poirot starts digging he finds ties to other much older murder cases, and it's a case of identifying people, some thirty years later. Another thing that Ms. Christie does so well is characterization, and this book is certainly no exception. I absolutely loved the muddle-headed Mrs. Summerhayes.

Written in 1950, MRS. MCGINTY'S DEAD was published for the first time in 1951. I like a lot this novel because Hercule Poirot appears at last as a human being in it. So we learn that the illustrious detective feels very old and that he appreciates the haute cuisine, particularly cooked snails. Look also for the character of Ariadne Oliver, Agatha Christie's literary double. The thoughts she formulates about Sven Hjerson, the detective appearing in her own novels, leave a bitter taste in the mouth considering the fact that Agatha Christie could say the same words speaking of Hercule Poirot.

Anything that requires getting a bunch of jars on the server classpath was deemed unsuitable for automated deployments. I wonder how people manage automated deployments and configurations, especially in a multi-server clustered environment.

This book is a joy to read. Object relational mapping is explained in a very simple manner. What I like about this book is that it explains a certain concept and then immediately talk about the specific use-cases when that concept/design may not be the best choice. The authors then give excellent suggestions and alternatives.

Very good reading material, simple examples used to explain complicated concepts. Writing style of the authors is also very engaging.

A very good buy.

This is the best book out there that explains in detail how JPA works with some good examples. I found the book to be well structured and easy to read.

I would recommend this book for anybody who is looking to work with JPA.

This books seems to achieve the goal it has in mind, that of providing the user with the information necessary to use the Java Persistence API. Unfortunately there are real problems in the execution of this book.

A book like this should not only be full of examples, but it should be structured in such a way that it is easy for someone using the book to duplicate the examples on their own system. This book fails to do so.

In chapter two we are promised a complete application using the new API by the end of the chapter. The source code is provided for the application discussed and it is a pretty good example of the API discussed up to that point. Unfortunately there isn't enough information for the reader to build and run the application on their own computer. There is no reason for this kind of omission this early in the book.

The problems with the book continue as one moves on. I recognize that the target audience for this book includes only professional programmers of reasonable skill. I consider myself a very good Java programmer. That doesn't mean that I want to waste my time filling in gaps that should have been covered by a book I already spent my money on. It isn't any excuse for the omissions in this book.

Pro EJB3 is a great book. Having been using it for over last 6 month on my recent project, I can definitely say that this book is invaluable.

Have been worked on EJB 2.x for many years and on several projects with different application servers (Weblogic, JBoss, WebSphere), I understand the basics of EJB. So I want not only understand the basic how-to in EJB3 and JPA, but also want to understand the in depth explanations on transaction, persistence context and different behavior in the new system.

The book explain all these topics very well. I had brought other book (hibernate in action with JPA pdf version), but found that book was too focused on hibernate (even I was a fan of the previous edition of hibernate in action book). This book is well focused on JPA,and I really likes JPA APIs.

The book author is really nice and accessible. I have emailed Mike questions and he consistently replied promptly.

This book worth the money !!!

Chester

Excellent technical code-oriented book, great learning tool for people interested not only in Tomcat but in writing either Java server code or servlets. Also a great book to better understand how to manage Tomcat. The author reviews in details the code and gives the whys of it. He goes step by step and gives you code that you can run to build progressively a web server. Even if Tomcat 5 is not fully covered (when is the next edition?), it is still a great insight on Tomcat and what's going behind the scene when you write a servlet.

Thanks so much for this hard work, I am waiting for the next edition.

I have been working in the past 4 years as an architect for several high-profile industrial strength web sites (i.e. 1,500-27,000 tps) and they all use tomcat for their back end. The common thing I have found is that out-of-the-box tomcat won't support this kind of transaction rate and some tweaking is needed. For example the threading model doesn't fly, and obviously stickiness isn't an option. I got this book to understand the code base better and to see where and how the modifications could best be made. This book is definitely for contianer/server engineers. I doubt' much bnenefit would come if you are just a servlet or jsp type. But if you are having performance problems, want to develop your own container, or are an architect for highly-scalable sites that use ro want to use tomcat then I recommend this book.

This is one of the rare books that pave you a way through the implementation of a major software product. The last one I read was Tannenbaums classic "Operating Systems". The Tomcat book is a lot easier to access: Tomcat is written in Java not C and the author takes a lot of trouble of making code iterations especially for pedagogical reasons. I do very much appreciate this. Both authors have a very clear style. They do not enervate and distract you with any vanity. You have ample time during the read for your own thoughts of how you can do better. Usually I found that my ideas were worse and I learned something more. Sure there are rather small questions of style. The code smells a little like C. There are very many if statements. Some routines are quite long... Still it is a pleasure to read the code.


In this book you learn a lot about the implementation of a major software project and a lot about production quality code. You do not learn how to install, administer and use Tomcat. Most is about Tomcat 4. Some ideas are given of the changes due to Tomcat 5. This is a Tomcat 5 aware book but not a book about that version. I am sure this book helps you to actually do extensions of the engine itself, though this certainly is not its main impetus. Be prepared for some very solid reading. Do not worry about the comments with regards to bad editing. The editing is more than adequate.


Much welcome improvements:
(1) Provide an overview of the major interfaces and classes. And provide the central sequence diagram. Put both at a prominent place in the book (maybe inside the book flaps). This should be straightforward and easy for the authors.
(2) Update the book to the newest version of Tomcat. I know this is really asking too much. It takes at least a full time week to read the book, to rewrite takes considerably longer. But it is clear that Tomcat 5 would require even more: an entirely new adapted pedagogically design of the book.

Tomcat is the most common container for Java servlets. Yet using all its power can be formidably intricate. To help you, the authors spend much space going over the interfaces it offers. Using these is an easy way for your servlets to avail themselves of Tomcat's functions.

Like writing your own logger, specific to your output needs. All it has to do is implement the Catalina Logger interface, and the container can run it. Or, you can use sundry default loggers that come with Tomcat.

The text shows, amongst other things, how Java's interface capability is a profoundly useful enabler of modular code. It lets you integrate easily with Tomcat, using a minimum of coding.

Having recently finished TCP/IP illustrated, volume 2, which is a line-by-line treatment of the BSD networking code, I was hoping that "How Tomcat Works" would be as thoughtful and as comprehensive a treatment of Tomcat's code. It wasn't, and it fell far short of my expectations. For the most part, the value of the book comes from the author's organization of the source code - first look at the connectors, then look at containers, then look at wrappers, engines, hosts, etc. This organization is valuable if you're just sitting down to dissect the source, since it gives you a place to start. Otherwise, though, the book didn't provide much information that the source code itself (freely available) doesn't. The authors just present the source code and say, "there you go. That's it". They don't delve into the why or the how - they don't show how the sources tie together or discuss areas where Tomcat might be improved (or why it can't be improved in an otherwise obvious way). All in all, if you're the sort of person who'd be interested in reading this book, you probably already know everything it has to teach you.

Zukowski's Java Collections is one of the best book i have ever read related to Java. It's a fabulous work by the author which explains and covers all the collections. However it doesn't cover more on generics just few pages related to this topic. The elimination of generics is acceptable in this edition. I am expecting the next edition of this book by Zukowski. I will advice any Java developers to own one copy of this excellent work in his library.

The authors have done justice to Java collections in this book. Should be in your desk if you use collections extensively

This book is the first real attempt at seriously covering Java Collections I've read. I felt the author could have included even more real-world examples, as far as advanced usage goes. But the author does illustrate topics effectively in the examples given nevertheless. Fair warning, though, this book is not for the beginner.

This book is well organized and is an easy to use reference. It has in-depth coverage of collection classes and their uses. Code examples are made very simple to understand and easy to follow because of UML(pictorial) representation. For advance developers, it's good to learn about the common mistake.

The sections on each collection interface and implementation form a great reference. You would learn to create multimaps and priority queues, through real world best examples. The book also offers tips on choosing an appropriate data collection type. Material on how different collections interact with threading particularly useful.

It's nice to see a whole book devoted to a fundamental but often underestimated subject in "commercial programming" like data structures and sorting and searching algorithms. (Ever heard: "well, let's just use and ArrayList, what else could we do?" or "will'll just dump it in a Hastable"). This book gives a very readable and clear overview of the main functionality of the Java Collections APIs and can make a decent introduction for someone just starting out with the language, but is definitely lacking depth and solid and interesting code examples and applications. So, I recommend the book only if you are a newbie to Java and data structures in general. Unfortunately, most of the books on Data Structures in the market will put you off with their pompuous academic style and horrible price, since they are created as textbooks to rip off CS students. A sound, detailed, no bs, up to date, code intensive technical text on the Java collections API is still sorely missing.

The best and most thorough treatment of transaction management I have seen. I've bought copies for myself and my engineers.

This book has the most comprehensive coverage of current transactional systems and standards in Java. A cursory look through the index might seem that what this book contains has already been covered in hundreds of articles, specifications and books - but that's not what it is about. Starting from the original transactional models, it's an entertaining journey through how they were mapped to Java, the integration technologies like JCA, till we reach WS-Transactions of today.

To take a simple example, the Java Transaction API is underspecified in a lot of places - creating an implementation of it which is capable of working with a wide range of transactional applications and resource managers is a big challenge. It's evident that the authors have actually worked on the transactional systems they talk about - because the perspectives presented in various parts of the book about the numerous APIs can only be gained from hands on experience.
I actually found reading this book fun - it does not read like a textbook, and that's a positive point - but it's definitely usable as one if required.

This book will get you started working with JTP... however, it's not going to get you through a professional application.

If you're new to a lot of transaction processing or just transaction processing in Java, this is something you've got to breeze through at least once. Once you start getting deeply into the nitty-gritty of your application, it's complexities, etc. you're going to find that the book starts to fall short.

It's not to say that the book lacks examples, it just won't contain what **YOUR** application is going to need. The book does not nearly do justice nor spend nearly enough time talking about the complexities you are going to run across when working with enterprise-grade transactional processing in Java.

Beginners: go for it
Intermediates: there's better resources, but it may be worth it for you
Advanced: ignore it

A great read, but it would be even better if the authors could provide actual examples of how today's popular containers like BEA WebLogic, IBM WebSphere, JBoss implements it ?

It would be a great help to solution architects in evaluating the feasibility of implementation.

This book gives a high level view of how transactional middleware is built for J2EE App Servers and containers, which I think is just the right amount that any serious J2EE developer should know.

More often than not, we all have heard that the J2EE application developer need not know the internals of of Distributed Transaction Processing. It should all be hidden/transparent. But I am of the opinion that transparent middleware does not translate into ignorant developer.

As a lead developer and architect for years, time and again I have encountered the developers who are cluless about how J2EE application servers manage transactions for them. Consequently I have seen them struggle with what would be a trivial problem had they known how these app servers handle transactions.

This book cannot make you a J2EE developer, but it makes you a better J2EE developer. Having the bigger picture of how things really work behind the scenes is a good thing and will give everybody a broader perspective of things and make people develop transactional applications with that awareness. Now that is what I call as transparency...

This book will make you appreciate the EJBs as you develop them and also code better performing EJBS. The concepts from this book will help you debug transactional, JDBC and EJB problems faster (The other alternative is really shooting in the dark !!).

I have seen developers "google" the newsgroups when they get weird application server exceptions without really understanding the problem or putting effort towards it. That is not the way to solve the problems. This book will make you think what your app server might have done when you got that weird exception, do some poking around and then google the newsgroups, which I personally think is the right way of solving problems arising in transactional middleware.

The book is not a easy read like those other "Head First" books. But the material that this book deals with is complex and I think authors have done a decent job of simplifying.

Couple of suggestions though:

1) The authors could have elaborated the first chapter more. It becomes very tough read at times, which can turn even some serious developers away.

2) The material presentation starts getting better as the authors get into JTA/JTS. JDBC-XA, EJB and JCA coverage is outstanding. Why cant the rest of the material be the same ?

3) I would also have preferred if the authors got down to building a hypothetical J2EE application server in a dozen or so Java classes and show how the connection pooling might have been done in that imaginary app server, how XA connection from a database driver is acquired, wrapped and show interaction of XAResource and Transaction Manager. Right now there is explanation and some code snippets. The reader is left with the task of connecting the dots. It was not difficult for me. But I guess, the authors could have saved me from doing that.

4) Some explanation of middleware data caching, its impact on data visibility and O/R mapping challenges would have been much appreciated.

Inspite of these missing pieces, the book is an excellent read.
I have recommended it to every developer on my team. The last thing I want is a clueless developer, who hides his ignorance behind the so called transparent middleware marketing campaign!!!