5 comments about On to Java (3rd Edition).

1. Basically, what all those 5-star reviewers say is true, but they either didn't really work through the book or they are leaving out some critical information. I found errors in this book and when I tried to report them, the website listed on the back was no longer active and there was no response to emails. Months after reporting the problems, their site still said there were no known errors.

   Upon reaching the halfway point in the book, I found the project would not run as given in the text. I went to their website (which, like I said, appeared to be abandoned) and found some different code for the chapter I was on, but that wouldn't even compile! Luckily, I also had Geary's Graphic Java book and was able to get past the error using his approach. I felt that errors like this, along with the complete lack of support, were quite unacceptable from a second edition. Now they have a follow-up edition which appears to be simply rewritten for Java 2. The website referenced no longer exists and you now get redirected to Winston's book site, which does not even pretend to support this book! The last update to the known bugs was in 1997!!! I've sent him at least two emails on his errors since then!

   I also found the segment numbering scheme to be distracting and strange. The "segments" are 1 or 2 paragraph subsections; they are numbered sequentially throughout the book. The author will say "please refer to segment number 238..." and I see this more like a GOTO in programming and therefore a cop-out by authors that didn't want to bother with numbering sections in the normal manner. This is just a personal peeve and I would only take off one star at most for it.




2. This book is a wonderfully written book on the Java language. On to Java is a great reference book and perfect for just learning the language. The examples are easy to follow, and it does not make assumptions about programming background. Highly recommended if just learning to program or as reference book for those already programming.



3. There are more or less some differences among all the programming languages. One might think that being a veteran in one language automatically makes one the master of other languages immediately. Often, it's the minor syntax that are the easiest to get wrong and spent the most time debugging. This book will make sure you really know the nuts and bolts of Java; it doesn't assume some part is not important.



4. If your are an old C/C++ hand or if you learned Java a long time ago and did not use it for years, this is the perfect Java introduction for you. It contains high density contents organized in lists of items. No fluff just pure knowledge. Right now this is the first book I use to look up the simple Java concepts. I do not have to wade through long texts or examples to find or not to find something.
   
   If you prefer an easier paved or more pedagogical introduction you are probably better of with the books from Cornell, Eckel, van den Linden, which I use if I do not find what I look for in the Winston book.
   
   If you know have a good working knowledge of Java be warned. The content of this book is the basic and only the basic stuff. You might be bored by this book.
   
   If you have a grasp of the basics of the Java language, you should also learn a little about how to properly use Java and pick up a book like Joshua Bloch "Effective Java".



5. This is an excellent book for someone who already knows how to program but knows little about JAVA. Presents information simply and concisely.

2 comments about Java Methods : An Introduction to Object-Oriented Programming.

1. Wow! What a great book for learning Java! Whether you are a beginner to computer programming, or migrating from another language, this book has so much for everybody. Every chapter ends with a summary and a variety of exercises to test yourself (or your students) on the topics presented. In addition, most chapters have at least one Lab and/or Case Study to extend your understanding and your programming skills. The book however is just the beginning. There are numerous Internet references for support, edification and enrichment as well as a terrific companion web site devoted to enhancing the book. The web site contains sample programs from the book, "student" activities, "teacher" solutions, information on Java compilers and IDE's, appendices, I/O classes, etc. As a high school APCS teacher I believe that this book will be an excellent choice for any high school level programming course. The Litvins gently take the new programmer by the hand and first walk them through samples of code just glancing at the details and eventually exposing the full breadth and power of Java.



2. I am a math teacher who can program (not a programmer) and clearly the Litvins are experts. However, I have some terrific AP students (5's on the AP tests, 91% pass rate for over 6 years) and my kids really do not like the Litvin books, find them terribly confusing. We are trying out the Lewis Loftus book and liking it.

4 comments about J2EE Open Source Toolkit : Building an Enterprise Platform with Open Source Tools (Java Open Source Library).

1. This book is not only good conceptually and instructionally, but it's also a great reference text. Aside from reading very well, the content presentation is straightforward and concise. Using this book the reader can quickly throw together everything needed for development of this nature. The book is worth it for the chapter on developer tools (chapter 4) alone. After sitting down and going through it once, I was finally able to get a complete development environment up and running under Linux. I had made a few attempts before but couldn't set up the environment correctly nor had any good choice for an IDE. Under Linux (my preferred development platform) I had always just used the command line compilation tools and text editors (like vi). Now the IDE is set up and I can test, debug, write, and deploy code easily and I'm considerably more productive.
   The book is incredibly useful for experienced programmers and indispensable for anyone trying out Java and J2EE (particularly if you don't have access commercial development environment or testing platform... as a grad student I rely heavily on open source for development in all languages). It also explains how open source solutions can enhance production environments as well. And I've not found another reference that had everything I needed all in one place. This text is thoroughly recommended to anyone with an interest in J2EE or Open Source.



2. I would definitely recommend this book to developers or enterprises that need to build applications with limited resources.

   Having been the commercial app server developer for years (using Weblogic, JRun and Websphere), I was unaware of the capabilities of todays opensource app server. The capabilites and performance of opensource app servers like JBoss are well illusted in this book.

   This book also introduces the reader to a variety of opensource API's. Most of these API's are supported by Jakarta or Sourceforge projects.

   As it's name suggests, if you need opensource knowledge, start with this toolkit.




3. This book is perfect for anyone wanting an introduction to the capabilities of Open Source software. It is EVEN BETTER to help convince management on using Open Source. It clearly shows how to quickly setup a free, fast and reliable enterprise platform for your development team without spending thousands of dollars!

   If you want to have a professional level enterprise platform for you or your development team this book is for you! Using the book and the Companion website you can use all of the most popular open-source tools to build a single, integrated platform.




4. I tried to make myself read this book, but it didn't say much. Mainly a list of open source projects for a given topic. For example, templating engines, then proceeds to explain each one. This goes on for the entire book. Most of this information is available on the web for free. I wouldn't recommend this book.

3 comments about A First Book of Java.

1. Where to begin? Well, that appears to be the same problem the author of this text suffered, and was unable to resolve. The presentation is a bit scattered, and the exposition is confused and confusing. The simpler points are beaten to death, while the more esoteric issues are left unclear.

   Code snippets are repeated often "for convenience" (to save the reader flipping back a page, and coincidentally to add pages to the book), and many of the code snippets introduce very poor techniques, without cautioning that this is not the way to write real code.

   It seems that the author can't decide whether the book is simply an introduction to the language, or a first book on programming in any language. Sadly, it doesn't succeed in either way. The review of basic types is stultifying to those experienced in writing code, yet inadequate to those with no prior experience.

   If this were priced at the level of a "Dummies" book, it might be forgiven some of its shortcomings, but as it is intended for use in schools, and as I encountered it in a college-level introduction to Java, no forgiveness is possible.




2. The only reason I even bought this book was because my professor requires it for an intro to computer science class (which I'm only taking for a math credit). I may know a little computer science and be a bit advanced for this book, but this book is not a book for beginners, it's a book for stupid people who don't understand a thing.

   Small concepts which only take a few words or a sentence to explain the author spends PAGES explaining. The author is so verbose. It's a pain to read and that's why I stopped reading it.

   Also the example programs given in the book are often useless programs which do not reflect a real life application of arrays, objects, etc. I can't believe I paid $75 for this book. With that kind of money, I could have bought 3 REALLY good books from OReilly or something.

   The other reviewer is correct. The author beats the reader over the head on some concepts and spends way too much time on esoteric details whcih are nonessential to the novice programmer anyway.

   I only recommend this book to people who need something to put themselves to sleep with.




3. Not sure what the other reviewers have been reading. Overall, I think this is best text I encountered for an intro programming course. The author writes in a way that is concise and easy to understand. Further, it covers problem solving issues at a level that fits well for newcomers to programming. Bronson's coverage of input/output, is great.

1 comments about Java 2 Laminate Reference Chart (Quickstudy: Computer).

1. This guide is absolutely horrible. It is full of errors. Much of the example code is flat out wrong and won't compile.
   
   Two thirds of the first page is wasted with an image of JCreator and what each toolbar button is. JCreator is a fine IDE but not as popular (or useful) as Eclipse, JDeveloper or NetBeans.
   
   "Getting Started" - is there really any point to a history lesson of the Java language origins on a quick study guide?
   
   "Java Statements" - incorrect code examples! "break" is incorrectly capitalized and used as "Break". The example switch statement is passed a string with characters as the case options. Wrong! (switch must be passed a byte, short, char, int, enumeration or wrappers of these types - this is confusingly mentioned in an italicized note)
   
   There is no mention or example of a Java 5 style for loop. The example for loop is erroneous and fails to declare the type of the loop variable "i".
   
   "Java Operators" - the "not" symbol/operator is shown as an upside down exclamation point (Spanish?) rather than the correct normal exclamation point. This section probably should include mention of using .equals() rather than == for non-primatives.
   
   "Classes" - the first paragraph is poorly worded.
   
   "Did You Know" section - Why put this on a "quick reference" guide?
   
   "Scope & Reference" - the last bit #4 that tries to explain a passed object is very poor.
   
   "Colors" - fails to mention alpha which is perhaps the trickiest portion of dealing with colors.
   
   "Variables" - says to "see Data Types" but there is no section on data types! The note about converting an object to a primitive type suggests: "Integer.parsInt()" - parse is missing the "e" and this really should be "Integer.intValue()". "Integer.parseInt(str)" is used to convert a string to an integer.
   
   "Threads" - overall this is just a poor example. The example instructs you to put code in the stop() method. stop() is depreciated. What the heck is the crap in the run() method?
   
   "Applets" - modern browsers certainly do fully support Java versions later than 1.1. Applications could be written in any version of Java (they did not start with 1.2!). Why is mention of AWT in the applets section?
   
   I stopped at this point as it's obvious this guide should never have been published.

5 comments about The Essence of Object-Oriented Programming with Java(TM) and UML.

1. I really enjoyed this book. It was a fairly swift read and a good introduction to object-oriented programming and methodologies. It could have been better, imo. I recommend it, in spite of the criticisms below :).

   I wish the author had spent more time explaining how the example programs integrate with the MVC framework which he provided. Unfortunately he doesn't even provide that information with UML diagrams, much less discuss it in the text. It would also have been nice to have some discussion of how to extend the framework.

   In chapter 6, it was a bit confusing when he used the class MovieModel to model not a movie but rather an application to catalog movies.

   The included CD-ROM was missing the source code file for Listing 5.10, so I had to type in in by hand. Unfortunately the listing in the book has a couple of mistakes. The author's web site does not have the code available. Here's the corrected code:

   I apologise for the lack of formatting. Space constraints.

   /*
   * WmvcChkMenuItemCtl - implements JCheckBoxMenuItem controller
   * (c) 2001, Bruce E. Wampler
   */
   import java.awt.*;import java.awt.event.*;
   import javax.swing.*;import javax.swing.event.*;
   public class WmvcChkMenuItemCtl extends WmvcController {
   private JMenu myMenu; private JCheckBoxMenuItem checkBoxItem;
   // Constructor for JMenu item: JCheckBoxMenuItem
   // public WmvcController( JMenu menu,
   public WmvcChkMenuItemCtl(JMenu menu,String text,String icon,
   char mnemonic,String accel,boolean checked,WmvcExecutor wExec )
   {super((JComponent)new JCheckBoxMenuItem(), null, wExec); myMenu = menu;
   //checkBoxMenuItem = (JCheckBoxMenuItem)myComponent;
   checkBoxItem = (JCheckBoxMenuItem)myComponent;
   if (text != null)checkBoxItem.setText(text);
   if (mnemonic != ' ' && mnemonic != 0)checkBoxItem.setMnemonic(mnemonic);
   if (accel != null){KeyStroke ks = KeyStroke.getKeyStroke(accel);
   checkBoxItem.setAccelerator(ks);}
   if (icon != null){Icon theIcon = new ImageIcon(icon);
   checkBoxItem.setIcon(theIcon);}
   checkBoxItem.setState(checked); checkBoxItem.addActionListener(this);
   checkBoxItem.addItemListener(this); myMenu.add(checkBoxItem);}
   public boolean getState(){return checkBoxItem.getState();}
   public void setState(boolean checked){checkBoxItem.setState(checked);}
   public void setEnabled(boolean enable){checkBoxItem.setEnabled(enable);}
   public JMenu getJMenu(){return myMenu;}
   public JCheckBoxMenuItem getJCheckBoxMenuItem(){return checkBoxItem;}}




2. Learn the basics of MVC and UML in a movie catalog application. Clear representation of fundamentals of OOP.



3. The world of programming is changing, and in my opinion, the change is welcome. The Unified Modeling Language or UML used to be reserved for advanced programmers in large projects. However, the basics of the UML are easy to understand and provides an excellent way to represent classes and their interactions. Therefore, more authors of introductory programming texts are using the UML in their books. This is a welcome addition, and I am now puzzled when I see a book where it is not used. I do not understand why anyone would use the standard bubble tree diagram to describe inheritance when a UML diagram could be used.
   The next question to settle then becomes how well the UML is used and integrated into the presentation of the principles of object-oriented programming. My response to that question is also an affirmative. Wampler uses the combination of UML and Java to explain the fundamentals of object-oriented programming in a way that anyone with programming experience can follow. He also does not commit the error of using too much code in the book. Code is used only when necessary and only enough to make the crucial point. If there is a flaw, it is that there is not enough code in the book. There are times when I thought that an extra example would have been beneficial. However, that is a debatable point and not a serious flaw.
   If I were teaching an introductory course in object-oriented programming, this is the text I would use. The emphasis in such courses should be on the principles of object-oriented programming and not the features of a language. In my experience, students quickly learn the syntax of a language, but the organizational strategies used to make programs comes much more slowly. Wampler takes the right approach and I recommend this book to anyone who wants to learn object-oriented programming.



4. The world of programming is changing, and in my opinion, the change is welcome. The Unified Modeling Language or UML used to be reserved for advanced programmers in large projects. However, the basics of the UML are easy to understand and provides an excellent way to represent classes and their interactions. Therefore, more authors of introductory programming texts are using the UML in their books. This is a welcome addition, and I am now puzzled when I see a book where it is not used. I do not understand why anyone would use the standard bubble tree diagram to describe inheritance when a UML diagram could be used.
   The next question to settle then becomes how well the UML is used and integrated into the presentation of the principles of object-oriented programming. My response to that question is also an affirmative. Wampler uses the combination of UML and Java to explain the fundamentals of object-oriented programming in a way that anyone with programming experience can follow. He also does not commit the error of using too much code in the book. Code is used only when necessary and only enough to make the crucial point. If there is a flaw, it is that there is not enough code in the book. There are times when I thought that an extra example would have been beneficial. However, that is a debatable point and not a serious flaw.
   If I were teaching an introductory course in object-oriented programming, this is the text I would use. The emphasis in such courses should be on the principles of object-oriented programming and not the features of a language. In my experience, students quickly learn the syntax of a language, but the organizational strategies used to make programs comes much more slowly. Wampler takes the right approach and I recommend this book to anyone who wants to learn object-oriented programming.



5. I have gone through your book entitled "The essence of
   object-oriented programming with java and UML" and I
   must say that you wrote a very fine book.
   
   To explain my point and let you know what is good
   about it from my own perspective, I find it not quite
   advanced in its treatment of the JAVA language but at
   the same time it gives you a sense of knowing right
   from the beginning the very essence of the language.
   In addition, introducing in parallel the UML
   methodology helps a lot to understand the software
   "production" requirements.
   
   I have gone through several books for the last 5
   months. Each pretending to explain once and for all
   JAVA or UML. But your book is the only one I found so
   complete in its treatment of both OO, JAVA and UML
   (even though it is only 290 pages long !).

   Again, thanks for such a fine book and my best wishes
   for all your future endeavors.

5 comments about J2EE Design Patterns.

1. Old wine in a new bottle. Put simply there's nothing new in this book.

   If you are just beginning to wade through the vast land of J2EE, you will find lots of introductory material to help you get started. The preface pronounces the audience as Java-aware readers who may not be fluent with J2EE technology stack. Beginners will appreciate the slow pace, logically ordered chapters, thoroughly descriptive background information on every pattern presented and an entire chapter dedicated to UML. However, if you are familiar with the core J2EE patterns published by Sun, there aren't a lot of things in this book that will interest you. Some things worth mentioning are - strategies for content caching, Serizized entity strategy for rapid development, and use of soft references for being thrifty on memory usage. The chapter on Enterprise Messaging Patterns is particularly interesting since it is an area that has attracted some interest lately.

   Why another book on patterns? The bookshelves are already packed with several noteworthy titles on this subject and it is only natural to expect to see something new in new titles. This book is a far cry from "CoreJ2EE Patterns" or even the "Java Enterprise Best Practices" from the same publisher.

   They could have done a better job by cutting down on teaching the basics and including all of Core J2ee patterns. ACID transaction pattern isn't a pattern at all, but just a fundamental concept. The selection of best practices covered seems arbitrary at best.

   - Ajith Kallambella




2. There is nothing remarkable about this book. It loses momentum about halfway through. It isn't a big book and there doesn't seem to be much depth in the coverage. Look else where.



3. There are a large number of Design Patterns books available in the industry over the last decade. Crawford and Kaplan's J2EE Design Patterns offers a fresh look at the subject in both a practical and readable manner. Instead of just another catalog of design patterns, it provides insight into the real world scenarios of where these patterns can be employed. From a J2EE designer perspective, this book is a great addition to the study desk.



4. It's good for me because I'm still a beginner of J2EE, its focus on using servlet, jsp and JavaBeanIt's good for me because I'm still a beginner of J2EE, it focuses the patterns on using Servlet, JSP and EJB, it told that how to determine and improve scalability and extensibility, and how to model and implement the system. It is used UML diagram for represent the pattern; some of example covers few chapters to let the content easy to study, some of code is very common for let reader reuse in different application.
   
   -calendarw



5. This book could be an introductory book on understanding J2EE design and guiding principles but beyond that you don't find much help. The book has poor editing and repetitive style of explaining concepts which annoys experienced J2EE developers. If you are looking for J2EE patterns to support real-world implementation with exhaustive details then you must consider reading Core J2EE Patterns (Alur), Core Security Patterns (Steel) and Enterprise Integration Patterns (Houpe).

5 comments about Pro Jakarta Commons.

1. This is a must have book for Java Developers. I already have found many components/code that I can reuse to make my life easier. For example, the File Upload component is simple to use and saves a great amount of coding. The XML component (Digester) is fantastic! The author writes to the point and shows great examples. The examples on the Jakarta Commons website are lacking, so this is why this book is needed!



2. Jakarta Commons have done a superb job of harnessing the collective intellect and know-how of the great group of contributors who build them. I found Pro Jakarta Commons to be a great introduction to the commons classes. If you are like most working programmers,you will most likely need to use a few features in commons before you know much about them. Not only does the book do a very nice job of organizing the classes and methods in all of the commons packages, but more importantly, it gives you excellent examples to use many of them.
   
   Mr. Oak does an amazing job of "getting down" on this material. Diagrams, tables and lots and lots of Java code examples make this handy and a valuable keeper of a book. By definition, once a common package leaves the sand box and becomes production ready, they strive to keep the interface backward compatible so these examples will serve you a good long while. It's also a very good read should one want to go cover to cover as the writing is clear and has that "just right" balance of simplicity and detail.



3. Easy to use book, very clear examples. I now have better understanding of Jakarta Commons. Thanks Harshad Oak.



4. If you want a in-depth, head's down, nuts and bolts explanation of the Commons components, this is NOT the book for you. Doesn't even discuss some of the more powerful features of the Collections component such as Predicates and Closures.
   
   As for the other stuff, a lightweight overview, at best.



5. So I have had this book a little over a year and I come back to it time and again rather than going to the JC online docs. The book is reasonably well written but the subject matter is stellar. I am confident that using JC has given me increased confidence in my own projects and saved me countless hours of work. If you find yourself using other components that require the JC jars [Spring, XFire etc] and you are not using them yourself already, don't you think you could. Get the book and improve your code.

No comments about Delivering SOA Using the Java Enterprise Edition Platform.

5 comments about Advanced Java Game Programming.

1. This is not by any rate a book on advanced Java programming! It just has some very ugly 2D swing-based applications (you really cannot call them games..). Avoid like plague. Java game programming is still in a very immature stage but if you' re really, really looking for a decent book on Java game programming try "Developing games in Java" by David Brackeen.



2. Mr Croft explains his game game framework in this book. This framework is capable of handling 2D games via network, especially for mobile games. The book looks old fashing with a cumbersome layout and code examples which take a lot of space. Also the explained code seems to be old fashing, the new features of jdk1.4 are only mentioned about images, while the java.nio package is missing. Only some advanced topics are touched. This book is a good basic to enter the field of game programming in java, but doesn't lead you to the advanced topics.



3. I bought this book in hope to get some easy-to-use-library. what I found was a humble thing, written in old style that ignores modern java techniques (that allready were available long before this book was written).
   The concept for the "reusable library" is such stiff, that using it for anything but silly pre-C64-style 2D games, you have to dig into the (sparely documented) library code, which turns out to be nearly empty, creating hulls of hulls of hulls of classes supplying most basic features.
   Result of this is a collection of old fashioned (more than boring) games (hard to call them "games" indeed), that nonetheless employ a 1GHz machine to the limit (e.g. game "mars"). I profiled the game and found ~50% performance go into the artificial intelligence classes for 2 (two !) automated tanks humbly following my own tank and hardly able to hit me and ~40% for the 30fps crickeling of 12 sprites. The rest of the CPU power disapeared in the many empty hulls cascading to significant depths.
   Do not buy !
   PS: I'm an IT consultant since about 20 years now, who just learned his 18th programming language (java) and was in search of an out-of-the-box library !



4. You would assume by the title that this book was written for the experienced Java programmer who knows a little about game programming and wants to learn a lot more. You would be wrong. Instead the author wastes your time and his book's space with chapter after chapter of information that has nothing to do with Java game programming, much less advanced material. Chapter one, for example, is all over the map talking about XML, Ant, and upgrading to Java 1.4, which is no longer even the latest release of Java. Chapter two, which is labeled "Deployment Frameworks" talks about JAR files, applets, and Java Web Start. Other off topic subjects include a chapter each devoted to persistent data, the A* search algorithm, and HTTP tunneling. In fact, there are three chapters on HTTP. The few chapters that actually relate to Java game programming are not advanced at all to the experienced Java programmer who knows anything about graphics, Swing, and Java. Instead, the author spends his time talking about his own game programming framework that does nothing special and is constructed quite awkwardly from a software engineering perspective. There are two much better titles on the market right now. One is "Developing Games in Java" by David Brackeen, written in 2003. The other is "Killer Game Programming in Java" by Andrew Davison which was released in the summer of 2005. If you are serious about game programming in Java you should probably own them both, since they are both excellent and each has their advantages. For one, both show how to use Java's own features and API's such as Java3D and Java Sound to complement your game programs rather than reinventing the wheel such as this author does. I notice that Amazon has nothing on the table of contents for this book, so I offer it here for the purpose of completeness, and to help prove my point that most of the book is not applicable to game programming:
   Chapter 1 Development Setup
   Chapter 2 Deployment Frameworks
   Chapter 3 Swing Animation
   Chapter 4 Animation Library
   Chapter 5 Advanced Graphics
   Chapter 6 Persistent Data
   Chapter 7 Game Architecture
   Chapter 8 A* Algorithm
   Chapter 9 HTTP Tunneling
   Chapter 10 HTTP Polling
   Chapter 11 HTTP Pulling
   Appendix A Source Code Index
   Appendix B Introducing CVS



5. This has to be one of the worst programming books I've seen. I've been coding in java for a few years and recently got interested in trying to write some 2D games for fun so I got this book.
   
   The book is only useful if you want to know about the authors 2D game framework (which is horrible by the way) otherwise its useless. You won't learn much about 2d graphics in java, how to deal with images best (such as volatile images vs managed images) or anything else that is useful when trying to write a game.
   
   Also its beyond me why the example games are so awful....you'd think if you were trying to show off your framework you'd actually make something that was nice..instead of completely hideous.
   
   A much better book is "Kill Game Programming in java" by Andrew Davison.