No comments about Sacred Texts of the World's Religions.

3 comments about Concurrent and Distributed Computing in Java.

1. I bought this book because I was interested in implementing
   distributed algorithms. It has a good overview of the fundamental
   algorithms and I found it helpful to see actual code. It's the only
   book I know of that actually provides implementations rather than
   pseudo code.

   On the other hand, the algorithm descriptions were often condensed, and I
   expected a more formal approach. I often found myself reading eagerly
   to learn about an interesting variant of an algorithm only to find a
   reference to a journal paper. It would be useful to cover a few more
   variants more deeply.

   Also, I was hoping to get an idea of an algorithm's usefulness and
   performance in practice. Or is a particular algorithm more of
   theoretical interest? The answer was not clear to me, although in
   fairness, this was not the author's main purpose.




2. I got this book because I have been a fan of Garg's Elements of Distributed Computing ever since I first read it. Concurrent and Distributed Computing in Java seems to be really great buy. It has a very strong theoretical foundation, but the emphasis seems to be on writing distributed programs and getting them to work. If you are a theory lover I wouldnt recommend ths book, but if you like implementing stuff then you will definitely like this book. The range of topics covered is quite comprehensive given the size of the book.



3. I bought this book a couple of years ago now. Although it has some interesting discussion of distributed algorithms its big let-down is the abysmal Java code that it contains. I cannot believe for one moment that any of this compiles, let alone works - it all generally looks like pseduo-code written for the purposes of illustration rather being of any practical value.
   
   Likewise I didn't find the material particularly helpfully structured or consistent in its level of detail. I would have liked to see more quantitive analysis of the suitability of different algorithms in practical applications and broader coverage of well-known distributed algorithms (for instance paxos and virtual synchrony are conspicuous in their absence).

5 comments about Java Design: Building Better Apps and Applets (2nd Edition).

1. There are hundreds of books out there which deal with all of the low-level Java stuff, some of them excellent. I would like to echo the point made by some other reviewers that there is a shortage of books which deal with some of the higher level topics such as application design.

   I've been working as a Java programmer for about 8 months and I've worked my way through countless introductory books (Beginning Java 2, Horton; Just Java, van der Linden; Thinking in Java, Eckel - that type of thing). These books are great, and I now feel they've taught me most of what I need to know at that level, but I'm finding it hard to make the jump from knowing how to perform relatively small tasks using Java to designing large, complex applications. I know there is only one way to really do this - practice & experience - but I could do with a few books to help.

   I flipped through this book for about 10 minutes in the shop, and it seemed like it was just what I was looking for so I bought it. However, after reading it for a couple of hours I realised that it is in fact a bit rubbish. I was attracted by the chapters about design using interfaces, and there are certainly plenty of UML class diagrams featuring interfaces, but the accompanying text is so brief and so badly written that it is impossible to work out what points the authors are trying to put across.

   Furthermore, there are plenty of mistakes in the text and in the diagrams which in my opinion is just criminal - these concepts are extremely tricky to understand, and if you feel like you've grasped something and then you check out the next diagram and it's contradicted then you assume you must be missing something when you are in fact correct.

   I agree with other reviewers that this book employs cheap tactics: lots of whitespace, repetition, unneccessary diagrams.
   If I hadn't broken the seal on the CD sleeve before I realised this book was poor, I would have taken it back. £36.50 for a 300 page book too.

   what a swizz....




2. I just finished reading this book, and still can't describe "in 25 words" what it is about.
   I am not sure whether I am not ready for it, or the authors present their material in such a way, but I was put to sleep after about 20 minutes of reading. So I had to read in short sessions, and it took me a while to finish this book. And even though I realize that it does contain some sound design principles and some good ideas, I can't say that I have picked up anything that I am going to use in my coding practice.
   It's a bit unusual to me, but it feels like the writing style precluded me from picking up the useful information contained in the book.
   I think, I'll give this book another try some time later.



3. This book was a significant stepping stone in my development in OO thinking.

   This book immerses you in the thought process of OO. If you feel that you haven't quite clicked with OO design, and pattern books are leaving you puzzled, then read this - give it a month - then read it again.

   The you'll then probably think many of the GoF patterns quite obvious, and wonder what all the fuss was about. For example the Bridge pattern, and the Factory patterns are just implementing plugability concepts of Ch 3.




4. I read this book a few years ago and I remember it to be
   a pretty decent book on design. It doesnt claim to teach you
   how to do UML or Java. There are other books specifically for
   that. Highly recommended if you want to learn about good design.
   Books like these are *rare*. I am not sure what the reviewers who
   gave this a low score were looking for in this book.



5. To program effectively in Java, one should know the difference between Interface, Class, abstract Class, composition, inheritance, and polymorphisms.
   Most CS Java textbook lacks in explaining the differences.
   If you are a Java programmer, ask yourself the following fundamental questions:
   1. what is the difference between Java Interface and abstract class?
   2. when to use abstract class?
   3. when to use Interface?
   4. when to use composition over inheritance?
   5. how to check when indeed you need inheritance over composition?
   
   If you cannot answer all in clear way, you are missing very important things in OO design and Java's support of OO.
   
   This book is not for mere programmers or beginners. This book is essential for experienced programmers who understand OO and value object oriented design. This book explains those fundamental concepts in very clear and easy way to follow.

5 comments about JavaScript Application Cookbook.

1. After working through the first chapter (site search engine) I felt that this was a book work reading. It isn't a beginner's book, but anyone with intermediate javascript skills and an interest in using client-side processing will pick up a good amount of useful techniques and some needed perspective on how client-side scripting can be a powerful asset.

   The code could be better (as could anyone's). There is a strong focus on using local variables instead of global and the naming conventions make following the logic from one function to the next a little difficult. This, however, does not diminish the value of the concepts presented.

   To use the book, you "MUST" download the files. Not only are they a lot easier to read, you can comment them extensively as you go and pick up logic bits.

   An inportant suggestion is to not blow through the example application too quickly. If you take the time to take them apart, modify them and reassemble, you will pick up much more than just running them reading the code and moving on.

   I wish there were more books that presented the business functionality of javascript and how it can be used to handle many of the things that are being passed to server-side processing.

   I bought it, used it and would buy it again...




2. The text is focused on providing ready built constructs that can be applied to any website. In summary this book contains 11 application constructs. 3 are possibly applicable in todays world, albeit their relevancy is questioned, the other 9 topics such as text ciphers in JavaScript and Shopping Carts in JavaScript, etc. are completely unacceptable in today's world. Adding text cipher or Shopping cart logic in the browser completely exposes that logic to the hacking public leaving your site completely vulnerable to attack. Even in 1999, when this book was written, this would have been a ridiculous way of implementing these things. I must say I gathered no useful information from this text. And as for the author, anyone who had their site implemented by this person should hire a professional to correct the security holes he has most likely left behind.



3. This book fills a very nice gap in the world of JavaScript books. Most of the books either are basic "how to" learning guides or exhaustive reference manuals. Both of those types of books are necessary for a good developer, but there comes a time when you want to cross over from the theoretical to the practical. As in, "how would I do a function like this in JavaScript?"

   The "cookbook" approach is designed to take a common web site feature, like a search engine, and code a common JavaScript routine that would do that. You can then take the code in the book and use it with very little modification. In most cases, you would learn from the code as you are implementing it, and from there you can enhance the function to better suit your particular needs. You get the best of both worlds... You are quickly able to implement a function you are getting paid to build, and you are learning at the same time.

   I liked the piece on context-sensitive help files. Nothing is really complex or visually impressive. But it's core functionality that you can implement quickly, it's useful for the end user, and you can build on that technique both in your current and future applications.

   For Notes/Domino developers, you'll find a lot you can use here. Being that Domino functionality often translates to the web, you may find that a pure JavaScript implementation of a feature may not be the fastest or easiest way to build something for your application. You'll need to examine the functionality you need for your application and determine the best way to do it. But even if you choose to use Domino to accomplish some task, seeing the way to do it in JavaScript can help you expand your horizons and consider different approaches.

   Conclusion
   I would recommend this book as a practical supplement to a good "how to" and a good reference book. If you're just starting to learn JavaScript, you may want to leave this one alone for awhile.




4. As a javascript, I started using this book after studying Goodman's "The Javascript Bible", hoping to study some real-life applications. The code is nicely written and fully commented. But most of the examples do not work on today's browsers (IE6 and Firefox 1.0 when this review was written), so in this respect, the book is useless.



5. You do not want this book. Both the examples chosen and the style of programming used are ... nothing you want to emulate.
   
   In partial defense of the author, most (practically all) Javascript books are pretty awful, and at the time this book was written, there were few or no better examples.
   
   I was looking as an exercise to offer well-written rewrites of older poorly written examples. After scanning through my copy, realized that even the examples were not worth redeeming.
   
   The best Javascript book I have found so far is:
   JavaScript: The Definitive Guide
   (even in this book the examples are not often less than excellent.)

5 comments about Instant Messaging in Java: The Jabber Protocols.

1. I should not have started this book in the afternoon. I could not put it down. This is a very unusual book that teaches things that are Jabber unrelated. We participate in the construction of a Jabber server and Jabber client as we go through the book. The construction is not your usual namby-pamby baloney either. The construction, while not commercial grade, leaves us with an application which could easily be refactored into whatever you want to do with Jabber. Another good book by Manning. Manning is having quite a Fall in 2002.



2. A great book, very well written, and very intresting.
   Realy helped me to enter the new of world of Jabber, and to understand its internals.
   A must have.



3. Instant Messaging in Java is an excellant and informative book for all levels of programmers. If you are new to IM and would like a book that will catapult you into to this technology, this is the book for you. The program examples are easy to follow for if you have java experience. Also if you are an experiened programmer planning to implement production code the insights gained from this book are invaluable. Mr. Shigeoka has done an excellent job of stressing the Jabber protocols yet using java's multi-platform capabilities. Highly recommended!



4. Highly recommended for any developer with some Java experience who is interested in IM technology. Iain Shigeoka takes you through the background of the technology, and then takes you through an easy to follow guide to produce a fully working Jabber server and test client. The book also includes a very usefull reference section and stresses important issues relating to the technology. I have personally found this book invaluable whilst producing a Jabber framework as part of my dissertation, and has given me direction to further my knowledge in this area, buy the book!:)



5. I have read some of this book and I don't like it that much. I personally feel the author spends too much time with things that are pretty easy to compress.
   Looking backwards I think the Jabber documentation is enough to write an IM client. I wrote one for alarming purposes. This is the first edition and the book has plenty of errors in the text. ( The code samples seem to be O.K.). Obviously the author was so busy pushing out his book that he didn't let anyone proofread it.

   I would recommend to buy another book ( there are plenty ) or rely on the Jabber documentation and the plenty of samples the web has to offer.

1 comments about Java Applets (2nd ed) B&W: Interactive Programming.

1. "This book is a gentle introduction to the art of programming." (Quote from the preface) Well-said but way-too gentle for me. If you need to write and deploy professional applets, you should look elsewhere.

5 comments about Introduction to Java Programming (4th Edition).

1. You need to KNOW programming to read this book. It is not a almost perfect book but a very good book!



2. I've reviewed many of the Java textbooks on the market and have compared their coverage with the objectives of the Sun Programmer certification. I have yet to find another book that covers as much material in a well-explained manner. It does assume that you have programming experience. This is definitely not your Idiot's gude / for Dummies level of book. The book contains many, detailed examples which demonstrate effective use of code. If you want a reference book look to the O'Reilly series, if you want at textbook get Liang.



3. Things I dislike about this book:
   Cheap layout. Looks like it was desktop published by a so-so amateur. Black and light blue...how very 80's textbook.

   It's Virtually useless for the cetification exam (SCJP)...get Kathy Sierra instead. It's weak on threads and inner classes apparently don't exist. The explanations are not suited toward the beginner as they gloss or assume prior knowledge of many aspects of the language.

   Coded examples tend to be too hard for the beginner as they contain multiple concepts, which can confuse some.

   Things I like about this book:
   Coded Answers to ever other question.
   Some coded examples.

   In summary I wonder what the target audience is of this book. The beginner -> then it fails, the intermediate? With no inner classes and a weak treatment of threads...I think not...then who...certainly not the advanced Java programmer.

   I think you'd do better to pocket the hefty price of this booka nd spent it on something more apt (Java 2 primer plus isn't too bad, or Head FIrst Java for the novice Or Walter Savitch if you need a textbook).

   No, this book is just too expensive and too weak for what you pay. Even Deitel is significantly better. Look elsewhere.




4. Overall, this is a good book. I've
   gone through much of chapters 1-4, some of 5-6, and
   a little of chapters 17 and 19.
   Chapters 1-4 are solid and (I think)
   about at the right level for the intended
   audience. Some of the examples in Chapter 5
   (which focuses on arrays) are a little heavy.
   Learning Java arrays is difficult enough
   without adding concepts such as mean and
   standard deviation into the mix. Also, the
   two-dimensional array examples are probably
   beyond the grasp of most beginning students.

   Overall though, I'd give the book a thumbs up,
   so far. It doesn't make the mistakes that other
   Java books make, such as introducing GUI or Object
   Oriented concepts before teaching methods, loops,
   and arrays. For example, I've had a chance
   to look at the "Head First Java" book. I think
   it makes the mistake of introducing Object Oriented
   programming too early on. If you don't understand
   loops or methods, etc., then you can't work with
   Java objects. Further, the "Head First Java" book
   also goes out of its way to be funny. While I think
   there's certainly room for humor in teaching,
   most people don't set out to learn Java for the fun of it.
   They need to in order to earn a living.
   So, as dull as this book is, I'd recommend it so far.




5. This book covers all fundamentals of java programming.
   I needed more advanced topics and examples in OOP and threading using java

5 comments about Extreme Programming with Ant: Building and Deploying Java Applications with JSP, EJB, XSLT, XDoclet, and JUnit (Developers Library).

1. This book is a "must-have" for anyone who will be leading a development project, in addition to being extremely useful for any developer. The extreme programming section is wonderful - it does a great job of explaining a very useful methodology for delivering a successful, on-time, within-budget project. The book also thoroughly explains each topic (such as using Ant for compilation, unit testing, etc) and gives plenty of examples so it's easy to understand. I would definitely use this book every step of the way for a major development project!



2. Before I proceed further with the review, I should note that I am the co-author of Java Development with Ant, the book which has been the best selling book about Ant to date. Thus if I were critical of this book, you'd know where I was coming from.

   But I am not going to be critical -I am going to say nice things about it, and give it 5 stars as anything else would be unfair. This is a really good introduction to Extreme Programming in Java using Ant, Junit and XDoclet.

   After a quick intro to the concepts of XP, this book follows the story of a team that is using the XP methodology to get stuff out the door. First Ant is introduced, the JUnit -the latter being the key to test-centric development. Then as the chapters progress, the new problems are introduced and the code and the build process refactored and expanded to adapt. I particularly like the chapter where a business merger forces a team reorganisation -organisation change does effect projects, but most software engineering books ignore such events, along with team member dynamics in general. It also repeatedly reinforces the need for automated builds and tests, and has some basic coverage of CruiseControl. CC is the system that keeps our team in check: whenever you break the build, you get email. I get a lot of email.

   It doesn't go into significant depth in Ant -you will (of course) need the on line documentation, and I would also point my own book. Mostly this isn't an issue -the only place where I had significant differences of opinion was when the book recommended using the task to precompile JSP pages for tomcat. If the authors had tracked the Ant dev mail list, or the open bugreps related to this task, they'd know not to encourage that, because the underlying jasperc doesnt really let you. Also there was some commentary on Ant2.0, which is not going to be the complete rewrite promised on the web site. Again, involvement in the open source project would provide such information.

   These are minor issues with the non-core parts of Ant and the book. The central theme of the book: using XP, JUnit, Ant and XDoclet for building, testing and deployment of server side code is well covered, and that is what matters.

   If you want to get into Ant, this is one of the two Ant books to consider owning -ideally you should get both :) I think I'd also get one of the XP series books, like XP installed, for a more abstract treatise on XP, Fowler's Refactoring and a copy of IntelliJ IDEA, the best XP-centric IDE for Java.




3. Pros: Nice writing style, clear and not boring, touches not only Ant but quite a few other open-source tools and the Xtreme programming ways... Cons: its vast breath is counterbalanced by
   little depth. Ant 's coverage is appropriate to get you started working with it quickly, and to have you appreciate what this tool can do for you. Forget about being able to work with JUnit or XDoclet just by reading this book. You will barely discover that they exist.. and expect a lot of painful hours spent on the traditionally poor open-source docs.
   Overall a good buy though. If you want a more in-depth treatment of Ant I recommend Java Development With Ant
   by Erik Hatcher, Steve Loughran



4. As the subtitle indicates, this is a tools book, not a process book. Consequently, the XP practices are merely used as a motivation to introduce new Ant features into the build process - and sometimes this feels rather far stretched. In many cases, a good XP team should try a more team- and less tool-oriented solution than presented in this book. Also, the repeatedly mentioned "lead developer" coming to important decisions by himself feels quite contrary to XPs "Whole Team" practice.

   So the book concentrates on covering Ant, and starts quite promising in this regard. Using a case study to show how a build script can evolve with the needs of a project is a nice idea and the introduction to Ant is concise and to the point. Unfortunately, the book later starts to rush through the different topics, a big amount of it covering how to integrate different tools into the build process. There are also some much-less-than-optimal examples, which makes you wonder about the depth of knowledge of the authors; they even show a hand-made solution to implementing boolean attributes for custom tasks, even though Ant comes with a much more elegant inbuild mechanism.

   As an advanced "Ant build master", this book still taught me interesting new things about the tool. I'd guess that most beginners would be better off with a book more concentrating on the core concepts of Ant. If you want a good book on Extreme Programming, you will definitively have to look elsewhere.




5. Good book but no CD and can't find example buildfile online at samspublishing.com. Page 4 and Appendix D both say you should be able to download the examples.

1 comments about Modern Software Development Using Java: A Text for the Second Course in Computer Science: A Text for the Second Course in Computer Science.

1. This book gives insight to the reader that there is more to software development than just writing code or programming, going deep into best software development practices, explains the software lifecycle step by step, with sufficient examples and case studies. Although the focus is on object-oriented programming and mainly Java, with the appendix on Java preliminaries, the book is useful for anyone with a basic programming experience in any programming language.

5 comments about Java 2 and JavaScript for C and C++ (Programmers, Revised Edition).

1. The index is throughly useless, but otherwise the book is great. I gave it five stars because, for once, the examples really helped. He gives you a practical example of just about everything you could expect from a book of this size. Its easy to read - plus, its organized so you can skip sections you're not interested in and then later go back. I'd really like to see more books like this out there.



2. Read what I wrote about the previous, 1.2 edition here on Amazon. The book has not been changed much - it just has a new cover.

   What is missing from my review (the 1000-word limit has cut out the last 3000 words) is that the book is definitely NOT suited for a beginner. Just an example> check out the I/O and the AWT chapters. No beginner will understand them - even books like Lemay's Teach Yourself Java 2 in 21 Days are much more comprehensible.

   You can buy this book if you already know the language and are eager to discover the differences between C++ and Java (too bad only the first 4 chapters emphasize them, the other chapters spend NO words on C++ at all), you can give it a try. Or just get the previous (and, therefore, cheaper) edition, as it's alsmost the same as this one...




3. Although slightly thought provoking in its tactics, the main theses were misconstrued. There were many instances of erroneous teaching methods which led to unfavorable results. This book does have its bright sides, mainly pertaining to general layout of the book. The relation of Javascript to C++ makes the book very difficult to comprehend. Overall, as a Javascript programmer, I would not recommend this book to anyone.



4. I wanted a book that for an experienced C++ programmer that would not waste time teaching me what a class is, etc. It did that, but unfortunately covers waaaay to much ground to be really practical to learn how to actually write code without additional reference material.

   There are long coding examples presented with little explanation, which the reader is expected to spend hours deciphering and then say "voila, that's how it works."

   Major concepts lacking. For e.g, nowhere could I find an explanation of when you have to use "throws" in a declaration.

   The index is a joke. Try to look up Vector, implements, throws, Set...not there!




5. In the meantime, I've scrutinized the book more thoroughly. I've written the 1st review after comparing moslty the I/O and AWT chapters, the two being the worst of most Java books (and these two chapters are still as worse as they were in the 1998, Java 1.2 edition). As these chapters were similar to the previous edition, I thought the entire book is just a rehash too. However, other chapters are really updated, which I will also write about in the next review to be posted soon.

   Werner Zsolt.