5 comments about Java(tm)2: A Beginner's Guide.

1. This is very easy to follow and does not assume any previous prgramming experience for real and gives very good explaination chapter wise.



2. I disagree with those who have reviewed this book as suitable for unexperienced programmers. Java 2: A Beginner's Guide is a solid and well written book but in my opinion it is not a book for someone who has no or very little programming experience.
   
   The first couple of chapters are fairly easy to follow but later chapters become somewhat difficult for the novice. I would definitely recommend this book for anyone who has prior programming experience in Fortran or C but if you are looking to learn Java as your first real computer language you should look elsewhere first.
   
   I would compare Java to learning calculus. Something you really should not do before completing arithmetic or algebra. I would recommend getting your feet wet with something like RealBasic (www.realbasic.com) which, for example, introduces the concept of classes in a much more manageable format. Another great approach would be the programming language of 4D (www.4d.com). Both of these are available as free full working demo downloads and would give you an easier slide into the programming world.



3. If Herb Schildt wrote it, it's gotta be good. I find his explanations very accessible and easy to follow for this non-programmer. If it weren't for the explanations and examples in his book, I'd never have gotten a passing grade in my class. It was far more useful than the textbook (or the professor, for that matter).



4. I use this book as an alternative source for students in my introduction classes. They repeatedly give me excellent comments about this book. They consistently find the book helpful.



5. After taking a class on Java, I bought this book to review based on other reviewers comments and it's low used price. I was not disappointed. This is an excellent value for the beginner/intermediate. Written clearly and plainly there is no wasted space in the book. You will need another source for swing/graphics (perhaps the newer editions?) but as a beginner's guide this book truly delivers.

5 comments about SCJP Exam for J2SE 5: A Concise and Comprehensive Study Guide for The Sun Certified Java Programmer Exam.

1. This certification study-resource from Author: Paul Sanghera is a great tool for quickly getting up to speed in java with a view to taking the java programmer exam! As someone who recently succeeded at the SCJP 1.5 exam, i can vouch for this book. The following review is thus for those interested in preparing for the exam and not quite sure whether this book is the right tool for the job.
   
   As a green-horn in Java, I found the following 2 exam-study resources very useful in learning how to program in java, and taking the Sun Certified Java Programmer for J2SE5 certification:
   (Book 1.) SCJP Exam for J2SE 5. - (SCJP E5)
   (Book 2.) SCJP Study Guide. - (SCJP SG)
   
   Note: (due to review real-estate constraints, i shall limit this review to (Book 1) ie: [SCJP E5 (Sanghera)] -( the current book in question). you'll find a (Book 2) review on the customer review page for : SCJP SG
   
   Like most new-comers to java, I wanted to get-up to speed in java rather quickly. Therefore, the (SCJP E5) book from Sanghera was chosen as the first reading-reference, as it seemed concise, compact & condensed. However, if i had to do things-over, and choose which one book to use in order to scale the SCJP 1.5 exam -(whilst learning the Java language as well), I'd pick the [SCJP SG] from Sierra & Bates.
   
   Here's why...
   
   About the (SCJP E5) book : this book is great for beginners. i found that it brought me up to speed quickly Re: java, as well as preparing for the exam. However, unless you have previous knowledge & experience coding in java, you might need another book for deeper clarity and more rigor regarding 5 SCJP1.5 exam-objective related areas, viz:
   (1.) - Generics
   (2.) - Threading
   (3.) - I/O + Regular Expressions + Parsing
   (4.) - Packages + Jar Files & Static Imports
   (5.) - Exceptions
   
   Note that: while the 5 exam-objectives above are quite well treated in the (SCJP E5) Sanghera book, I found that the (SCJP SG) Sierra & Bates book, provided the finer level of details that i believe a beginner might further require in order to have a better grasp Re: these 5 exam-objectives cited above (AND) (the questions in the real exam do require this further finesse with those details).
   
   Otherwise, with the material in this book alone and without any hands-on experience, i reckon, a beginner might struggle a bit to pass the real exam by a comfortable margin.
   
   and this is why i cant give the book alone all 5 points of credit. (I would however award 4.5 points!)
   
   Upon completing the book, any access to good exam-revision practise material would be very useful in order to pass at the exam-level. while the (SCJP E5) book features useful questions and answers at the end of every chapter, as well as a further round of 73 questions in Appendix-D of the book; I believe people preparing for the exam would find it useful to seek out further resources for exam-question practise & revision purposes .
   
   As review-space is short, i shall include below only 2 of the exam-revision resources which really helped prepare for the actual exam (for details Re: The other key resource used, u might want to refer to the customer review posting for (Book 1): SCJP SG
   
   u might want to check these out:
   (1.) "Tiger notes" on JavaRanch. look under the SCJP FAQ section for : [Mikalai Zaikin's SCJP Tiger notes ]. You can get a paperback copy of notes similar to these on Amazon if you prefer. lookup: Java 1.5 Tiger. However, i'd advise that you use it only as a prep-extra, just to cross-check certain topical-details you may need to clarify ie: (java: "Exceptions"). I wouldn't recommend it as your sole & unique study guide.[ kittybooboo's notes ] on JavaRanch are also quite good.
   
   (2.) Turn to a SCJP Group for advice on the forums. They represent people in the same boat as those trying to prepare for and pass the SCJP exam. here are 2 such groups you can join.(Yahoogroups): Google: [" tech groups yahoo + scjp5" ]; (Another is): Google:[ "jchq + net" ] (-OR-) if you are preparing for the SCJP 1.4:( scjp 1.4 groups ) : Google:[ "uk groups yahoo + java_balk" ] ps: a good book for SCJP 1.4 is :A Programmer's Guide to Java Cert
   
   (3:) refer to my customer review posting for (Book 1) ie: SCJP Study Guide
   
   Schedule, Sit and Ace the exam in 2hrs:55mins, when you've finished with these various exam-practise questions and study-guides.
   The exam is comprised of 72 questions of which several are fashioned as drag & drop coding-scenario questions. Although, the pass mark is 59%, I think most people -(myself included!), view the exam as tough, because of its code intensive nature. I think reading, tackling & spotting possible coding errors in code-samples 6-30 lines long is tough under such time-constrained exam conditions, Plus, No credit is given for partial answers. However, on the up-side, it is do-able with the appropriate revision preparation regime.
   
   Curiously, in comparison, the previous SCJP exam ie: the SCJP 1.4 exam, is comprised of 61 questions , for which one has 2hrs to complete. Plus, the pass mark is 52%. That exam, is generally deemed to be an easier exam compared with the SCJP 1.5 exam; at least so attests certain in the user-community on JavaRanch.
   
   for those wondering, i took the SCJP 1.5 exam on March 19th 2007. the passing-score achieved was: 98% ie: (71 out of 72 questions ). The pass-mark is 59%.
   
   Good Luck!
   
   next stops: SCBCD, SCWCD, SCEA, SCJWSD.
   
   Cheers :-)



2. I have just passed the SCJP for J2SE 5 exam largely after preparing from this book. However, to be on the safe side it might be good idea to consider using more than one resource to prepare for this exam, because the exam is certainly not a walk in the park. I have read all the three SCJP for Java 5 study guides from cover to cover. So I would like to share my experience with these study guides in the context of both the exam and learning Java:
   
   "SCJP Exam for J2SE 5" (this book) by Paul Sanghera.
   I found this Study Guide the best among all, especially for the beginners. As another reviewer said the author has the unique approach of saying only what is necessary. He also has the skill of making difficult concepts easy to understand without compromising accuracy. The material is organized in such a manner that we also learn Java while preparing for the Exam. Because everything is explained from scratch, and there is no hopping from topic to topic, this book is especially suitable for the beginners. Here are some features in the book that I especially liked:
   
   * All concepts are clearly defined and explained by using visuals where necessary. It makes this book self-contained.
   *Tons of code examples explained in the book, which I downloaded from the book website and experimented with them to build confidence.
   * The Exam Quick Prep appendix. I went through this just before the exam to refresh all the important points quickly.
   * Exam's Eye View, Caution, and Notes throughout all chapters, which re-enforced important points.
   * An appendix that provides useful information and analysis for those who are considering updating the J2SE 1.4 certification to J2SE 5.
   If you are a beginner, this is your book. If you are an advanced Java programmer, this book will still take you through the exam without boring you.
   Bottom line: I agree with another reviewer that books like these are hard to find.
   
   "SCJP for Java 5" by Kathy Sierra and Bert Bates.
   This is a good book for advanced Java programmers, but rather over-hyped. If you are planning to buy two books to prepare for the SCJP exam, this is the second book I will recommend. However, this is NOT the book for the beginners. If you do not have intensive Java programming experience, do not use this book as your first book. If you want to use this book, first study Sanghera's book.
   
   "Complete Java 2 Certification" by Phil Heller and Simon Roberts.
   If you want to buy three SCJP for Java 5 study guides, this is the third one I will recommend. It does not do justice with some of the exam objectives. Overall exam coverage is not that great, but you will learn some Java topics.



3. This was the only book I bought and I passed the cert. I found the book to be generally good. I felt a couple of the examples were poor. For instance on page 141 the finding the area of different shapes, a classic example of where one should use polymorphism, the book provides an example of overloading operators. Yes, in the sense the code is "correct" but I find the misuse to be confusing. There are a number of items including some questions in the review exam that are just wrong. That is if you type the code in and run it you don't get what the book claims that you should. These do not seem numerous and I have not found any certification material that is without this sort of problem. The reality of preparing for the test is that if someones answer doesn't make sense you have to test it for yourself. It would be nice if publishers would hire someone to go cut and paste all of the code into a compiler and find this stuff.
   
   More importantly there is not enough material on generics and there is only ONE practice exam.
   
   Having complained I should and that the text is readable and helpful in preparing for the cert. I found it to be a good starting point for my preparations.



4. In the beginning of the year, Java equals "null" to me ( I know C/C++). I decided to learn the language and take the SCJP as a measure of my learning. I tried the Deitel book but didn't like it. Then I started to read the Kathy Sierra book, but they assume you know the basics (not my case). Due to the comments of one of the reviewers, I bought this book and liked it very much. I read it twice, tried all examples, fragments and tests and then went back to the Sierra book, which is more comprehensive (it is a much bigger book), has better explanations of generics and threads and has more tricky questions. I was able to pass the SCJP exam this month thanks to these two very good books.
   I do not give 5 stars due to the presence of several typos and some other minor errors in the text. These errata are not yet in the book site, but as you are studying for the exam, you will spot then when you compile or cross-check with the SUN Java documentation. But these are a small nuisance considering the overall value of the book.



5. your reading this based on my rating '1' stars.
   
   The book starts off good and explains OOP (abit) but the ending chapters which is the important stuff is like a "quick cram", you know, if your buying this book to get your SCJP - well, you need to know java, because in the interview you will be asked questions and your general knowledge of java will only do.
   
   if you know java GREAT - buy it, read it and after a few weeks of 'reading' - take the exam. CONGRATS
   
   BUT -- Please save yr/self the time which is the most important, to click the 'back' button on IE7 and search for a more complete title.
   
   just my input

3 comments about Java Programming: Advanced Topics, Third Edition.

1. This is the kind of book that gives you a ton of useless classes to install on your system, along with about 50 pages of how to install the ... on your computer. If you don't watch it or read the fine print, one of the IDE's that the accompanying cd installs, will go and screw up your classpath during its install. The simple installing procedure to install some jar files is so complicated that you will spend a half a day getting it installed. And once it is installed the docs, make it impossible to generate the docs you need to use the stuff.

   From the beginning of the book, there is no smooth transition about how to use java, it just jumps all over the place. The examples you are suposed to do in chapter 2, ask you to do IO things which aren't even covered until chapter 8....? Why do people do that?

   The writer of the book did not take the end-user into account, but just wrote to get the job done.

   It is a terrible book.




2. As Java is my sixth programming language I have a fair bit of experience with these type of books, and all I can say is that this is the worst I have ever come across. It has no sense of progression and it does not seem to have the idea of learning in mind at all - ie progressing from simple to more complex... It seems to be written for people who already know Java entirely and are wanting some kind of refresher, but its not very good as a reference either, so I actually don't know who would find this book useful....whats particularly annoying is that its not actually an advanced book, but the authors manage to make simple concepts as obscure and complicated as possible, so you struggle for ages trying to understand, and once it finally clicks, you feel almost cheated.

   The writing is very repetitive too - by chapter 15 why are they still telling you that "the structure of the package mirrors the file system, so you can find the code for this example in ...."before EVERY single code example? It sounds like a stupid complaint, but I swear that sentence alone is responsible for about 5 pages of this book.

   If you are forced to buy this book by your uni or college as I was, my advice is that you read it cover to cover several times, and don't be too concerned with understanding it the first or second time... you need the later chapters to understand the earlier chapters properly. I think the best way to read it is to start with the chapter end summary, then try and figure out the code example and discussion, and only after that confuse yourself with the actual chapter. It is not comprehensive and you are likely to spend a lot of time on the net (your cash would be better spent printing out Suns java tutorial) and using other books instead.

   It is also horribly biased to IBM VisualAge for Java, as Wigglesworth was one of the developers, and the first bit of advice given to me by senior students at my uni was to rather use anything else, even javac, than that peice of...

   To be fair, the questions are quite good and challenging, but as others have said, its kinda pointless without access to the answers.

   The unfortunate effect of all this is that you end up frustrated with Java itself rather than just this badly put together book.




3. This is a book for those who have a solid base in java now. Don't even think about using it as a beginner. I used it in a senior level course and it was the first book I worked with that dealt adequately with threads. Use this to polish your java skills. If you want a beginner's book try one of the head first books. The books that develop progressive skills are a dime a dozen out there, few will bring you into the advanced topics like this one does.

1 comments about Creating Mobile Games: Using Java ME Platform to Put the Fun into Your Mobile Device and Cell Phone (Technology in Action).

1. This is a pretty good book on creating mobile games for the Java platform. The author does not assume that you already have a working knowledge of the tools involved, so she starts by introducing you to these tools to give you a general idea of what is involved. Next she covers what you must do to set up your computer for Java Micro Edition game development and how to get your games running on an actual target device. Then, once you have your development environment up and running, you can begin building and modifying the book's examples. The book website at Apress has all of the source code for the examples available for you to download. The author assumes you already know Java programming with Java Standard Edition, and that you already know something about designing a game - this is not a book on the theory of game design. The point of this book is to show you how to do all of this with Java ME. Even multi-player gaming is explored by showing how to write a program for a game of checkers using Java ME. The following is the table of contents:
   
   1. Getting Started 1
   2. Using MIDlets 21
   3. Using the MIDP 2 Games API 53
   4. Using Threads and Media 95
   5. Storing and Retrieving Data 131
   6. Using Network Communications 193
   7. Advanced Messaging and Data Access 263
   8. Securing Your Applications 305
   9. The Mobile 3D Graphics API 317
   10. Adding a Professional Look and Feel 351
   
   You can carry some of the ideas into other types of applications, but this book is very much focused on Java mobile games. For that purpose it is highly recommended.

5 comments about SCBCD Exam Study Kit: Java Business Component Developer Certification for EJB.

1. I used this book as a primary preparation tool for the Sun Certified Business Component Developer (SCBCD) exam. Being a beginner in EJB, I found this book to be very friendly. I liked the layout of the book in general and the writing style of the author in particular. Only relevant pieces of code are presented to focus explanation of topic in question. A complete running application may be downloaded from the author's website. The multiple choice questions at the end of every chapter and ALERTs in every chapter made remembering main points easier. Deployment descriptor elements are clarified in considerable detail and they are explained well. Please note that there are errors in this book - some of them are fairly obvious such as using a capital letter as opposed to a small letter (Java versus java) while others are not so obvious but noticeable by experienced java developers. Regardless of its minor faults, I consider this book to be a valuable addition to my library. Normally I would have a cut a star for the errors but because of its content quality, I felt compelled to give 5 stars. I just passed the exam today thanks to this book. I know that I will not hesitate to buy another book from this author. Thanks Mr.Sanghera! I recommend this book highly without any reservations whatsoever.



2. This is a good book to learn the concepts of EJB but for the exam you need the HFEJB book.
   The details of Context objects (which method of Context object you can use in which method call of the Bean class) are more descriptive in HFEJB
   If you are planning to sit for the exam this book should be accompanied by HFEJB



3. What I was most impressed in this book was how clearly it's written and yet it goes deeply on those details that can always get you confused on a certification exam.
   
   I am very satisfied.



4. This book is an excellent read start to finish. Topics are introduced gradually, the same topics are dug dipper as we proceed. The author makes sure you understand clearly as we proceed.
   No confusions created with too many scribblings and notes, going back and forth; like in the "Head First..." I had to drop that one at end of 2 chapters, you can refer to that for some examples if at all.
   With this book I never had to refer to anything at all. I definitely recommend this book over the "Head First..."



5. This is probably where the SCBCD exam is, but I was a little disappointed to discover that it only covers EJB 2.0 and not EJB 3. Probably a waste of time for most people certifying on older technology when a new version is around.

5 comments about Beginning Java 2.

1. This book is very thorough in it's coverage. It doesn't delve into the "why" as much as the Head First Java book does, but it certainly tackles the how-to very well (at great lengths sometimes). It's also a different style than the Head First series of books. It has more of a traditional feel about it. Beginners that want to approach Java from every angle might do well to opt for both Head First Java and this book.



2. I had the previous version of this book and lost it so I bought the new version because I really liked the one I had. Unfortunately my experience has been a little different with this version. It contains a lot of great information however I think it may have too much in it for most beginners and novices. It is also a very thick book and takes up a lot of space when carrying around.
   The information is great in the book but it isn't something you'll be able to hold in with the first read.



3. This book is a great reference to Java language and how to program it. It also has an overly complicated/not well explained example in using ModelViewController pattern to program a shape drawing program. I also agree with other reviewers who complain he uses mathematical examples too much. Hint - if you hated geometry, buy a different book. But, if you have a sold HIgh School math / graphics background, I strongly recommend this book to learn a lot about java. It still is not comprehensive, but it's a great serious first book to learn java from.



4. I bought this book few years back to update myself on Java Knowledge. This book is very good, simple and details all the basics that is expected by any new java programmer. Those who know java can also use this to refresh their knowledge. This is a good buy.



5. This is a great book if your great with Maths, and like bland talk. I still think its an alright book, however I prefer working examples that I could take note off to use when I start my own proper projects. The ending chapter examples are not worded too well. At times I had to view Ivors solution to just understand what I had to do (and the solutions mind you, use things which you havent seen and dont get explained till much later on).
   
   The worst chapters for me so far are the File Read/Write chapters. They are really bland and there were a good 20pages with no coding just dribble talk about Bytes, Streams and how they work, these could have been done in 4-5pages, if this was so not only would it have uncomplicated things, it would have just made sense (for me I felt I went from one page and 2pages later ended back at the same spot). Now Im not the person who can exactly concentrate reading (reading isnt my thing) without doing some sort of exercise. And he seems to go over the same things (I will probably have to go back over a tutorial for File Read/Write).
   
   Now just because "Beginning" is slapped on the title, this is no way a beginners book, unless of course you consider the first 4-5 chapters the beginners part, which mind you they dont go full into OO and he says that you may need another he actually does quite a good job, and even though the examples cant do much with they are actually quite well thought out, the rest on the other hand require you not only to try and understand how he has worded things (maybe my brain is dead by this time after some bland talk), majority of the examples arent interesting either.
   
   Now if your thinking Im a beginner think again, I have been doing programming with PHP, Perl, C/C++ for over 4-5yrs so Im no new comer.
   
   If this is your first language, this isnt the book for you. If your not so great with Maths or havent done it in a while (like myself) this again isnt the book for you. If you have the concentration span of about 10mins before you feel like your going to go insane because your not coding this is defianetly not the book for you. If you can withstand it all you will enjoy this book and I have had some chapters which were pretty good. However I will be looking for another book as well as Tutorials to grasp the things which just got way over complicated (i.e. File Read/Write).

5 comments about Data Crunching: Solve Everyday Problems Using Java, Python, and more..

1. Gregory Wilson likes Python and bash but doesn't particularly care for XSLT (or Perl, and possibly Java as well, either), doesn't express a preference in the great Emacs vs. Vi(m) holy war, and divides programming languages into two camps - agile, like Python and Ruby, and "sturdy", like Java. He's an adjunct CS professor at the University of Toronto, a contributing editor with Dr. Dobb's Journal, and is developing "Software Carpentry", which is either a basic course on software development aimed at scientists and engineers for the Python Software Foundation or a project to develop a newer, easier-to-use set of software development tools.
   
   In the book, "Data Crunching: Solve Everyday Problems Using Java, Python, and More", data crunching is explored through a series of examples. The closest that Wilson comes to giving a definition is when, at the start of the first chapter, he refers to data crunching/munging as the "other 10%" of a programming task that takes up the "other 90% of the time". The first example that he gives is his experience helping a high school science teacher convert PDB (Protein Data Bank) files containing the coordinates of atoms in various molecules into a format that a Fortran sphere-drawing program could process.
   
   From the introduction, he moves on to the manipulation of text and text files using Unix command-line tools and Python, with Java work-alikes following most of the Python scripts. Although the book's subtitle, "Solve Everyday Problems Using Java, Python, and More", gives Java first billing (possibly for marketing reasons?), Wilson's preference for Python over Java is never in doubt. After presenting the Java equivalent of a Python script that counts the number of times every email address appears in a list of email addresses, he writes:
   
   All right. It's two-and-a-half times longer than the equivalent Python program, it isn't as fast on small files, and we have to compile it before we can run it, but other than that, it's almost as easy...
   
   With a table of useful commands, explanation of redirection and piping, and some guidelines on how to make sure that your command-line tools follow convention, the text chapter could actually be viewed as a pretty passable introduction to the philosophy of Unix.
   
   The chapter on Regular Expressions is great. So good, in fact, that I wish I could go back in time and give myself a photocopy of those thirty-odd pages at the point that I was struggling to get a handle on RE's some years back. Also included in this chapter is a brief, but very lucid, discussion of character encoding and a bit on using grep.
   
   Although the Text and RE chapters were my favorite, Wilson's clear and concise writing style makes th eentire book, including the coverage of XML, binary data processing, and relational databases, a joy to read. With segues like "But wait a second. Wait just one pattern-matching second.", lists of email addresses to munge that include entries for Alan Turning, John von Neumann, and Grace Hopper, and the like, he also manages to inject some pleasant, if a bit groan-worthy, humor here and there into what could otherwise be a rather dry book.
   
   He uses the last chapter, titled "Horshoe Nails" to quickly address a number topics, like encoding, the pitfalls of floating point arithmatic, and unit testing, which (not a surprise in a title coming from the Pragmatic Bookshelf) he likes, going so far as to say that the spread of test-driven development has been the "real revolution in programming in the last decade"). Diff is introduced and he brings the venerable make to the table as a tool for automating test running.
   
   He doesn't say it in so many words, though his retooling the old saying that "two years of hard work can save you an hour in the library" as "an hour of hard work can often save you sixty seconds on Google" comes close, but the message is to work smarter rather than harder. Use industrial-strength tools and processes when industrial-strength solutions are called for and agile, simplest-things-that-work solutions whenever possible.



2. Data Crunching by Greg Wilson.
   
   The book opens with a statement of purpose: transmuting data from one form into another. The focus is on problems where the hardest part is extracting the data, not problems where the hard part is processing it. Simple transformations and data grazing, rather than data mining, as the ideal problem for these techniques is small, separable, and useful in a variety of contexts.
   
   Major book sections include: Text, Regular Expressions, XML, Binary Data, Relational Databases, and a twenty page miscellaneous section. As usual for Pragmatic Programmer's books, the text is short, coming out at 187 pages, with source code on the web site. That regular expressions come up pretty much immediately tells us that the text will be unix-heavy. Not a bad thing, really, as a few simple unix tools can often save hours of anguish.
   
   Introduction:
   
   The introduction is clear on the intended audience. Read the nine pages, and you have a darn good idea whether the book is worth reading for your tasks. Among other things, the tools he strongly suggests installing - Python, Java, a command line xslt processor, a relational database, and unix command line tools - make it clear the level of this effort. No GUIs, no complicated database reverse engineering tools. Note also, no Perl. (For me, a bonus, but a deal killer for some.)
   
   Text:
   
   Early in the text chapter, the author spends some time examining a data file, then writing out the result. He makes a point of looking up a spec, then ignoring most of it. The YAGNI (You Will Not Need It, for grammarians) says that detailed interpretation of the spec is not as important as carefully making sure it reads the files you actually have to process. After all, your files may be misformatted, or may only use a small fraction of the specification. His example showed that three iterations through some samples got him just about everything he needed, in a very short time. He looked at the input file spec to see if there were corner cases he would need to solve, then focussed on the actual conversion he wanted to make. This theme recurs often - simple data cruncher programs need to be correct, but they do not have the same needs as a general data parsing tool. Do not try to solve every conceivable problem, try to solve the one you actually have.
   
   Interestingly, the author lumps Python, Ruby, and Java on one side, and Perl/C++ on another as far as 'thought collisions' go. Examples thus far include both Python and Java, with more Python than anything else. The Java examples are 1.2+ - using Java 1.5's autoboxing would have simplified several examples to roughly the Python complexity.
   
   The author is not sloppy, but he does take judicious shortcuts. Trimming a file extension in python, he uses a hardcoded three character extension, rather than the more correct .splitExt(). He then mentions that the more correct function required an extra library include, which would have cluttered the text. (The text does mention the more correct function in a sidebar.) A page later, he points out the perils of repeating yourself, and the kinds of errors it can produce. In other words, a bad file extension is likely to cause a visible failure early, while repeated code can lead to subtle bugs. This kind of tradeoff comes up a lot when coding; I was glad to see him make a point of it.
   
   Regular expressions:
   
   Regular expressions are, to my mind, one of the more convoluted topics that programmers encounter on a regular basis. Getting a deep understanding is worthy of a book in itself, and using Perl or Ruby properly _requires_ that understanding. Java now has regex support, though python's is easier to use. He references the standard book on the topic.
   
   The author tries to cover the 10% of the topic that you will regularly use. This will not turn you into an RE-master ready to tackle any Perl you happen to see, but it will be enough for the tasks he is describing. He spent quite some time describing character encoding, Unicode, ISO Latin-1, and the like, which was a welcome surprise.
   
   I note further that not a single Perl example showed up in the RE chapter. Many Python excerpts, some Java excerpts, a lonely-looking Ruby script, but no Perl. Made me happy, but this might infuriate a Perl aficionado.
   
   XML:
   
   The XML chapter goes into a great deal of detail on SAX. The author compares SAX responders to GUI event responders, which felt a bit strained. Most GUI responders do not hove quite the order dependency that SAX responders do. That said, the introduction was clear, and the limitations were explicit. While he did discuss the need to keep state, the discussion came later than I liked.
   
   The DOM section wisely uses language-specific APIs, like Java's JDOM and Python's minidom. I find tree-based APIs more useful than stream APIs in general, and this was a good, if brief, introduction to my most commonly used XML API.
   
   The XPath section is also brief, but clear. Much like the DOM section, the author mentions language-specific APIs. Since many DOM-like APIs have an XPath module, even programmers not planning on doing much with XML will still find it useful. The author draws a paralell to regular expressions - a rich, dense language that can select small pieces out of a large mass of data.
   
   Since I find XSLT a Martian space language, despite having used it heavily for several projects, I was pleased that the author's impression of it matched my own: "I don't really like XSLT that much". The introduction is clearly written, but unlike the other technologies, an introduction does not provide enough meat to accomplish a real problem.
   
   Binary Data:
   
   My rules of binary data: do not use it if you can use text, and if you must, try to find a library. This chapter mentions that on the second page.
   
   The 19 pages of this section cover binary integer representations, string representations, bit shifting, designing self-contained comprehensible binary data formats, and packing as much data per byte as you can. The author did not mention recognizing and parsing gzipped textual data, but other that that, this chapter had a good collection of useful ideas. I have found text, xml, and databases to be more important in my work, but binary files do come up. This chapter reminded my why I always get a sinking feeling when they do.
   
   Relational databases:
   
   This 30 page section gives a good introduction to the practice of SQL databases, using sqlite as the engine. Simple joins and normalizing tables showed up by the fifth page of the chapter. Between aliases, nesting, and negation, the author claims that you should be able to do perhaps 90% of the queries you will need. I rather agree - with the caveat that you do need to understand left and right, inner and outer joins, which are not covered. (They are footnoted to a reference, so expect to snag a good SQL book.)
   
   After joins, the chapter covers aggregation functions, views, and nulls. I give the author credit for bringing up the "Does NULL mean not present, or does it mean unknown" war. Most books take one side or another as gospel, or do not bring it up at all.
   
   A section on creating tables, inserting/updating data, deleting data and tables, and transactions follows. The examples are typical, and appropriate for simple CRUD apps, like many web apps. The author points out that data crunching is far more likely to involve selection than complicated create/update/delete logic.
   
   Finally, the author covers using SQL from python and from Java/JDBC. He also described the impedance mismatch between object oriented programming and the relational model. Wisely, he suggests well tested packages to handle that. I note that the vast majority of my sql has either been in scripts to set up test data or when I was writing an Object-Relational Mapping tool. The vast majority of my code that accesses databases uses well tested ORM packages like Hibernate. (I might have brought Hibernate up earlier in the chapter. Then again, for this book's target audience, perhaps not.)
   
   Odds and Ends:
   
   The final chapter has 19 pages on a variety of tools. The unit testing section discusses JUnit, Make, diff, and TDD. The encoding section discusses HTML escapes, base 64, and others. The section on floating point arithmetic answers the basic questions seen daily on Java discussion lists. Date parsing is discussed in sufficient detail, though I might have added an extra sidebar on just how bad Java's date handling can be. I have little to say about this section, save that it is worth the read.
   
   Final Thoughts:
   
   All in all, this book was well written, well proofed, and well designed. Like all Pragmatic books, it is available as both a downloadable PDF and a bound book. Errata and updates live on the Pragmatic web site. This is an extremely keen system - dead tree form for reading on a plane, PDF form for early access and up to date information.



3. The book presents the topics in conjunction with showing some practical data mining examples that any person might encounter. This book is recommended to people who are interested in basic parsing of data (text, XML, binary, etc) using python.
   
   I got the impression that the author was trying to cover too much in too little space. The title, for example, mentions Java, Python, and more. This is deceiving since the book uses python for about 99% of its examples. And while the book does present Java, it only does so to show that it would be easier to use python. Almost no other languages are covered, although there are some examples in Ruby and Bash.



4. This book is mainly concerned with scripting as a 'glue' between applications: processing various input and output formats. The book is divided into 5 main categories of data handling: plain text, regular expressions, XML, binary data and SQL. There is a final chapter on various miscellaneous topics. Most of the examples are given in Python. Some of the code is demonstrated in Java, although, disappointingly for a book published in 2005, none of the Java 5.0 features are leveraged. However, if nothing else, it demonstrates why Java is not anyone's first choice for such activities.
   
   If you've read any of the O'Reilly cookbook series, you will know what to expect, although the chapters are more cohesive and less episodic. Beginning programmers will get the most out of this book, although intermediate programmers should find at least some material here that's new to them.
   
   The XML chapter is a pretty good introduction the use and advantages/disadvantages of SAX and DOM, and XSLT is also described, although the discussion is not so clear. Those without experience with databases will welcome the chapter on SQL. The discussion on dealing with plain text files in chapter 1 was highlight for me, a subject not often covered in much depth in cookbooks; if, like me, you still regularly need to convert between various plain text formats, this chapter will help formalise approaches that you may already be carrying out in a less than rigorous fashion.
   
   Additionally, the paragraphs on floating point arithmetic were intriguing but all too brief. The chapter on dealing with binary is fairly good, although rather dry. Peter Seibel's discussion of binary data in the context of writing a Shoutcast server in Practical Common Lisp shows that the subject can be dealt with in a more compelling fashion. That said, for the most part, author Greg Wilson is a genial companion; the writing style is chatty, but doesn't overdo it.
   
   Overall, if you own any cookbook-style books, there is little here that you don't already know. Even for a beginner, it's hard to see how anyone who decides they need this book hasn't already been exposed to some of the material here. In particular, does anyone really need yet another introduction to regular expressions? The treatment here isn't bad, it's just that this material is already covered in many introductory programming books (especially those that cover scripting languages like Perl and Python). As this takes up nearly 20% of the book, and there's less than 200 pages, it's a bit of a waste. Personally, I would have preferred more discussion of the less well-treated subjects, some of which are too sparsely described, but this would have detracted from the book's main aim.
   
   This would be suitable for a beginner Pythonista, who for some reason didn't want the bulk of the likes of Python Cookbook. Otherwise, if you feel that some Pragmatic Programmers books can be rather lightweight and somewhat overpriced, this will not change your mind.



5. Some of the best technical books are short, clear, easy to understand, and practical. Greg's book falls into this description. This a great book for exploring algorithms in the python language. The book assumes the reader has at least a basic understanding of the python programming language or some programming experience. I was delighted that topics were presented in a concise and unambigous way and that the book was short. There should be more short books published!

2 comments about Practical Ajax Projects with Java Technology (Practical).

1. I have read some AJAX books and enjoyed them, but they typically concentrate on the client side and coverage of what occurs on the server side, if any, is generally PHP or a smattering of almost anything. But I'm a Java guy. The book I've been looking for would have not only the server side examples in Java, but would also use Java as the basis of discussion on client-server communication and the tools available to ease the whole process.
   
   The examples cover a variety of interesting projects and technologies, but the coverage of CSS, JavaScript, Servlets etc is very light as to be almost non-existent. Some of the sample code has been cut and paste without too much scrutiny, so they are often bloated by useless or even empty javadoc blocks but this is more of a annoyance than a real problem. Appendix B has several pages of useful links, but I would have liked to have seen this as a closing chapter of the topics that didn't warrant complete coverage.
   
   Interestingly, while core AJAX books tend to favour the client action and be light on what happens on the server, this book leans the other way. If you are looking to buy a single book to cover AJAX this will cause you a problem, but now that you are fore-warned if you get the correct combination of client and server AJAX coverage you'll be well served for your future needs.



2. The book begins a three chapter introduction about the involved technologies, Ajax basics and maybe even more important the concept of Web 2.0 and its ongoing evolution. When people think about Ajax they often think 'no refreshing', 'cool widgets' and 'flashy stuff', but nobody really thinks about desktop application architecture within the webbrowser. And Frank Zammetti finely points this out.
   
   The chapters following the introduction are about fully working projects (a project per chapter). Every project uses a different Ajax toolkit/library or combines them differently. For example there's a very good introduction project on how to use DWR or Dojo (though Dojo's full capabilities are not used). Frank also goes into the details of the communication between server and client using XML and JSON. At the end of every chapter, he gives you a couple of suggestions for improvement so you can go at it yourself with your newly gained knowledge.
   
   Not all is perfect though; From the project chapters on, Frank just goes into the details of the project but fails to put it in a context; he doesn't for example explain why a certain Ajax webapplication has 'windows' using divs or why/how/if separation of responsibly is needed (like MVC). It's just the way it is and he only explains the mechanisms. I would've liked his opinion, both conceptually and concrete examples of how he thinks an enterprise web application should be implemented (for example DWR is an excellent candidate as Controller in the MVC marshalling between client and web).
   
   On the Java side he goes into details on how to set up the server (web.xml etc.) and how to configure some toolkits in there (like dwr.xml with DWR). Configuration aside, he explains his server-sided application logic for every project. Again, he just goes into technicalities here and leaves the architectural concepts behind them untouched.
   
   All in all a good book to read; to get introduced to many toolkits and gain awareness of what Web 2.0 really means.

3 comments about Pro Apache Tomcat 6 (Pro).

1. I have read this book cover to cover. It contains plenty of useful technical info, I learned a lot, and so I give it 3 stars. Boy, was it tedious reading though! The grammar is broken in many places. The style is rather stiff and tiresome. I do not blame the author though, and I wish the editors and reviewers did better job prior to bringing this work to the public. Yeah, even hackers and software geeks appreciate good writing! In fact, it is quite evident that Chapter 14 "Testing Tomcat's Performance" was written by a different writer than the rest of the book. A breath of fresh air! This chapter reads well, it flows, no grammar problems, no stiff/awkward/stilted style. Nice job on this one. Anyway, the author worked hard. Writing is a tough job, and it is not easy to organize, present and teach technical subjects, I know. But it seems to me that the quality control at Apress is sorely lacking. They might be rushing things to production a little too fast, so it seems. Hope they improve though!



2. I'd wish there would be a way to measurably gauge how far, "for better or worse", books have strayed away from the carelessly lousy online documentation from a purely linguistic point of view.
   ~
   This book has almost no actual examples of anything real in its 300 pages. It just the online docs with some Windows specific stuff thrown in, some of it relatively interesting/esoteric like using IIS front ending TC and some other stuff, which to me does not merit space in a TC book, e.g., Securing file system on a OS level, in which the author states (page 219) "Windows gives you much more flexibility when assigning permissions than Unix does" I am still wondering when, if ever, Windows will be able to achieve the level of security that hardened gentoo sports right from a live CD
   ~
   Matthew Moodie's book, in addition to the very Windows-centric mindset, also contains quite a bit of bluff and insipid content, sections that appear to have no meat whatsoever like "Transactions and Distributed Transactions Support". I wonder why didn't they just leave this section altogether. It also has many little mistakes that at some point I simply started underlining with my comments next to them:
   ~
   page 4: "Tomcat is always the first server to provide the new features of the spex when it is finished" Actually not true, Jetty has been better at that that TC itself
   ~
   page 59: author refers to the "commons" branch in TC directory structure while talking about logging listing 4-7 (TC 6 did away with it)
   ~
   page 161: "Using Tomcat's connectors"/"The Workers" it should be "CATALINA_BASE1", "CATALINA_BASE2", ...
   ~
   Book also seems to be talking more about TC 5.5 than the new features of TC 6.0
   ~



3. I read this book from cover to cover because I am a tomcat administrator and I need to update from version 5 upto 6. What I got after reading the book is very little.
   
   Most of the technical explanations are very shallow, some address -badly- esoteric/complex issues. The contents within each chapter do not mix well, there is no logic flow when reading the book from chapter to chapter.
   
   The book lacks working examples, the chapter 14 is completely useless, how can you test the tomcat if you can not set up it properly ?
   
   The appendix on MySql is unnecesary, that's not the main bulk of the work for Tomcat administrators.
   
   The book seems to be a rush rewriting from a previous book based on Tomcat 5.5.
   
   I will give a try to: The Professional Apache Tomcat 6 by Vivek Chopra, Sing Li, Jeff Genender. I hope this time I won't miss the point.

5 comments about Java Foundation Classes in A Nutshell.

1. A brief but good reference of the JFCs. Again none of language features are covered in dept so don't expect this book to be a tutorial or an introduction to Java. Buy it together with another title that has more hands on examples.



2. The book "Java Foundation Classes in a Nutshell" contains an introduction to the Java Foundation Classes and a complete reference to them.

   The major part of the text (~550 pages) is the reference to the Foundation Classes and lists all of the JFC classes with their class hierarchy structure information, all methods and a brief description of the class. This reference part has the same quality as the references known from the other Java in a Nutshell publications (Java in a Nutshell, Java Enterprise in a Nutshell). It is comprehensive, gives a good overview of each package and lists the class methods in a very readable way. The introduction to packages and classes are brief but cover the essentials very well.

   The first ~150 pages of this book give an overview of the Swing architecture and an introduction to the key APIs in the JFC. It covers graphics, printing, data transfer and applets. This part of the book is more problematic than the actual reference part. The selection of topics is limited and not very intuitive (why a hole section on Applets?). Although this introduction is written very well, the it is too short to serve as a tutorial and yet too literary and incomplete to be part of reference manual.

   Anyhow, this is a good and complete reference manual that comes handy whenever you don't have access to the online Java API documentation.




3. This is a truly good reference on the JFC with a thorough coverage of the various packages. It is not intended as a tutorial and is clearly not for beginners. Combine this with Java in a Nutshell and Java Examples in a Nutshell and you have nearly 2000 pages of detailed reference material.



4. This title is meant to be the second volume of a three volume set that covers the entire language. Volume one covers the basic core Java APIs, while volume three covers the enterprise classes.

   Like all "In A Nutshell" books, this isn't probably where you want to start if you are trying to learn the language. Part 1 is set up such that topics are introduced and discussed with code examples, but it is not a "hand-holding" type of explanation. It assumes you are at least familiar with the information at a high-level, and understand the basic core Java fundamentals. If you are at that point, you should be able to learn a lot from the first section.
   
   Part 2 is where an experienced Java GUI programmer will live and breath. There is detailed documentation on each of the classes that are covered, as well as a diagram that shows the class hierarchy within the class, and where the class fits into the overall Java class hierarchy. Once again, it's strictly documentation with no explanation. Don't expect the author to explain how each method in the class works. It's up to you to figure out how the method best integrates into your project.

   I can pose the same question I did when I reviewed Java In A Nutshell... Why get this book if I have the online API documentation from Sun? I see them as complimentary. You can probably find much of the reference material in either source. Some will prefer the online hyperlink navigation, while others will appreciate having all the information on a subject in four or five pages that can be thumbed through. I know when I'm stuck on a problem I want both sources!

   For Notes/Domino 5 developers, I would say that there is little in this book that would be of value to you as you code a typical Notes/Domino application. While Notes/Domino does support applets within the application, you would most likely code those outside of the Notes/Domino framework. If you are tasked with developing a Java application that uses Notes/Domino APIs to capture some of the inherent power of the platform, then this book would be useful as you develop the GUI interface that you'll need for your project.

   Conclusion
   If you're a Java developer working with client-side applications, get this book. If you're a Notes/Domino developer looking to use Java in your applications, you should probably focus on the Java In A Nutshell book. This is a very well written book, but the usefulness of the information depends on what type of Java programming you are doing.




5. Wonderful book in wonderful codition.