5 comments about Mastering RMI: Developing Enterprise Applications in Java and EJB.

1. I agree with all the negative reviews already posted, but I was so frustrated with this book I had to add another voice of criticism.

   The book was obviously a manuscript dump with no editing that I could detect. Why Wiley thinks they can charge this amount for no work at all is beyond me. It is littered with grammatical errors, incomprehensible sentences, and annoying repetition. In short, it is nearly unreadable. To add insult to injury, there are countless summaries which condescend to tell the reader that she should now have a good understanding of the covered material, and can move on. Don't be so sure you will have a good understanding. I did not, and I've been using RMI for some time.

   As others have stated, the examples are contrived, and not very well written. There is very little here of use for those developing large-scale distributed systems.

   Save your money (considerable money, in this case) and stick to Sun's website.




2. As the title states Mastering RMI does contain all the information necessary to master the subject of RMI. However, the explainations are not as clear as they could be. And, I found the pictoral diagrams to be of little value. If you are looking for a book which simply gives you what you need to use RMI you may be dissapointed. This book provides COMPLETE coverage, including the underpinnings of the technology. While this may be interesting reading it tends to divert attention and time away from the practical aspects of RMI. If your one of those programmers that has the time and desire to explore all the nitty-gritty details of the subject, regardless of their immediate benefit, than you will probably find this book a good read. Otherwise, if you just want to get up-and-running with RMI their are simpler and quicker routes you can take.

   I hope this helpes :)




3. I totally disagree with the negative reviews on Öbergs book. I always admire authors who makes things easíer to understand, not making them seem more intelligent than they really are. A good teacher is one who can make things understandable, not the opposite. If you have read 3-5 RMI books before this one you may get disappointed as some of the other reviewers. It's an excellent intoduction to RMI, but don't expect to find some magical new/hidden, features of RMI here. Maybe the title should have instead been "An Introduction to RMI with Lots of Good Explanations." If you need an introduction to RMI, where you don't have to read a lot "between the lines", then this book is a good choice. I've stopped searching the internet for explanations about RMI after I got this book. There are lot's of hello world RMI introductions out there on the web, but Öbergs book goes far beyond them all. A good introduction.



4. I have been on RMI mailing list for half a year. This book clearly explained most of the frequently asked questions on the list. I think by reading first half the book, I understood RMI better than the half year I spent on RMI mailing list.

   I agree that some examples were not given enough explaination, especially non-RMI related codes. E.g, the IdentySocket
   .




5. I purchased this book after doing some research into RMI via the internet to give me a more solid understanding of RMI, which it did. However, when applying my acquired knowledge to a real-world application, I found that I was missing a HUGE piece of the RMI puzzle. RMI over the INTRAnet is a wonderful thing; however, when trying to implmenent RMI over the INTERnet, and the RMI server is behind a firewall, you are in for a painful migraine. This is a show-stopper for my employers, I wish that the book mentioned something about RMI and firewalls. There are workarounds for the firewall, but they are by no means easy and you will not find them in this book.

4 comments about Understanding Object-Oriented Programming With Java: Updated Edition (New Java 2 Coverage).

1. If you bought this book hoping to learn Java, prepare yourself for a convoluted mass of unrelated code and disorganized presentation of Java concepts. A language as horrible as Java requires quite a bit more background and basics on the tricks and traps of the language than this book provides, especially for those of us gifted enough to have learned C or C++ first. My advice for those wanting to learn Java is to get Sams Teach Yourself Java in 21 days; it is so much more thorough and complete, especially with important topics such as the AWT and Java event model.

   Considering the OOP side of it, the book was actually quite complete and thorough--assuming you are well grounded in the basic concepts of object-oriented programming first. Like too many OOP books, it is wordy, far too abstract, and chock full of all the annoying buzzwords and lingo that characterize the paradigm. If you are making the transition from structured programming to object-oriented, C++ is almost certainly better than Java, for Java forces you to program OOP. A C to C++ transition book is likely just what the doctor ordered. UOOP is not.

   And how would I know all this? My object-oriented programming class used this book.




2. This is not a book to learn java from, nor is it even a good reference. Read and understand the title before buying this book.

   This review refers to the previous edition to this one.

   I found the text ordered well, with most examples clearly explained. There were some minor bugs in the code which a beginning java programmer would struggle with.

   After finishing the book, and running the examples, and working through several of the exercises, I found that I understand OOP much better, and of course understand java better too.

   I've noted several people who don't know java syntax are frustrated by the book, as they are expecting to learn java from it, and are never reaching the point where they will learn OOP or java from the book.

   In conclusion, don't buy the book to learn java, buy it only if you need to learn OOP and are having difficulty doing so.




3. Though Mr Budd's language is a little abstract but he has presented the ideas to understand Object Oriented Concepts very good. This book is not for starters rather persons having little knowledge of object orientation can benefit from it a lot. I think this book is not a basic rather intermediate level book for understanding object oriented programming. Overall this is a good book and must be kept for reference purposes.



4. Don't buy this book if you're a beginning programmer or need to learn the syntax. I suggest learning that from the web.
   
   Budd has a way of explaining OOP that made it much clearer now even after hearing it explained at least a dozen times to me. The examples are solid and not silly.

5 comments about Java Transaction Processing: Design and Implementation (HP Professional Series).

1. 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!!!



2. 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.



3. 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.



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



5. 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

1 comments about Introduction to Data Structures and Algorithms with Java, An.

1. I have found this book to be an excellent complement to a book on coding in Java. It provides easy to follow steps for building classes and shows several implementations for building structures that handle the primitive data type 'int'. It doesn't waste time with a lot of scary details like most data structures books I have seen.

5 comments about Programming with Objects: A Comparative Presentation of Object Oriented Programming with C++ and Java.

1. This is a pathbreaking book that teaches Java and C++ as a package. I believe this is an innovation that should be universally adopted. Kak, who is legendary as a inspiring teacher, uses all his skills to abstract the main ideas of the two languages in such a manner that is illuminating.

   I recommend this book enthusiastically as a text for college courses and as a book for self study.




2. I have used this book as a text for my class. It helped me understand the concepts of Java and C++ better than the other books that I consulted.



3. 
   I took a C++/Java course based on this book and liked it very much.
   
   Of course, you will be better off if you get yourself two separate books on C++ (for instance, The C++ Programming Language: Special Edition (3rd Edition) ) and Java, but this one is as good as it gets in a single cover.



4. To put it simply, this book is the best book I have read on OOP. It will save you a LOT of time and annoying searching through the net to only read thousands of confusing and badly written explanations of the different aspects of OOP with C++/Java. It is also very good with the choice of topics. Highly recommended. The text is simple, terse, to the point and fun to read.



5. I'm not new to oop, as I'm a java programmer; I took this book because I had to study some c++ for a job interview.
   I liked this book from the beginning, I think the explanations are very clear and the examples go right to the point.
   The best thing about the book is that it's very detailed and precise, and it doesn't waste your time with ambiguous discourses (as many IT books do).

2 comments about Agile Software Construction.

1. The book takes far too favourable a view of Extreme Programming [XP]. It ignores increasing results from industry about the brittleness of XP. You would benefit more by looking up "Extreme Programming Refactored: The Case Against XP" by Stephens and Rosenberg. It goes into gory details about actual XP attempts, including the famous initial one at Chrysler.
   
   Which is not to say that Hunt's book is entirely wrong. Parts of it, like the need for unit testing, are not bad at all. It should be adopted in many projects. And the waterfall approach does have severe problems. But you can buy into agile programming without necessarily going to the extreme of XP.



2. This book ostensibly focuses on "emerging methods and approaches that are loosely described as Agile and shows how to apply them effectively...." Topics covered include Agile Modeling, Extreme Programming, Feature Driven Development, Agile Methods with RUP and PRINCE2. The author's a Brit (hence the reference to PRINCE2, pretty much unknown outside the UK). There's an overwhelming emphasis on Agile Modeling and XP and, although the books introduction states that it "....brings together a range of the most popular Agile Methods," Scrum, probably the second most popular Agile approach along with XP, receives only around one page and half a dozen cursory references.
   
   While the author emphasizes XP heavily, there is very little attempt to examine the limitations of XP. The coverage of Agile Modeling is pretty lightweight and it's not really a "how to effectiely use Agile" book either. Overall, my assessment is this is pretty lightweight, not especially usefuland there's better books out there that focus on how to introduce and use Agile effectively. There's also better "overview" books out there with a more inclusive coverage of Agile Processes and Approaches for those who want an introduction. And for non-UK reader, the PRINCE2 coverage is pretty much irrelevant.
   
   Not worth your time. Wasn't worth mine either but I'd already spent it so I thought the least I could do is spare others the pain. Sorry John. Better luck with the next one.

5 comments about Patterns in Java, Volume 2.

1. Around three years ago, I joked with a collegue of mine that a sure way to make a fortune would be to write a book which included the words "Java" and "Patterns" in the title. It would matter little, I argued, what the book contained. Just the title and a half-decent graphic on the front page would suffice.

   It seems to me that both Mr Grand and his publishers Wiley are attempting to cash in on this very idea. The problem is that the joke was a bad one in the first place, and that it is now being made far too late in the day.

   I hope that the software development community is sufficiently aware that it won't be taken in by this outrage.




2. This book epitomises so much of what is wrong in the software industry that I wonder if, in a sick kind of ironic way, that this is its only value?

   It cashes in on buzzwords in the title but is full of errors and demonstrates a complete lack of understanding of the material by the author.

   There is nothing to redeem this book. It is an embarassment.




3. After reading the GOF patterns book I felt I was ready to tackle on more patterns and bought this book. This book made me feel dumb for a while for after repeated readings I still couldn't understand what the author is talking about. Finally decided to research on what other people thought about this book. Glad to find mostly negative comments in this review section for it proves i'm not dumb.



4. In my opinion, code examples are just as important as the text that explains it. Unfortunately, the author didn't think so. Going through the book and visiting the companion website to get the source code to run was a waste of time.

   For the most part, the code didn't work at all! It didn't matter what compiler version you make use of; I used 4 different versions of the JDK. A book is supposed to save you time when you are trying to learn. This book doesn't fit the bill. I still had to go to the web in order to get working examples of the patterns mentioned in the book.

   I'm sure the author know's what he talking about. I just think that he should prove it by writing programs that are tested and that compile before shipping it off in a book.




5. My impressions:
   The introduction (UML short and SW Life Cycle) is excellent. I especially liked the collaboration diagrams.

   The 'GRASP' (patterns) present good guidelines that can improve your overall class design. (Which classes to introduce, how to distribute the tasks to be performed ...). To get the idea, it is of advantage, when you have previously designed a larger project yourself (seeing that there are many solutions that will result in different gains and tradeoffs). The GRASP help you to explain why.

   'GUI Design' improves your sensitiveness in creating user-friendly GUIs (choosing the appropriate interface design, presenting not more than 7 chunks, how and when to deliver feedback, ...).

   The chapters 'Organizational Coding' and 'Code Robustness Patterns' explain techniques how to write clean and maintainable code (like the usage of adapter classes, constants in interfaces, finally statements ...). Those will already be known by todays more experienced programmers. But only because of this, they will neither harm anyone nor will they be trash anytime! (Sorry, this refers to very rude other reviews - but it really has to be told.)

   From the 'Coding Optimization Patterns' i liked double-checked locking and the (maybe already known) lookup table technique.

   The last chapter 'Testing Patterns' is the best general introduction into testing i've seen so far (black, white box, unit, integration , system, regression, acceptance and clean room testing).

   Conclusion:
   When you come from the GoF book searching for further explanations buy 'Patterns in Java Volume 1' (notice the much improved 2nd Edition!), otherwise you'll be disappointed, here.
   The problem that Volume 2 has, is probably the (missed) target group. But it is not a bad book and Mr Grand knows what he writes, believe me.

5 comments about Java 5: A Beginner's Tutorial (Brainysoftware).

1. Really good text for anyone who is new to Java, it could also be useful to someone totally new to programming, but that someone will need to put quite some work into it, and must not expect a "for dummies" presentation style. Budi style is "friendly" but not simplistic, so do not expect to be entertained. This is a serious book, but it will get you from zero to a good level in Java programming. A "lighter" book might only pretend to teach you Java. I liked the "by example" approach that's typical of Budi's books, and the broad range of topics covered (beyond the usual core subjects, JDBC, servlets & JSP, security, networking). The strong point of this book is the way it manages to cover so many topics without being too superficial or dispersive or crushing the beginner programmer with too much material.
   I also liked the excellent introduction to interfaces and polymorphism (even if I would have liked to see a simpler discussion earlier in the book) and the treatment of generics and annotations. The chapter on exception handling should have probably been expanded a bit. So if you are ready to start playing with Java and are intimidated by the more ponderous tomes, but still want a book that will bring you somewhere, you can definitely begin here. As a final treat, the whole book is freely available online at jtutedotcom!



2. Well what can I say but this book will sit and collect dust. I was very disappointed with it. At the start of chapter one you actually write a piece of Java equivalent to "Hello World", but after that there are no other defined bits of code to write and learn from till sometime after chapter 4. I actually stopped reading the book after I finished chapter 4. It goes into detail about various aspects of Java but with no hands on examples; something you'd call a tutorial. I can not recommend this book as a tutorial but might make an okay reference.
   
   To nick-pick, where was the copy editor? There are grammatical errors around every 4 pages. It just became annoying.
   
   A solid thumbs down and spend your monies on another Java Tutorial book.



3. I don't buy/keep computer books any more unless they have the source code available. The first time I tried to download the source code, I got an error. So I emailed the publisher and got a reply back from the author. When I tried it again, the download worked the second time.
   
   This is my first try at learning Java--haven't programmed much for a while but I have programmed. I found the explanations were well written and to the point: not so much detail that your head swims but yet enough to point you in the right direction. Especially appreciate finding detail on enum--not covered in many Java books.



4. This book is a really good coverage of the java language. It covers the syntax, constructs and components that are needed to become comfortable with java code. And, what was the best part for me, why the constructs are as they are.
   
   The "java 5" is a bit misleading. The book is really a java tutorial which includes java 5 details where relevant. There are better sources if you want to read about java 5 enhancements.
   
   Of spacewise necessity, it does not address the nitty-gritty of programming and so is not a tutorial in the 'this-is-how-to-code' sense. Rather, it gives sufficient background for the reader to be able to make sense of java code, and to be able to intelligently google the nitty-gritty. Code examples are used to enhance description of language components.
   
   The book's title does not really indicate its contents. It is much more than just a java5 tutorial.



5. POOR AND VERY LIGHT ON CONTENT, INCOMPLETE
   
   This book is about Java 5, which contains a new concurrency package (new way of doing threads). Trying finding it in this book!
   
   I just looked at this book at B&N, but if you are a beginner, don't get this book. There are a lot of "bad" practices contained in it. The chapters on Servlets and JSP are examples of that. (Not even a mention of JSTL.)
   
   There are better books out there, Thinking in Java being one of them (and one of the best).
   
   (I did not look at the other chapters, but I've had enough just based on these three.)

1 comments about Concurrent and Real-Time Programming in Java.

1. The basic syntax of C++ gave us all more than enough rope to hang ourselves. Java took that rope away when Gosling removed templates, operating overloading, and added garbage collection. But then he backed up the rope truck and unloaded threads on us. Now I see far too many programmers jumping into the world of Heisenbugs by building threaded applications without the proper understanding of their best use.
   
   That's where this book comes in. It starts with the threading basics, but then goes on to show best practice strategies for the use of threads and architectures to manage threads. And what's more, the author gives us case studies that detail how these strategies and architectures are implemented.
   
   There was a desperate need for this book, and the author has filled the void with excellent material. I strongly recommend this book to any Java programmer using threading. Which is to say, almost everyone.

2 comments about Sams Teach Yourself JavaServer Pages in 21 Days.

1. This book from the beggining just throws concepts at you, assuming that you will understand what they are trying to say. Then go over so many things without a thorough explanation of the topic. It shows you code and then don't explain it. If you are a beginner don't even think about buying this book. I read up to hour 6 but I couldn't handle it anymore, there were so many questions unanswered.



2. This book does a great job at setting your environment for making jsp programs. You'll need tomcat, java development kit, text editor (textpad is great), and a whole bunch of setting up. This is one of the best books that guides you very clearly through those painstaking steps for beginners. I covered the first 4 chapters in several hours in one day and made a jsp application for a class assignment, and it was very easy to understand. It's targetted for beginners because it introduces you to programming concepts like loops, switches, conditions etc, java class compilation and execution, and java programming stuff. One of the easiest books to follow.
   Having said that, if your looking for an indept treatment of jsp this book only has a few chapters dealing with more comples stuff. Having some programming language concepts is always useful, or else you may have to do some background reading if you don't know how to make a program to find the factorial of an int.