5 comments about Jakarta Struts for Dummies.

1. I like the Dummies books.

   OK, so I'm not sophisticated, professional, or even very smart. But so many computer books seem to forget the first twenty pages that explain just what the hell you are trying to do. Perhaps the Dummies books take 40 pages to explain what could have been done in 20, but that's not a problem. I can read fast.

   It has often happened that I first read a Dummies book and then once I'm deep into doing something with that language I need to go get a more complete Bible type book. I haven't gotten far enough into Java yet to know if this is true, but my newest task is moving a web site over to Unix (BSD), Postgre, Apache, and Java Servlets to provide server side dynamic pages; I don't have the time to read a Bible on each one of these. This book, along with some other Dummies books is getting me started a lot faster than I thought possible.




2. I was surprised at how clear this book is. I was expecting less from a "for dummies" book. I had to get a struts-based web application up and running in four days flat and I bought both this book and the more highly regarded "Programming Jakarta Struts" by Chuck Cavaness (an O'Reilly book). I used both books, but relied extensively on the example applications in the "for dummies" book. When crunch time came I found myself consistently turning to the "for dummies" book.
   
   Frankly, I thought it was a darn good book.



3. Thank you Mike, Ellen. You did an excellent job. This is one of the rare technical books that I enjoy



4. I read this book way back and it's a winner for beginners! Except the name of the book (dummies?!?!) this book is an excellent start for the struts audience (again, beginners only!). Let me put it this way, if you have 0 knowledge about struts, take this book, read it and *implement* the examples - you'll understand everything, guarantee!
   
   Robinson and Finkelstein did an excellent job explaining the intricacies of the struts framework and implementation. Well done guys!
   
   Simple, elegant, (sometimes funny), bottom line and excellent examples!
   4 stars!



5. In the starting the author builds a simple example from the ground up. But, from chapter four, instead of continuing adding features to the example, start to explain things whitout practical examples. Conclusion: you are disconnected from the real work with struts until the rest of the book, when he builds a complete application in only one chapter.

5 comments about Conducting the J2EE Job Interview: IT Manager Guide for J2EE with Interview Questions (IT Job Interview series).

1. Amusingly, Hunter states how certain questions should not be asked of job candidates in the US, due to non-discrimination laws. But he then immediately proceeds to broadly hint (nudge, nudge, wink, wink) how the interviewer should indirectly ferret out such data, if you deem it germane.
   
   He then goes on to suggest that interviewees should adopt the dress of the executive and banking industries. Wretched idea. A spineless conformism. Do you want to have the chance to hire the best people or not? His advice can cause you to lose some creative and brilliant programmers who care little about a dress code or those employers who set store by it.
   
   Sure, some top notch people will readily conform. But others won't. And the truly talented do not have to work for you. You are competing for them, more than the reverse. For a purely, self interested viewpoint, you should not impose a dress code. Maximises your chances of getting the best.



2. 50% of book is with general topics, other than J2EE



3. Sometimes I wonder if the author's advice is very biased towards their own knowledge of the technology and qualifications. I mean, come on, proper dress code???, education in the ivy league schools???
   
   1. Dress code is the responsibility of each employer, some larger corporations might adhere to a stricter dress code, some smaller ones (especially technology companies) could care less if you wear jeans to work, as long as you are knowledgeable and productive.
   
   2. College degree. I disagree with the statement that "You **must** possess a certification and/or degree. You truly can't make such hard qualifying statements, since most IT jobs in the industry require degree or equivalent experience. I mean, come on, I know plenty of great developers who didn't finish college, but have many years of Enterprise Application Development under their belt. What if you are an industry acknowledged expert, book author, and have many years of experience, do you disqualify that candidate if they don't have a formal degree?
   
   Basically I almost felt like the author is a psychology expert (which half of this book is dedicated to), vs. sticking strictly to technical questions and qualifications. Does the author also have a **degree** if psychology? Otherwise based in his statements, he's definitely not qualified to make such recommendations.



4. The author appears to have no serious managerial experience: he seems to be a self-employed DBA. And it shows. Bigtime.
   
   The model candidate, according to the author, would appear to be a conformist left-brained banking clerk. I have worked with and hired developers with a varied range of dress habits, personal manners, backgrounds and education. Good developers come in all sorts of shapes, sizes and colors. The best programmer I ever worked with never had a high-school education. Following this book's guidelines for assessing candidates' personal qualities would have excluded 2/3 of the best developers I know.
   
   It's riddled with prejudice: "the female job applicant with three children less than five years of age may not be appropriate for an IT position that requires long hours on evenings or weekends." But it would be OK for a man with three such children to neglect them? And what does it say about a company and management which cannot organize projects without expecting excessive overtime?
   
   The author appears to have no idea of the existence of employment legislation, anti-discrimination law, management techniques or how to motivate people. One has the impression that the recommendations would be more appropriate for a correctional facility or a kindergarten school than a twenty-first century development shop.
   
   The technical questions reveal immaturity and inexperience. Design abilities are far more important to the fate of a project than technical minutiae. Yet no questions are included that would enable a manager to distinguish someone who really understands good principles of object oriented design. Just asking questions about patterns that a trained parrot could answer is hopelessly inadequate.
   
   The technical questions are about half the book. But they are repetitious, the 'answers' are often too specific - one 'right' answer when several alternatives are equally appropriate. Some are obscure and totally academic: 'What is the Java Remote Method Protocol(JRMP)?'. Who cares? JRMP goes on completely under the covers and a developer has no need to know even of its existence. Some questions are plain wrong: 'What are the two transport protocols used by J2EE web-based client applications?'. 'HTTP and HTTPS transport protocols' comes the answer. First, HTTP is not a transport protocol but an application level protocol. Second, there is no HTTPS protocol: HTTPS is a URI scheme which is used to indicate that HTTP will be tunneled through secure sockets.
   
   By the time the candidate has been asked Non-Technical Questions 8 ('If you were a vegetable, which vegetable would you be?') and 9 ('Describe the month of June'), any sensible candidate will already be asking themselves Non-Technical Question 10: 'Why do you want to work here?'



5. I am a manager (and still developing, however as little as possible) for a group of developers working with Oracle Apps 11i and a custom integrated web application for our sales and manufacturing department. I own both the Java and the J2EE version of this book and will be cross posting my comments to both of them. The comments below are both mine and senior members of my staff that have gone through both books.
   
   Both books contain very similar information with regards to the interview process - proper dress code when showing up for an interview, assessing job skills, the values of certification and formal education requirements.
   
   The heart of both the Java and J2EE books, however, is the Q/A section. Both are filled with well written and insightful questions that could be used for many J2EE or Java candidate positions.
   
   With regards to the J2EE book, I feel that there was good coverage on Servlets, JSP, JDBC and JMS, however, I would have liked to seen more (actually any) questions on Struts, DBO and Web Services.
   
   Generally speaking, both books are well worth the $$$ and I was very impressed by the quality of the Q/A section. Hopefully a newer version of this book will address Struts and Web Services.

5 comments about Java RMI.

1. I bought this book a few days ago, and I'm satisfied with it.

   If it's an introduction to RMI that you're looking for, then you will not regret your choice: the author gives a good overview of RMI and the related topics, like sockets, streams, serialization and threads. As a "side effect", sometimes this book is a bit off topic, especially during the long description of what threads are and how to use them.
   I would have liked to read something more about RMI over IIOP.

   It looked correct and clear in the explanation, and I must dissent from a previous reviewer:
   1) the author does not write that java.io.File is not serializable, but that its serialization is not obvious and it explains why;
   2) arrays are really not serializable because they do not implement the Serializable interface (just check the java API).

   The book is not intended for the advanced RMI programmer: I think Java.RMI from AW (Pitt-McNiff) is more suited for this purpose.
   In conclusion, not the best book about RMI, but a satisfactory introduction.




2. The book is well organized from the basic technology to hgh level, deep technology. If someone wants to know RMI itself, this
   book will be useless. But if someone really wants to know what distributed system is and how the distributed system is implemented using RMI, this book is very helpful.



3. Explanation is too cluttered and a lot of material is off topic(threads, sockets,..). On the other hand topics like the newer 1.2 Activation is not covered in detail. I felt "Java.rmi" book by Esmond Pitt to be a more useful resource.



4. I personally have a very high opinion of the technical level
   and presentation of this book. The author gives enough substance
   to all RMI components as well as enough how-to information for
   a typical TMI deployment. What I apperciated most however is
   that it's replete with small pieces of wisdom on distributed
   systems design (e.g., scalability) that were eye-opening. It
   also illustrates the distributed way of thinking through teaching to ask the right question at design phase.
   It's true that it talks about more than strict RMI but that's hardly a shortcoming.
   The reader wanting to see onl RMI stuff will find his way by picking the right chapters (you can't miss them).
   Overall, excellent technical depth, good job.



5. RMI has evolved a lot from 2001, this book is rather outdated.
   
   But I'll only comment on the serialization chapter (10).
   
   It gives some bad advice for doing serialization (read Effective Java for that), and even has this passage, commenting on the internals of java.util.ArrayList, which is serializable, and has an internal Object[] field marked as "transient".
   
   "But hidden in here is a huge problem: ArrayList is a generic container class whose state is stored as an array of objects. While arrays are first-class objects in Java, they aren't serializable objects."
   
   That's the reason he thinks it is marked as transient. Well, serializing arrays worked from day 1 (depending on the element references being serializable themselves of course), and this just reveals a big misunderstandment on the author's part about the code he read. (Surely enough, an ArrayList's internal array can be far bigger than its actual contents, so it would be a bad idea to depend on default serialization for this field).
   
   This sort of stuff just doesn't boost my trust.

5 comments about Java After Hours: 10 Projects You'll Never Do at Work.

1. This is a fun book to advance your programming and Java skills a bit.
   
   The strength of this book is not that it has complete code for 10 projects. It is that each of these projects have nearly unlimited potential for adding in features.
   
   Take the aquarium for instance. I added in a simple GUI popup to control how many fish, their individual speeds, supports unlimited fish photos, change backgrounds, add in whales, sharks, dolphins crabs, ect. In addition, the shark can randomly pick a fish every so often and eat it, along with sounds from Jaws. Next I am going to add in fisherman and divers.
   
   The great thing is that all of the projects are this way. Even if you are not inclined to etend the projects, there is still alot to learn from the basic projects.
   
   There is complete source code on the books web site. BTW, the Aquarium does not feature multithreaded fish. Each fish is not a thread. There is exactly one explicit thread in the program.



2. This book is for experienced Java programmers that don't need a rehash of the basics and want to try some interesting projects as well as learn some new techniques and tricks such as sending JPEGs back from a web server, grabbing web pages from Java code, creating drop shadows in Java2D, using online filters, and controlling any other program robotically.
   
   This book contains 10 projects, along with some minor projects used for illustration purposes. One of these subprojects builds an entire web server you can run from your desktop, given an Internet connection and a fixed IP address, which you probably have if you have a broadband connection. The following is a summary of the book's contents:
   
   Chapter 1: Aquarium-- A multithreaded fish-swimming project with fish that swim realistically against a bubbly background.
   
   Chapter 2: Slapshot -- A multithreaded hockey game that moves. You play against the computer and set the speed. And when you set the speed in the upper 90s, you've got a good chance of losing.
   
   Chapter 3: The Graphicizer-- An image-editing and conversion tool. This one lets you read in JPG, PNG, or GIF files and save images in JPG or PNG format. You can work with images pixel by pixel, embossing them, sharpening them, brightening them, blurring them, reducing them, and so on. And you can even undo the most recent change.
   
   Chapter 4: Painter-- Lets you draw your own images from scratch--ellipses, rectangles, lines, and so on. You can even draw freehand with the mouse. You can also draw each shape open or filled, using a texture fill, a solid color fill, or a gradient fill. You can draw text. You can give shapes a drop shadow, or make them transparent. You can draw using thin lines or thick lines. You can set the drawing color. And not only can you save your work when done, you can also read in images and work on them, annotating them with text or adding your own graphics.
   
   Chapter 5: The Chat project-- In this project you create your own private Internet chat room that will keep you in touch with anyone over the Internet. All you need is Internet access and a Java-enabled web server. You can have as many people in your chat room as you like. What they type, you can see, and what you type, they can see. Type all you like--all you're paying for is the local Internet connection.
   
   Chapter 6: WebLogger-- Log access to your website. This project lets you log users who access your website by access time, authentication type, username (if they've logged in), user IP address, the URL they accessed on your site, their browser type, the milliseconds they were there for, and so on. All without their knowledge.
   
   Chapter 7: The Robot project-- This interesting project lets you control any other program by remote control; just tell it what to do. You can send text to the other program you're controlling. You can use the ALT and CNTL keys. You can send tab characters, the Enter key, or the ESC key. You can also use the mouse--just enter the screen location (in pixels) where you want the mouse to move to. Then click the mouse, right-click it, or double-click it. You can also take screen captures. If you want to automate working with any program, the Robot will do it.
   
   Chapter 8: The Browser project-- This project lets you create a fully featured browser that subclasses Microsoft Internet Explorer in your Java applications.
   
   Chapter 9: The Intercom project-- This project lets two people type across the Internet. You just start up the project, connect with the click of a button, and you've got your own connection: Everything you type into the Intercom, the other use can see, and everything the other user types, you can see. This one is a client/server application and connects directly across the Internet using its own protocol--unlike the Chat project, no Java-enabled web server is needed here at all.
   
   Chapter 10: The Forecaster project-- Displays a four-day temperature forecast for your area, starting with today's high and low temperatures. All you've got to do is to tell the Forecaster your ZIP Code, and it'll give you the forecast by reading its data from the National Weather Service and sending a JPEG image from the server back to the browser.
   
   I'm a Java multimedia programmer, and I found this an interesting collection of projects and ideas for games and utilities I am working on. It is much more interesting than all of those enterprise Java books that are necessary for getting stuff done at work, but are not that inspiring. I recommend this project-based book to anyone curious about just what can be done with Java.



3. I like several of the ideas; I thought hockey would be good, but it is pong.
   
   The robot and web browser are very interesting ideas. You can really think of things to do with these.
   
   The ideas and examples would have given this book a higher rating but there were a couple problems that I list below.
   
   Bad ideas of the writer; first is listing the main functions for class. First the method names and parameters and return types doesn't really help. It just took up space.
   
   Second bad thing is the way code is shown in the book, here are pieces of the code, now filling in other pieces, and just continuing along those lines. I would prefer the entire program and list the line numbers, in writing just identify the line numbers.
   
   I think every chapter would be about a fifth the size if the code didn't extend so long and the class methods were delete.



4. This is an ok book for people that want to learn what they can do with Java. The projects are explained well. I didn't think any of the projects were that exciting



5. I was reading this book and about to post a comment regarding the wasted space and pages. Well there it is, exactly what I wanted to say in the previous post. It should be a way thinner book if not for those silly main()s.

1 comments about Java Concepts for AP Computer Science.

1. As the teacher of college courses in computer science, I am always trolling the textbook waters looking for a new and better book. Therefore, that is the context within which I examined this book.
   It is designed for an introductory course in Java and covers all of the basics, although some are not covered in what I consider to be the proper depth. Objects are used throughout, although introduced in a gradual manner. The control constructs; the core properties of object-oriented programming such as encapsulation and polymorphism and many of the classes in the basic libraries are covered. The last two chapters introduce data structures, an area that is generally not considered to be a part of basic java.
   While I consider the book readable and the examples understandable, the coverage of the objects in the swing library is weak. In my opinion, the book would have been stronger had the chapters on data structures been dropped in favor of more coverage of the swing library and the event handling classes. While it is a good idea to begin with programs that are run from a command line, most programs released to the world will present a visual interface.
   Since I consider the creation of programs that present a visual interface yet still do significant underlying processing to be an essential component of my java course, I will not be adopting this book for my class.

5 comments about Java Card(TM) Technology for Smart Cards: Architecture and Programmer's Guide (The Java Series).

1. If you're like me, new to Java Card development, this seems to be a must have. The book provides an introduction into Java Card development, code samples throughout the book and a brief step by step development guide. It also has the all important API reference documentation in the appendix.

   In brief, if you liked the Java Series JDBC book, you'll probably like this one as well.




2. Ok, prepare yourself to my orrible english!
   To be full honest with U I'm relatively new to java card development. This book explains very well all the API and give us nice ideas how to use the smart cards in a real environment.
   But it fails when we reach the testing point. Yes, ther'is no testing at all.
   How do we have to use the java card kit?
   How to compile and use the produced output?
   How to test the code in a emulated card environment?
   Nothing.
   You will remain with the code in your hands only.
   Obviously...U will find yourself to check the web again...



3. I'm really impressed by the amount of details presented in this book. It really starts from the basics and covers lot of details which may interest advanced programmers/architects. It covers advanced topics like Transactions etc in detail.

   If you are looking for a good reading as well as reference book, I would suggest buying this book. It will go a long way with you!




4. A really good book that explains not only Java Card specifics, but also some smartcard basics. A must read for someone who is intending to develop applications around Java Card and has never developed any application for smartcard. This book also covers some preliminary cryptography needed to understand Java Card API and applet loading. This book however only covers Java Card 2.1, with Java Card 2.2 and contactless products emerging at market place, another edition is due. Object sharing interface mechanisms are very well covered and so are some of the gotchas of ISO 7816 and its usage. It also includes a step-by-step guide to develop Java Card applets. Overall, a bible for someone who wants to be an expert Java Card developer.



5. Hi,
   
   This book is good for beginners like i,
   
   It attracts much to me like programming an application in Java Card
   
   Greetings!!
   
   CACALOMACAN , TOLUCA , ESTADO DE MEXICO

3 comments about Java Software Solutions (Java 5.0 version): Foundations of Program Design (4th Edition) (Lewis Series).

1. The book is clearly directed at a reader new to Java. She might also be new to programming, in any language. Consequently, the book steps carefully through various key ideas, like object oriented programming, polymorphism and recursion. These, and other ideas, are reinforced by extensive self review questions and problem sets. Something worth considering by a lecturer searching for a text to accompany a course.
   
   It is good that the graphics examples focus on using Swing widgets. The original AWT widgets get only a passing remark. Which helps a newbie avoid coding in these.
   
   The book has extensive appendices. Too extensive. Appendix M, which lists the Java class library, is superfluous. It describes the standard Java classes that come with J2SE. For each class, it lists the variables and constants, constructors and methods. Along with brief explanations of the intent of many of these items. The Appendix takes up almost 160 pages. A sizeable fraction of the 900 pages of the entire book. The problem is that the appendix is basically a rendition of the standard documentation that Sun supplies with Java. Little value is added by Lewis and Loftus. This appendix should have been entirely dropped. Instead, the reader could have been directed to the appropriate Sun URL. Or, indeed, been asked to search the web. Because it turns out that the manual pages written by Sun are widely mirrored by many websites.
   
   Or, the manual pages should have been in the CD that comes with the book. (If the pages are already on the CD, then Appendix M should certainly not have been written.)



2. This book could have shown the examples, especially the complicated ones, a lot more in depth. The basic information of the book is good, but it is very dry. The chapter on recursion is not very helpful at all. The author could also make better examples for exception handling.



3. There is an updated printing of this book that uses ISBN 0-321-32202-7. The updated printing (which corrects small changes in the final version of Java 5) also is called the 4th edition. The publisher added words "Java 5.0 Version" to the title listed in online stores, and added a leaf with the words "Covers Java 5.0" to the bottom right of the cover. Be sure not to buy an old printing that you can't return, especially from someone selling a used copy.
   
   This URL to purchase the most up-to-date printing from Amazon is: http://www.amazon.com/exec/obidos/tg/detail/-/0321322037/qid=1126549578/sr=8-2/ref=sr_8_xs_ap_i2_xgl14/102-3991796-1688157?v=glance&s=books&n=507846

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.

5 comments about Conducting the Programmer Job Interview: The IT Manager Guide with Java, J2EE, C, C++, UNIX, PHP and Oracle interview questions! (IT Job Interview series).

1. This is another good book in the Job Interview series from Rampant. As with the other books, this book gives both the employer and the candidate guidance in areas such as work experience, personal appearance and education.
   
   The questions that are provided in the book give a good base for the employer to ask the candidate. Of course, each company will need to modify or use only the questions that they will need.
   
   I would recommended this book to any employer or candidate seeking a programming job in one of the languages covered.



2. This book certainly helps managers interviewing programmers who claim expertise with many languages. If you own a J2EE shop and looking for Oracle and C++ expertise and need tough questions to ask....the questions prescribed in this book is good. Also note, this book does'nt help you as a reference for any other practical use of those languages.



3. I often interview programmer candidates, so I bought this book to calibrate my interviewing style and skills. I am appalled at the advice in the book -- I guess I should hope other firms do interview this way, so they'll gather the programmers I definitely don't want and leave the good ones for me.
   
   Besides the defects other reviews have already mentioned (in this day and age, if you only hire candidates who show up in suit&tie as this book recommends, you'll end up missing many of the best techies!), some parts are positively creepy -- e.g., under "Gleaning Demographics" it claims that, while some questions are illegal, you should still slily ask questions to hiddenly gather that kind of information, since aspects such as whether the candidate has small kids (illegal to ask about that) should "factor strongly into a hiring decisions" -- so, ask what the candidate does to relax, that will dupe them into revealing whether they have a family.
   
   Disgusting, really, and I find myself hoping somebody ends up in lots of trouble for practicing such weaselly duplicity -- meanwhile, all I can recommend to anybody but outright weasels is to carefully avoid this horrible book.



4. This narrow minded, interrogation oriented guide is simply horrible. The only person to recommend this to is the job seeker -- to prepare you for the more mean spirited interviews. My advice would be to walk away, but if you really want the job, then awareness of this sort of interview practice might help you get hired.
   
   As another reviewer observed, if companies really do follow this sort of advice, then they deserve the people they hire. Now, some companies may want a team of willing white shirts with heads full of programming language details. If you're one of those, buy the book. However, note that ascertaining real competence, creativity and aptitude take a back seat here; it's form over substance.
   
   When I think about the very best "techies" I've hired and worked with over the past 30 years, many would not successfully pass an interview process modelled after the advice in this book. Unbelievable. The credentials for the author to write this book, as far as I can tell, are these: IT executive and horse trainer. I rest my case.



5. This is supposedly a book about hiring top-notch engineers. Instead it's a really great way to scare away talent. Do not use the technical content from this book; if you have to do a technical interview and you're not up on the technology in question, use another resource.
   
   The questions in this book are terrible, ranging from trivial ("How do you end a comment in C"), to mildly wrong (regarding the correct declaration of the main function in C). And then we have the hilariously and incredibly confused:
   
   Q: What would you say someone is doing if they are calling "mmap()" followed by "sizeof()"
   A: They are trying to get the size of a file.
   
   Ow. Ow. Ow. Ow. Make it stop hurting, please.
   
   Q: (something about a hunk of code that the author claims is broken)
   A: That code works just fine.
   
   Glancing at the other questions, they look about the same (plus a lot of stuff like "What variable should be set to turn on TTFT mode in order to configure XMLG in WebGronk 7.61 for IETF compatibility with mode 3 client access?" -- things that someone competent should be able to find quickly, and that I would never expect anyone to have available in an interview). It's really clear that the author had no expertise in the areas covered, but simply skimmed some books and made up questions with little or no research or technical review.
   
   If you think your next candidate is smart, you might want to hand them a copy of this book and ask them what they think of it.

5 comments about C++ For Java Programmers.

1. I liked this book. It *is* a light, but helpful, introduction to most of the pifalls of C++ for a person who has worked with Java for some time. The problem is that the approach to memory allocation and the standard library tools are very different in Java and C++, while the syntax of both languages appear to be very similar; the author makes this point clear with examples. Compared with some standard references for C++, with lots of detail and almost thousand pages, this book is very readable and enjoyable. This is not a reference type of book, there are plenty of those out there. It is a book for those who reached OO programming via Java period.



2. This book was mistitled. It should have been "Differences Between Java And C++: A Crunch Translation Guide". Like an English-LanguageX translation guide (or a culture-to-culture translation guide, for that matter), this book is intended to identify the sorts of things that a Java developer jumping into C++ with no background in C++ would typically incorrectly presume or fail to correctly presume without having been told. To that end, this is an excellent, one-of-a-kind book that immediately immerses the reader into very significant and important differences between the languages regarding everything from syntax to compilation and execution. There is an interesting bit of detail about the philosophy, purpose, and objectives behind C++ which paints a significantly different picture in that realm than Java does, showing that in spite of the fact that Java and C++ look similar to the human eye, they are nothing alike (... but alike enough to be able to produce a "direct translation guide" like this book).

   This book assumes a) significant familiarity with Java, b) is familiar with, and respects and appreciates, what too many people think "doesn't really matter," like how computers work, computing history, etc., and c) basic existing familiarity with C++, at least enough for "Hello World!" and then some.

   I'd recommend this book to any Java programmer looking at C++ who has never done so but who has recognized that Java was born by C++ developers, and who has recognized that one can and should actively extend, and not indifferently coincide, new C++ skills on top of an existing fluency in Java. This book should be accompanied by other books--no book can do it all--but this is an excellent "Java/C++ translation guide".

   Due to the mistitling/mismarketing, I would give this a 9/10 but given only five stars it rounds up to five.




3. I am a java programmer trying to learn C++, and find this book VERY hard to follow.

   Most of the syntax is not explained and too much time is spent explaining subtle details, rather than key concepts. Some of the real differences between c++ and java are clouded with confusing fragments of explanation, mixed with unexplained code.

   It seems to be more of a comparison or overview for C++ programmers than an introductory book for java developers.

   I am confused and left reading pages over and over again trying to make sense of this language. I think it would have been easier and quicker to just buy a c++ book, forgoing my java background.




4. This is a very good book. I read it in full. This book provides a very precise explanation of the concepts that one needs to know in C++. Also this book provides a clear comparison of the two languages C++ and Java. It explains the strengths of both the languages without any bias. Many of the C++ books tends to be tough to follow. This book is highly readable and explains even the difficult topics in a simple language with simple and easy to follow examples. The case studies are very good. I like the way Templates are introduced in this book and the container examples in the case study. Simple yet complete and precise.



5. This is a good book highlighting the major differences between the two languages. The material is presented clearly.