5 comments about Beginning J2EE 1.4: From Novice to Professional (Apress Beginner Series).

1. I was taking a college course using Wrox press pro to pro series book on J2EE and it was kicking my butt. I purchased this book and it was invaluable in breaking down concepts in an easy to understand manner. The book is well written and a great introductory text to J2EE, I highly recommend it for anyone trying to learn this technology.



2. Overall a very good book except for the errors. ;-) I would've given this book a higher rating if it were not for the editing.
   
   I read the book from cover to cover. The explanations are good but there are problems with the examples. It really is difficult to find a programming book that is not rife with poor instructions and/or examples that will not compile. This book is better than most but I am a rather unforgiving sort when it comes to code examples in a book. There is nothing more frustrating than spending hours on a problem that could've been solved at the outset with just a little more attention to detail by the editors.
   
   My setup is a Windows XP Pro notebook, jdk1.5.0_06 installed on C:\ (the root directory) and J2EE 1.4 also stored on the root. I am using Eclipse 3.1 for an IDE (Integrated Devlopment Environment). If you can avoid it, do not put any of your Java software in directories that have spaces in their directory/folder names. This will prevent problems you will encounter when entering commands on the command-line that involve using environment variables in path names (there may be other problems avoided as well).
   
   Here is a summary of some of the trouble I ran into. I would like to say at the outset that I DO recommend this book. Unfortunately there is no such thing as an error-less computer book especially when you are dealing with a technology that has not yet matured.
   
   The problems begin in Chapter 3 on page 54, #5. Compiling the FaqCategories.java resulted in the following message...
   Note: FaqCategories.java uses unchecked or unsafe operations.
   Note: Recompile with -Xlint:unchecked for details.
   To solve this problem I changed the following line of code...
   private Vector categories = new Vector();
   to...
   private Vector categories = new Vector();
   
   This problem occurred because JDK 1.5 uses generics. I guess I can't blame this one on the publishers because I am probably using a later JDK than they were. This problem comes up again in Chapter 4, page 108, Questions.java. You will need to compensate for the use of generics in JDK 1.5. So here is the source you should use for that example...
   import java.util.Map;
   import java.util.HashMap;
   
   public class Questions {
   private String topic;
   private int numTopics;
   private Map questions = new HashMap();
   
   public String getTopic() { return topic; }
   public void setTopic(String t) { topic = t; }
   
   public int getNumTopics() { return numTopics; }
   public void setNumTopics(int n) { numTopics = n; }
   
   public Map getQuestions() { return questions; }
   public void setQuestions(Map m) { questions = m; }
   
   public Questions() {
   questions.put("1", "How do I use implicit objects?");
   questions.put("2", "How do I use the JSTL?");
   questions.put("3", "How do I use the 'empty' operator?");
   setNumTopics(questions.size());
   }
   }
   
   
   I remember having trouble with the JSTL (Java Standard Tag Library) examples in Chapter 4 but unfortunately I did not make any notes for those problems.
   
   In Chapter 5, page 161, #3 I had a problem with the login.html page. I changed the following line...
   
   
   to...
   
   You may not have the same problem depending on your setup.
   
   I had the same problem with the code on page 192 near the bottom of the page. I removed '/Ch05/' from the path. The explanation on page 194, #5 is not good at all. It would've helped tremendously if they had included a better explanation and a screen shot.
   
   Want to get confused? Read the first paragraph under "How It Works" on page 204. The whole Filter topic needs to redone.
   
   In Chapter 6, page 243, the connection string they use is just plain wrong. Look at how they refer to the same snippet of code in the middle of page 245, that is the correct connection string. I have no idea how they came up with the one on page 243.
   
   In Chapter 7, page 263 in the middle of the page the variable declaration should be "String sql" not "String sdl". On page 274 I had problems with the command-line entries. I had to resort to using the App Server Admin Console. On page 275 the conn, stmt and rset variables are declared just before the try block and within the try block itself. I removed the words Connection, Statement and Resultset from within the try block. In the smae example I had to remove the semi-colon from <%= e.getMessage(); %>, it should read, <%= e.getMessage() %>. In page 289 replace "192.168.1.103" with "localhost". (Someone was asleep at the wheel in Chapter 7!)
   
   In Chapter 8, page 325 the Deploytool shows a "JNDI Name" tab. My version of the Deploytool does not have a "JNDI Name" tab but the same functionality can be found through a click on the "Sun-specific Settings" button. On page 328, the command line entry shown in #2 did not work unless I rebooted my computer first. It could be that if it doesn't work for you try stopping and restarting the app server. That may be all
   
   it needs. On page 337, #11, the second bullet, change 'Stateless' to 'Stateful' - then you will be in agreement with the session-type tag in the ejb-jar.xml file shown on page 341.
   
   In Chapter 9, page 359 - remember, if you do not have a "JNDI Name" tab click on the "Sun-specific Settings" button. On page 389 the "Try It Out" example does not point out changes that must be made in the source code from a previous example to make this example work. I had to
   
   download the examples from the APress web site to see that there were differences (normally I hand-poke all the source code examples to get used to the "feel" of the code - in this case that practice presented a problem).
   
   Chapter 10 became a problem for me because as with other places in the book this chapter uses source code developed in previous examples and builds upon them. Well, if everything went well for you with the previous example then this practice is fine but if you had problems that you could not solve then you are pretty much out of business in subsequent examples. This is where the authors started leaving out detailed steps because, supposedly, you already did those in the previous example. Well, what if you were just hopping around in the book? I don't
   like their practice of leaving out the detailed steps - put them back in, afterall its only a page or two here or there.
   
   In Chapter 11, the top of page 475, the command-line entries are wrong. Each option needs to be double-hyphenated and the option 'resourcetype' needs to be changed to 'restype'. Here is what the first command-line entry should look like...
   asadmin create-jms-resource --user admin --restype javax.jms.QueueConnectionFactory --property imqAddressList=localhost jms/QueueConnectionFactory
   
   In Chapter 12 there is a very long and involved set of steps to go through to implement a web service and then invoke a client application to use that web service. I got all the way up to the next to the last step and wouldn't you know it, the client app will not compile. It looks like a seemingly easy-to-fix problem but the solution is not readily apparent. The error is "Package javax.xml.rpc does not exist" but that class is in the application's project. Strange problem but I have not found a solution to date. So that problem mows down two whole chapters because chapter 13 depends on this example too.



3. The book is a very well-balanced introduction to many J2EE topics such as JSP, Servlets, JDBC, and EJB. Examples are "as simple as possible, but no simpler", and are quite useful for understanding the various topics.
   Obviously this book is now out in the newer edition that covers the much-changed and simplified (yey!) Java EE 5, but for anyone who would need to work with legacy J2EE 1.4 applications this book certainly provides good value.



4. I've had this book for a week now and I would love to be able to give a knowledgeable review but I can't get past the second chapter.
   
   Why? The second chapter details setting up the SDK but after many hours of searching I can't find anyplace to download it. It uses the first (November 2003) release of the J2EE SDK and there have been 3 updates since then. The current release uses an entirely different database with an extensively updated web server.
   
   I'm looking to familiarize myself with J2EE 1.4 and this appears to be a very good book for that, but it's going to be a major pain when I'm forced to use different software.



5. Being a beginner I was frustrated by other books before I happened upon
   Beginning J2EE 1.4. I'm only 1/4 way through the book but all the examples
   work and I feel I've already got my money's worth. I think after studying
   this book I will be able to go back to other beginning books and fix the
   reasons why their examples did not work for me.

5 comments about Data Mining: Practical Machine Learning Tools and Techniques with Java Implementations (The Morgan Kaufmann Series in Data Management Systems).

1. This book is actual a textbook for a data analysis course. We use it because the flow of the chapters is almost the same as the flow of the course material. Unfortunately, it is not as useful as expected if you are in the field. It is not in depth for the materials that the authors wanted to cover due to the fact that this is not a book for just programming or just statistics. If you have a strong background on machine language or a strong background on data analysis, you may not find it useful for you career. This book is for those who have limited knowledge on both programming and statistics, but not for professionals.



2. I've been working with "big name software" for some years, but when I joined the institution I work now and no tools where available I begun my quest for an open source tool that could help me build statistical models applied to real business problems.

   As a result of this quest I found the WEKA data mining software on the Internet (you can find it on www.cs.waikato.ac.nz/~ml/weka/) and that nice piece of software leaded me to this book.

   This book is EXCELLENT and I am giving 5 *five* stars to it as it helped me understanding the whole process of datamining: from loading the data to building the model.

   I've read some reviews and I think some of them are not fair (particularly one that says that this book have "just words with no relation or sense at all").. THIS BOOK IS REALLY WELL WRITTEN but you have to read it slowly: As when you study something.

   Buy this book (*don't forget to download the software*) and I am totally sure that you will be producing and using models in a week.

   Can't imagine that some weeks ago

   Cheers,




3. Witten's book, combined with the accompanying open source package, Weka, provides a great overview of data mining principles and practice from a machine learning perspective. One could hardly do better than to own this book and "The Elements of Statistical Learning; Data Mining, Inference, and Prediction" by Hastie, Tibshirani, and Friedman which covers complimentary material from the statistician's perspective. Witten does an amazing job of providing a comprehensive overview of the field while still providing some depth re. the algorithms; after reading the book I didn't feel like I'd read yet another large volume of empty claims about the power of information technology to make me rich and famous. In fact, with the book by my side, in a relatively short time I was able to use Weka to pry some useful information from one of my medical imaging data sets (maybe even enough to serve as preliminary data for a grant application). It seems to me that with an understanding of the material in this book and the one by Hastie et. al. one could embark on serious data mining projects.



4. I have bought this book as course book to learn some particular aspects of data mining.
   With the software that you can dowload you can do yourself all the exercices for every models presented
   It's the best way to progress
   Do the same, it's simple and funny
   The explanations are very clear and pedagogical, very practical



5. This book covers data mining at a serious level, including essential material on testing and a broad array of techniques. It is written for practitioners and provides clear explanation of included topics. Easily one of the best 5 books on data mining currently available.
   
   Note that this book has moved on to a second edition.

5 comments about Advanced Java(TM) 2 Platform How to Program.

1. This book was a text book for one of my advanced java classes. Unfortunately, there is very little to learn from this book. Filling the book up with pages of examples without sufficient explaination of concepts makes this book a complete waste of money. Most of the chapters were rushed, students will have a tough time grasping important concepts unless they buy some good books as well (OReilly, Addison-Wesley). I will not recommend it to anybody.



2. I am a big advocate of the HTP series. I've been reading this series since your 2nd Edition of the Java SE. I've also owned the HTP Visual Basic books when I first started programming. I don't think I have seen a better programming textbox on how to learn any language the "proper" way. It is because of the HTP series that with just an A.S. CIS degree, I am currently in a 6 month internship with IBM Global Services as a Java Web developer. The task given to me has been challenging. I'm responsible for migrating an ASP application to JSP and also developing another JSP application from the ground up.



3. Dont buy "ants" books. Terrible style, bad explanations, urgh ... There are a lot of tutorials to spend money for.



4. Book looked brand-new even though it was used. Very pleased with what I got.



5. this book is not suit for j2ee beginners, no detail explanation to build basic j2ee idea; but if you have some concepts about web components and ejbs but no sense in real world projects and how to deploy projects into a server, there are a lot of examples in this book, it is a good practice.

1 comments about Professional Java Native Interfaces with SWT/JFace (Programmer to Programmer).

1. One thing you gotta love about the Java crowd is their naming philosophy. Now there is SWT, the Standard Widget Toolkit.
   
   This book covers SWT as used in conjunction with Eclipse. It first compares SWT with other user interface packages, then it goes on to detail how to use the widgets to facilitate the writing of GUI's. It's a tutorial style book that completely covers Version 3.0 of SWT/JFace in a clear and informative manner.
   
   This book is timely, clear and well written. It will quickly get the reader up to speed on these packages.

5 comments about Concurrent Programming in Java(TM): Design Principles and Pattern (2nd Edition) (Java Series).

1. This book is great but don't read it as your first introduction to Java threads.
   
   This book is not about Java threads per se, but more about design patterns and good object oriented programming practices as applied to concurrent programming (hence the title). Doug Lea is a university professor and this book has a very academic style, including a ton of references to an impressive array of concurrency and object oriented research. While this makes the material somewhat dense, it is very thorough and thankfully supplemented by actual code snippets (Doug Lea also makes significant contributions to the Java SDK and writes great code).
   
   Especially notable are the sections on semaphores and locking in general. Users of util.concurrent (which directly supplements this book), and even the new Java 5.0 concurrency utilities (which were written by Lea and company), will get tremendous value out of these chapters as the locking strategies form the backbone of the higher level classes found in those packages.
   
   For beginners, read "Java Thread Programming" by Paul Hyde, and then try this book.



2. This is the best book I have ever read on threading, and certainly applies well to other languages naturally (especially languages with a modern and mature thread library like Mono/.NET). Unlike other reviewers here, I encourage so-called "beginners" to read this book. He has plenty of examples so you will not get lost, and this *is* the right way to do things, so start with this one.



3. This is a kind of book you'll need to start developing concurrent systems in Java. It shows details of what should be done to safely handle patterns for concurrent programs.
   I beleive this book is a must for every developer who want to start learning concurrency design priciples for Java.



4. Sure he knows his stuff but doesn't have a clue on how to write. This is appallingly poorly written. It is one of the most ridiculously disorganized collections of academic 'verbage' (verbiage subsumes garbage) I have ever read. It's almost useless as a reference: its very non-linear (say non-deterministic almost) in concept elucidation (perhaps he's taken the notion of multithreading too much to heart and tried multi-threaded writing???). It's useless as a book to learn from- since learning by example is not just a way to learn, but the only way to learn (Einstein) and this book largely disavows examples.
   
   What it needs is another edition with a ghost writer. Seriously it's not good. Try Paul Hyde for a good intro to threads.
   
   While those at guru-ish level may love this book, those of us for whom threads represent a means to an end, not an end in and of themselves, would probably want to throw this book in frustration of the author's inability to structure a coherent sentence with a clear point. This meanders on like great uncle herb's war stories and is equally will sapping.
   
   Avoid if you can or check it out when you reach guru-ness. It's a good cure for insomnia though.



5. The book contains a lot of concurrent and parallel programming theories, but the organization of the contents is not well formed, such that the reading and understanding of the book are hard. The examples giving in the book are not very helpful either.
   
   Overall, the book seems to target for academic researchers rather than developers. Highly recommend "Java Concurrency In Practice" which is much more practical and easier understood by Brian Goetz

3 comments about Java Programming for the Absolute Beginner, Second Edition.

1. This is a book oriented to the complete beginner. It basically starts with a blank sheet of paper and begins with a simple applet that just outputs a single line of text to the screen.
   
   From here he goes on to provide a very simply step by step tutorial to cover the fundamental rules of Java. In this book he doesn't get everything there is to know about Java. It's an introductory book, it covers the bases of the language well enough to get you started. You will probably want an additional book before you become the local master.
   
   If I have one complaint about the book it is one that I complain about a lot on Java books. On page 5 he starts talking about object oriented programming. And he talks on for two or three pages. Then he skips saying anything more about object oriented programming for about 160 pages. By then the reader has completely forgotten about the few pages on page 5.



2. When this book says it is aimed at the absolute beginner it means beginner to programming rather than a programmer with no experience of Java. The book's format of making the topic interesting by gradually building up examples that are games is a good concept but the book does not execute the concept very well.
   
   In practice the book launches into Java and programming in too complex a fashion for the total beginner, there are lots of abbreviations (often not explained) and it discusses terms and concepts that are not explained until a much later and do not need to be introduced this early. It seems odd to be using terms like how many bits a data type has without explaining the term, particularly considering the audience of this book. References to hex and octal are not explained, and as you go into chapter 3 the book covers methods of the random and math class before covering how to use "if" and even what classes are. The flow and structure of this book feels very awkward, covering try/catch and the basics of exception handling very early in the book before the total novice even knows WHAT you are trying to catch and why.
   
   The general jokey examples such as snippets of song lyrics and how to add comments around them, or a fortune teller routine demonstrating random numbers that print text such as "You will talk to someone who has bad breath" seem aimed more at attracting kids that want to write simple games on their home computers rather than someone who wants to learn Java and computer programming for professional reasons. If you are serious about learning Java, try the latest editions of either "Head First Java" or "Core Java" and skip this book. If you have never programmed at all, first try "Sams Teach Yourself Beginning Programming in 24 Hours". The Sam's Teach Yourself series can be rather hit-or-miss, but that particular book is definitely a hit.
   
   Since Amazon omits the table of contents I show that next:
   1. Getting Started
   2. Variables, Data Types, and Simple I/O
   3. The Fortune Teller: Random Numbers, Conditionals, and Arrays
   4. The Number Guesser: Using Loops and Exception Handling
   5. Blackjack: Object Oriented Programming
   6. Making Your Life Easier: The java.util Package and Generics
   7. Learning to Read and Write: The java.io Package
   8. Creating a GUI Using the Abstract Windowing Toolkit
   9. Advanced GUI, Layout Managers, and Event Handling
   10. Writing Applets
   11. Rendering 2D Graphics
   12. Animation, Sounds, and Threads
   13. Putting it All Together: The Block Game



3. This book helped me get my foot in the door for Java programming. Before this book, I was getting "stonewalled" trying to get started into Java programming. This book is aimed at people who want to start computer programming and is making Java their first language. May not be adaquate for experienced programmers who want to learn Java and already know programming conventions.

5 comments about Applied Java Patterns (Sun Microsystems Press Java).

1. Just shortly: Book contains all patterns from GoF book. Patterns are explained in more appropriate way and more closer to Java. Also examples are pretty simple and easy to understand. So the simplicity would be the best about this book.

   I also like that the the second part of the book: "Patterns in the Java Programming Language" where the author covers extra patterns used in J2EE which I find very usefull !

   I would like to see a CD or FD attached on the end of the book, although full code samples are also good (you don't need PC while reading the book). There is a web site to download examples and images and all fits on one single cheap floppy.

   Anyway the best pattern book for Java I saw. I have many Pattern eBooks, but all of them are either too simple (can't really learn how to use the pattern), or too complicated (e.g. GoF is complicated for me). So this remains the best for me.




2. I got the book before I had read the GOF book and found it quite useful. After reading the GOF book I found it even more so - I like the simpler examples and the fact that they are done in Java. Some people will not like the code reprint at the end of the book (about the last half of the book) - however I do, as it is quite convenient for referencing. Found the UML diagrams that were downloadable from the web reference site quite helpful.

   The major problem with the book are the errors! The first pattern I looked at (Visitor) had an extraordinary number of errors. In the text it gave the methods one name and used another name in the code listing. Two of the classes for this pattern the code was simply duplicated from a third class. The downloaded examples did have the correct code. Be nice if there was a CD - but this is no major issue.

   I would give it a 2 star at best, due to the errors, but if you can sift through the errors I think you will find it a nice supplement to the GOF book hence 3.5 stars (if I could).




3. After reading this book, I did not see the author tried any new way to explain how, when and why to use design patterns. I don't think the book is worth the moeny I spent buying it.



4. This is the Pattern book that can be made compariable with GoF's book -- Detailed and clear explanation of 23 patterns plus some system patterns. The full code examples can further illustrate the concepts in a modern view and benefitial to technical pattern design. Though it's Java approach, it can still work in other OO-related projects.



5. For the developer LEARNING Patterns, the Heads First book seems the most popular. But this is essential as a reference book. Premier examples, plus it reads more like a book and less like a math book (as most coding books are).
   
   I open this up from time to time to keep those patterns not used often fresh in my mind to ensure I will realize when one is needed.
   
   This is the first book that I go to for anything patterns, and I have a copy at work because my coworkers also come to this book when they need a refresher or reference.

1 comments about Professional Java User Interfaces.

1. Basically a good book, although I wish there were more code examples explained in the book rather than provided on the author's website.

5 comments about Java Web Services.

1. The content in this book is a little dated. For a current book on Web Services check out either the Wiley book (Developing Java Web Services) or my favorite Java Web Services Architecture.



2. Not that dated, you will get the background that is behind all the hype and you will get some hands on. Not a first choice but it is a solid review and a book I still keep on my desk. Get this and of course one of the newer titles. The new ones may be hyping something that isn't going to happen, at least with this one you will find most of the topics still are the cornerstones of web services. There is gold in them there hills, and those hills are strewn with books discarded too soon as old. Many explain things very well and offer knowledge. Nice book.



3. This book covers the topic of web services, primarily from a Java perspective. It assumes a familiarity with Java and XML so as to be able to follow the code examples. The chapters are as follows: Welcome To Web Services, Inside The Composite Computing Model, SOAP: The Cornerstone Of Interoperability, SOAP-RPC, SOAP-Faults, and Misunderstandings, Web Services Description Language, UDDI: Universal Description, Discovery, and Integration, JAX-RPC and JAXM, J2EE and Web Services, Web Services Interoperability, and Web Services Security.

   Review
   If you read the chapter headings and say "What does THAT mean?", then you probably have a reasonability good idea as to whether this book is for you. As stated in the preface, this is not a "For Dummies" treatment of web services. While it covers all the different technologies that make up web services, it does it at a pretty high level of detail with a lot of code samples in Java.

   The good thing here is that many of the examples are given using the Apache Tomcat server as the mechanism for processing the request. This is great in that you can download that software for free from the Apache site. This book doesn't go into detail as to how Tomcat is set up and configured, however. You need to work through that on your own. Once you get to that point, you can use Tomcat to play with the examples that are used throughout the book. While they can look complex and intimidating, you can learn a lot from them.

   As a Notes/Domino developer, I learned a lot by reading the book. Am I ready to start developing web services? Not hardly. But I do understand more of the concepts behind how they work. Since web services often use servlets to process requests, Notes/Domino 5 doesn't fit the traditional picture of the technology. But since web services usually involve SOAP XML statements sent to a server, there's no reason you couldn't program a web service in Domino as a web agent that runs when a user submits a web page or runs a URL that activates a server agent. The processing is done and then returned to the client as an XML page. Once you read and digest the basic concepts behind it all, it all starts to come together.

   Conclusion
   If you are a Notes/Domino developer who is trying to understand "web services", this book could be useful. The book gets progressively more complex and detailed, so you may find yourself skimming at the end. If you are to the point of being ready to run an implementation of a servlet and SOAP engine (like Tomcat), this book will help you get started with your understanding of web services.




4. I wish I could recommend a better introduction to Java Web Services. David Chappell usually does a good job at explaining new technologies in simplified form; however, he falls short with this one. It comes very close to being a step-by-step, build-up tutorial but falls short. If you already know SOAP, perhaps coming from the .NET world and you just need to make the right connections in the Java world, then this would be a good book for you. However, if you don't know SOAP and you're looking for a thorough understanding of what's going on under the covers before you move on to advanced APIs, then this is not your best bet. Actually, I'm not sure what is. I started writing such a tutorial myself but got distracted by other projects. However, this book is solidly average, nothing necessary wrong with that, and if you can find it at a good discount it's a decent buy.



5. I bought this, hoping to be able to use it on a web services project I'm doing.
   
   I find it's completely out of date. Both Sun's JWSDP and Apache Axis have moved on since this was written, and you'll get better information from their websites than you'll get from this book.
   
   Don't bother with it.

1 comments about Pro JSP 2, Fourth Edition (Expert's Voice in Java).

1. Java's web technology has always been my fascination. This book opened up a whole new perspective on Java and JSP for me.
   The book that I truly started learning JSP with is "More Servlets and Java Server Pages" by Marty Hall. That book breaks down piece by piece how it all works. It's a really great book. "Pro JSP" shows you how to exploit that knowledge to turn it into something truly useful. If you are a Java web developer you know that Java web applications can be slow and clumsy. Have you ever wondered how the sites like Amazon are written in Java and can handle millions of hits a day? Well, that book explains the technology behind those kinds of applications.
   The book makes very extensive use of EL (not something I am very fond of). It shows you how far you can go with JSTL by utilizing it in creating Java Server Faces. So it doesn't just tell you how amazing JSTL is because it can connect to a MySQL db from a jsp page (I mean maybe hardcore PHP programmers would find that feature cool. I don't). As far a JSF, the book shows very clearly how to do it. And you can easily try it out on your server. Still I do not believe the book does a good job providing examples of when you would really need the JSF technology. It's pretty much up to the reader's imagination. The book does a good job breaking down the use of managed beans in the context of JSF.
   I think the coolest chapter of the book is the chapter on filters. Let me tell you I still have hard time comprehending the entire filtering technology in JSP. It's a really advanced topic. I had no idea you could control users' requests to that extent. The book shows graphs on how requests to your web application travel through layers of filters. So it's really clear as to when you need a filter in your applications. And it's not hard to figure out how to optimize your application's performance using filters.
   I can really go forever, so I will stop here and let you see the rest for yourself.