5 comments about Murach's Java Servlets and JSP, 2nd Edition.

1. The previous version of "Murach's Servlets and JSPs" was a good book, and this one is too.
   
   The book is described for use as "Training and reference", and while books tend to be good for one purpose or the other I found this one did manage to accomplish both objectives. The information is presented in small, distinct and incremental sections, and each block of code is clear and concise. It also contains all of the important information required to get a good start developing Servlets. I also found the same layout worked well when accessing the information as a reference.
   
   It was very amusing that the book managed to get through four whole chapters before addressing Servlets or JSPs in detail, but given that many people leap into Servlets while their other technical skills are still growing, this prelude will be valuable to many beginners. These chapters are spent introducing web programming with Java, setting up Tomcat and the Netbeans IDE, and a one chapter crash course in HTML.
   
   All of the required topics are covered elegantly, and enough room is left over to provide the same level of coverage for the next level of knowledge such as SSL, JavaMail, connecting to databases, container managed security and even some raw HTTP.
   
   While I would not usually consider 10 horseshoes for a programming resource, this one is less likely to be read and forgotten, and should be of use for the first few years of Servlet programming for the novice. Therefore it is easy to recommend adding this one to your bookshelf.



2. Hi guys, if you are looking for a book that guides you step by step thru servlets and jsp's this is the book you should buy, the method that is used in this book is learn and practice, for me this kind of studying is very proactive and it is better than just reading a bunch of pages with just a final example.
   So do not hesitate to buy this book, this is the only one you need.
   
   "Working hands are better than praying lips"



3. This book takes you through a well structured learning journey of JSP, Servlets and related technologies such as Netbeans, Tomcat and MySQL for developing complete web apps. The book has provided me with the skill and confidence to start building my own web-app. The book finishes with a completed e-commerce example that builds on the earlier work, and gives the reader a basis for their own future development.
   
   The book provides comprehensive details on how to set up the environment for developing and deploying web-apps, with the installation of Netbeans, MySQL, libraries etc covered in the appendices. The set up is generally a difficult part of learning a new computer concept and this book explains this very well.
   
   The material, the downloaded code, and exercises are well integrated and provide for a comprehensive learning experience. I was able to successfully complete the vast majority of exercises readily.
   
   I have ordered the Murach Java book as I found the JSP and Servlets book very useful.
   
   COMPARED TO HEAD FIRST
   ***********************
   I am a big fan of the Head First series, a series which has taught me everything I know about Java, XHTML, CSS, Design Patterns Ajax, OO Design etc. I love it. But as a novice, I found Head First Servlets and JSP: Passing the Sun Certified Web Component Developer Exam (SCWCD) difficult to get into. Mainly because the HF book is directed towards accreditation, and contains some curved balls to prepare for the exam that distracted me from learning.
   
   Instead, I did the Murach book from cover to cover, and skim read the HF book (partially because I am in love with that bossy HF girl!). The HF series is more fun and engaging, but for JSP and Servlets I found the Murach approach worked best for me. While the Murach book is as as well written and presented as can be expected of a more traditional text book, it is not as interactive as the HF series. I therefore found completing the exercises in the Murach book important for engaging with the content.
   
   Murach does a better job than HF on the MySQL and IDE side of things. HF probably covers the nuances of the Servlets more comprehensively.
   
   I recommend both, depending on what you need.



4. This is a very good text for a beginning JSP/Servelet developer. Very clearly laid out, with copious examples, well orgranized, slanted to a novice Servlet developer. You cant go wrong with this text. Additional benefit is a chapter on how to use the NetBeans IDE.



5. Java can be used in countless applications and websites with very little problems from the viewer; an ideal component for a designer. The second edition of "Murach's Java Servlets and JSP" is a complete and comprehensive technical guide for those who wish to master the program and use it to its very fullest. Covering just about anything one can do with the program, and enhanced with a web address that can be accessed for further resources for programmers, "Murach's Java Servlets and JSP" is a top pick for community library collections.

5 comments about Core JavaServer(TM) Faces (2nd Edition) (Sun Core Series).

1. Yes, this book will answer most of beginners' questions about how JSF works. No, after it answers them you'll still be looking for answers why.
   Yes, if you need to know *how* to program JSF then book's long examples will benefit you. No, if you want to understand *why* things are done that way then a lot of pages could be skipped.
   This book is much closer to being specification than it needs to be, but beginner will get good understanding of JSF foundation topics. So for every 'yes' - it's good, there is almost always 'no' - it was not enough.



2. This book is just loaded with JSF material. Google is still my first choice for answering JSF questions, but when Google can't do it for me, I can usually find what I'm looking for in here.
   
   A good book to have.



3. I'm disappointed in that the book focuses to much on how to accomplish a task without telling much about the architecture, why and how JSF operates behind the scenes. This results in that you don't exactly know what goes on, and thus don't know how to solve other specific problems. This is primary reason why I'm looking for another book about JSF.
   
   The book contains a lot of complete file code. Not necessarily bad, but keep in mind that the book might have less pure written text than you might expect.
   
   What I like about the book it doesn't only cover standard JSF, but also well known third party frameworks, like Apache Tiles, Facelets, JBoss Seam. Although again, it's also on that part more a how-to.



4. I recommend this book cause really you will familiar with JSF and in all technology needed in web application, for me I review some issue with this book such as JDBC and LPAP.
   
   I will give this book 4 stars, the one start losing for this book, cause really don't focus and mention enough the life cycle of JSF, for me I refer to another resource to can understand the JSF life cycle.
   
   Although this book really great. I read some reviewer said the Sun Microsystems don't put their brand-name in product low level of quality, I agree with him. Allthing realsed from Sun Microsystems I believe it.



5. It seems the main focus of these 'authors' is to sell Sun technology as opposed to educating developers. They force on you a technology that should be transparent to the education process. If I wanted to know about glassfish I would have bought a book on it.

5 comments about Java Generics and Collections.

1. Generics in Java have some non-trivial aspects, and this book does a great job of explaining when you need to use what in a comprehensive and concise manner. I thought I knew Generics, now I know I didn't... If List looks strange to you, then this book is for you.
   
   Not sure why half of the book is devoted to Collections (rather than having that be a separate book), but in any case these chapters are also very well written. There are simple explanations how to choose the most suitable Collection classes for any given situation.
   
   The Collections discussion touches the issue of multi-threaded programming. I almost expect the next edition to be titled "Java Generics and Collections and Concurrency"...



2. It's a decent reference and a great read to go over generics and the collections framework. But don't get me wrong, it's nothing you can't get from just reading the Sun-provided API documentation or tutorials covering the topics.
   
   It's comprehensive, sure... but the examples lean to near overkill on each topic in some areas. In other areas, there just isn't enough information or example code to really drive home the ideas.
   
   It's average and worth the read. Not worth keeping around, though. It's one of those "read-once-then-give-it-to-a-friend" books. Like I said, though: you should definitely read this book if you're looking for more information on these topics. You'll just find yourself hitting resources online for more information in areas you are particularly interested in (concurrency w/ collections, for example).



3. This a very good book on Collections and Generics. It is very readable and very well laid out and organized. Besides treating Generics thoroughly it also treats threadsafe collections very well too.
   
   For these reasons I highly recommend this book.



4. The authors provide detailed examples of capabilities provided by Generics. There are plenty of examples to illustrate various concepts. And many more examples which put them all together to show how they can be used to write full fledged OOPrograms. Its admirable how a non-trivial topic like Generics has been explained in a simple and succinct style. The collections coverage is good, but not as great as the Generics coverage.



5. This is excellent book, i really wish i had this book 10 yrs ago, excellent verbiage and great concepts.

5 comments about Pro JavaScript Techniques (Pro).

1. If you are an intermediate javascript developer, and you want to know what to learn next in the javascript language this book is for you. Inside you will find concise information about several obscure javascript elements which will make your coding more effective once you master them.



2. Book has lots of examples. Many involve using libraries such as Prototype and JQuery. But, if you are not already familiar with using those libraries, the examples will not make much sense. And considering the typos in the straight JavaScript examples, it left me wondering about the validity of the library demos. Written in the style of a blogger where the author expects you to follow a link to a library's web page and then come back before you can understand the example. If I'm paying for a book to cuddle up with to read on a winter's night, I want it to be self contained - and not expect me to reach for the laptop to read up on the syntax of another library. It also didn't even touch upon one of the more difficult to grasp "Pro" techniques - scoping of "this" when using object methods during AJAX callbacks in the author's own code examples or the various libraries he touts.



3. This was an excellent book two years ago, (and still is), but it's now outdated. I bought it based on its nearly five-star rating; I wish I'd done my homework, since I immediately needed to buy other books to supplement this one.



4. Pro JavaScript Techniques by John Resig is probably the best resource on the language I've encountered to date. I'm one of those web developers who has had something of a mental block when it comes to JavaScript. Despite its ubiquity, it always seemed like a toy language to me. It didn't help that JavaScript's syntax plays a bit fast and loose to my tastes, and that virtually all of the other resources on the language I've encountered barely scratched the surface on what the language can actually do. If you're like me - familiar with the basics, but knowing that you're not proficient enough to use it in a professional setting - then this book is for you.
   
   First, the bad news. Like all aPress books I've encountered, this one suffers from a few small, but glaring, editing errors. Small things - variable names that change between examples for no good reason, in-text refrences to things the author didn't mention (no doubt something missed between drafts), that sort of thing - crop up. It's not enough to break the book, but it is annoying.
   
   Also, the first section of the book moves at break-neck speed. While some of it is review, for those of us who have been toiling in web tutorials and older books, a few re-reads are necessary to truly understand what's going on. Thankfully, Resig addresses things in a logical manner, so each topic flows nicely into the next, making returning to those parts as painless as possible.
   
   Finally, in the chapter where he discusses public, private, and privledged object properties and methods, he completely glosses over how private properties and methods function. Instead, he merely tells the user to visit Douglas Crockford's site on the matter. It's a bit of a cop-out, and I figure that since I'm spending ~$30 on the book, the least he can do is briefly condence Crockford's ideas.
   
   All that said, though, the positives outweigh the negatives by far.
   
   Despite the quick pacing of the book, the information (ignoring editing inconsistencies) is delivered in a straightforward manner. Resig addresses most, if not all, of those little things which are important in the real world (testing/debugging, how to work with libraries, how to ensure your code doesn't interfere with someone else's code, etc), but are often ignored in other resources.
   
   In particular, the early chapters (chapters 2 and 3) on dealing with JavaScript objects are well done. While Resig doesn't go into all of the details (most notably with the link to Crockford's site I mentioned earlier), these chapters form the foundation of just about everything you'd want to do with the language. Indeed, these chapters address most of the pitfalls that create those pesky JavaScript errors we've all dealt with before: scope, closures, and context. Understanding how those three concepts work in unison is fundamental towards understanding modern, professional JavaScript as a whole.
   
   Being a JavaScript book, this particular volume visits topics we're most likely all familiar with: DOM scripting, event handling, and even a bit of AJAX. Thanfully, Resig stays true to his mission of creating inobtrusive JavaScript, and keeps his HTML separated from the scripting code. This is a far cry from other self-proclaimed professional tomes that embed their JavaScript function calls within their HTML tags.
   
   To conclude (and reiterate), Pro JavaScript Techniques is the perfect book for those developers caught in the middle. It's a resource aimed at those of us who have had experience with the language, but have never been pointed in the right direction to use it in a professional manner. Despite its annoying flaws, this book fills the rather large gap between beginner's JavaScripting and creating robust AJAX applications. It's worth owning if you ever want to do serious work with the language.



5. John Resig never fails to amaze and his latest book is no exception. I highly recommend it to everyone interested in javascript; it is a must have.

4 comments about Struts 2 in Action (In Action).

1. I took a chance and pre-ordered this book because I have recently started a Struts2 project and wanted to learn more about the framework. The book did not disappoint.
   
   The authors explained the concepts behind the framework clearly and used examples that were immediately useful. The book is a little too short and in many cases a few more details would have been appreciated but it seemed to be a deliberate decision to leave out some of the less common use cases to avoid cluttering up the book. Thus, this book is ideal if you are new to Struts 2 but have some prior experience with Java web development.
   
   I like the fact that an entire chapter was dedicated to integrating Spring and Hibernate into the framework. It brings all the bits and pieces from the online documentation together in a cohesive and comprehensive package.
   
   Chapters were also dedicated to validation, internationalization, best practices and migration from Struts classic. The authors spent several chapters on how the Value Stack and the ActionContext worked and how OGNL fits into this framework.
   
   All in all there is enough information in this book to start and to produce a complete Struts 2 application.



2. Struts 2 In Action is the best resource (hard or soft copy) for Struts 2 available. I took a look at this book as someone with quite a bit of experience using Struts and Struts 2. I really thought I had a good understanding of the core framework before, but many of the topics that lack online documentation were covered in more depth than I had seen in the past. As an example, many others have shied away from covering OGNL because it is a language all by itself. In this book you will find what I consider to be the most thorough explanation of how OGNL fits into Struts 2 and how to use it yourself. I was tempted to give the book 4 stars because there are a few things that I thought could have gotten more coverage, like Spring/Hibernate integration and AJAX, but I realized that it really would be impossible to cover everything in one volume. Struts 2 is a large and comprehensive framework and with anything of that scale, a good understanding of the fundamentals is the best way to start. This book delivers.
   
   If you are wondering what is covered, you will find comprehensive coverage of the following -
   - writing actions
   - action workflow basics
   - type conversion
   - OGNL
   - form tags
   - non-form tags
   - results
   - intro to Spring/Hibernate integration
   - validation
   - i18n
   - struts 2 plugins
   - migration from struts 1



3. I had to learn Struts2 quickly since I recently changed jobs and my new team has several web application projects built using Struts2.
   
   Overall, I thought the book was done very well if you are looking for a good introduction to Struts2. The first 8 chapters are very good.
   
   The main negative is the source code for the book's examples. The authors provide one very large war file with all the source code embedded into the war file along with an overall web application divided into sub-applications for each chapter.
   
   This packaging of the source code into the war file made it difficult for me to create individual projects in my development IDE that demonstrated just the material in a specific chapter. I had to spend quite a bit of time breaking down the source code into individual web projects and then figuring out on my own what jars needed to go into each project, what the struts.xml file needed to have, and what ever else was necessary to separate out just that chapter's sub-application so I could run that example and play with it.
   
   Where this really became a problem was in chapters 9 and 10. Chapter 9 is a very advanced introduction to integrating Spring and Hibernate/JPA into Struts2. I never could get this chapter's example to work correctly.
   
   However, chapter 10 on the validation framework then uses the same code as chapter 9, so you really cannot separate out the code for either chapter 9 and 10.
   
   The validation framework is likely something even beginning Struts2 developers will want to use, while Spring/JPA/Hibernate is for more advanced developers and should have been well after the chapter on how to use the validation framework.
   
   Also, the authors really don't give you a good understanding of what Struts2 jars you need to have to build a basic Struts2 application. There is some information about this in chapter 13 (setting up your IDE) but this information should really be at the beginning of the book. Also I don't think the list the authors provide is accurate since my basic HelloWorld (get the user to enter a name, call an Action class, and then display Hello userName in new jsp) worked with far fewer jars. Note there is apparently a new example war that just is a basic Hello World so there may be some information in that war file. That war was not on the manning web site when I purchased the book.
   
   This book is good but be prepared to struggle working with the code examples if you want to work on the examples in your own development environment.
   
   I recommend the authors create separate complete war files for each chapter's example to make it easier for users to just get that chapter's example code into their development IDE.
   
   Lastly, the book does get 4 stars because the author's explanations of the basics of Struts2 (chapters 1-8) is very easy to follow for experienced Java developers. I'm now ready to tackle the Struts2 applications in my new job.



4. This is a proper "In Action" book. I do strongly recommend it. If you plan to buy only one reference in the subject, look no further this is it! Down Brown is a Struts PMC member and an authoritative voice, among others he is the author of the Struts 2 REST plugin which is a superb addition to the framework from version 2.1.2
   
   The book is very well written and easy to follow. I personally found the explanations very concise and appreciated the most their unique and clear way of breaking down and explaining all code snippets. This is really a great reference.
   
   The first two chapters are a very good introduction to the framework. I am a pure version 2 user and had to learn most of these concepts from online documentation and from the Struts mailing lists.
   
   Among all the topics covered I enjoyed and appreciated the most the coverage of:
   - Interceptors
   - OGNL and Type Conversion
   - Validation! before this book, you could only find the relevant coverage of this topic scattered online in e.g. WebWork articles outdated
   ..for Struts 2. The authors did an excellent job explaining validation in chapter 10
   - Really unique was the coverage of:
   ..... Unit testing actions
   ..... Tiles plugin
   ..... execAndWait interceptor "processing your request, please wait .."
   ..... UI component templates
   ..... Writing Struts 2 plugins
   
   On the big plus side, the authors did a superb job keeping the book agnostic to minor versions of Struts 2 i.e. there were several differences from 2.0.x to 2.1.x and I was very happy to see that the examples and explanations were not outdated for the later.
   
   On the down side and as a trade off I can only complain that the book left the Ajax topics out; maybe also because there have been many changes on this topic from minor versions of Struts 2 e.g. the ajax theme of Struts 2.0.x was converted to the dojo plugin in version 2.1.x. In any case, I somehow find the Ajax topic in Struts 2 to be one of the best documented online.
   
   I believe that the Practical Apache Struts 2 Web 2.0 Projects (Practical Projects) book from Ian Roughley is a very good complement to this one. If you want to find coverage on topics like Security and Ajax in Struts 2 you will want that one too. The only issue there is that the coverage of the ajax theme is partially outdated for the newest version 2.1.2 of the framework

5 comments about Effective Java Programming Language Guide.

1. I've been using Java since 1995 and have owned this book since 2001 and it's the only Java text I still turn to. I recommend every Java developer, no matter what level you're at, read this book and read it again every year for the remainder of your career. I doesn't matter who you are or how experienced you think you are -- you will learn from this book. I give "Effective Java" my highest recommendation. I cannot wait for the Second Edition.



2. It is incredible to read Joshua's insights. Forget about being a Java Guru or something like that. This book is pure joy to read if you are detail oriented, perfectionist or a student of art of programming in general.
   
   I have started this effort of creating a distilled version of this book coupled with my own reflections at: [...]. To any curious reader though, any such effort is not a replacement for the book itself. It is a masterpiece.
   
   - Kedar Mhaswade



3. I ask all of the developers I manage to read this book, after having been introduced to it by a coworker. Great tips, and helpful in clarifying some of those "gut feel" things that come up during pair-programming.



4. An indispensable, insightful, and well written Java book to add to your reference library. The second addition is due out May 25, 2008.



5. I am only about half way through this book and already have learned numerous things about the design of Java as a language and about proper usage of said language. This book is going to be a staple in my programming library and a book recommended to anyone I know working with Java. I am also looking forward to the second edition which is slated to be released in May sometime.

5 comments about DOM Scripting: Web Design with JavaScript and the Document Object Model.

1. I've had time lately to do a lot more reading and Jeremy Keith's DOM Scripting book is another one that belongs on your shelf if you're trying to learn any amount of JavaScript. I've hated and avoided JavaScript for years, mostly because I started my career during the browser wars and quickly grew tired of having to write different code for different browsers. Thankfully, those days are now mostly over and this book has made me love JavaScript again.
   
   The Document Object Model (DOM) is a standard for conceptualizing and representing the contents of an HTML or XML type document. Mr. Keith's book teaches how to use JavaScript to manipulate the DOM so that you can dynamically add or remove content from a page, change the way things look, or move things around. Similar to how CSS allows you to control the presentation of your content, DOM scripting allows you to control behaviors and events.
   
   There are lots of great JavaScript frameworks available like jQuery, Script.aculo.us, or Dojo which allow you to easily enhance your websites. In order to fully take advantage of them though, you need to have a fundamental understanding of how things like the DOM and JavaScript event handling work. That's where this book really excels. It's written primarily for web standards developers fluent in XHTML/CSS who're looking to branch into more client-side scripting.
   
   This book is full of useful lessons and real world examples on how to make JavaScript and the DOM work in your applications. It also places a heavy focus on fundamentals and best practices such as graceful degradation which will help you make sure that your sites still function well even without the fancy JavaScript enhancements. JavaScript has long been thought to make things inaccessible but it doesn't have to be. This book stresses how to use these technologies in an efficient, unobtrusive way.
   
   What I liked most about this book was the voice in which it was written. I've read dozens of boring hard-to-follow tech manuals over the years but this book felt more like a friend standing over your shoulder and walking you through the process. That does somewhat limit the amount of information the book can cover and it definitely doesn't go very far into advanced techniques. If you've been doing standards development and basic JavaScript for a while though, and you really want to get started on increasing your scripting skills, this book makes an excellent primer. For me it turned my impression of JavaScript from an overly-complex annoyance to an easy-to-use yet incredibly powerful tool for improving my websites.
   
   [...]



2. Great book, no available in France. Basic Dom description but clever and useful. Jeremy Keith is a very good "teatcher". Grâce à ce livre tout devient plus facile et clair. Vraiment dommage qu'il n'existe pas de developpeurs en france qui écrivent des livres aussi bien. La collection friendsof est vraiment incontournable. Bravo et bonne suite à cette collection. FiendsOf is a very top book's edition.



3. One can't rely on a book to be good enough to explain things the way they should be explained. Many people give up trying to learn something because they blame themselves for not getting it. The key, I've learned, is to keep on looking until you find the resource that will. I've learned this lesson by going through a many books on JavaScript to finally end up with one that hits the nail directly on the head. That book is Jeremy Keith's DOM Scripting.
   
   I recommend starting with this book and then following it up with Christian Heilmann's beginning JavaScript book.



4. This book is perfect for front end developers with little to no JavaScript or DOM experience. Jeremy Keith is one of the top proponents for unobtrusive, semantic, and gracefully degrading JavaScript in the world. A must buy for anyone who ever needs to use or learn JavaScript and the Document Object Model.



5. This book gots it all together well. I love the way the author writes and the way he presents a concept. Its so easy to follow and understand. This book isn't fit for a total beginner..you're going to need at least some experience with Javascript, CSS, and HTML to be able to implement DOM in your javascript.
   
   I've never written a review before but after reading 10 chapters of this book, I purposely had to come on here to write this review. you really should check out some of the stuff Mr. Keith demonstrates in here. This is one of the best programming books I've read. The stuff he teaches sticks to you..they are real life programming techniques that can be used to spice up your website.
   
   Seriously, if you want to get deep into javascript, you ought to get this book. Very easy to read with very useful techniques being taught. A+ for this author. Next time I buy programming books, I will look for this author, Jeremy Keith.

5 comments about SCJP Sun Certified Programmer for Java 5 Study Guide (Exam 310-055) (Certification Press Study Guides).

1. Excellent book. Make sure you do all exercises and tests that come with this book.



2. This is a review of the previous edition of this book (ISBN:0072226846), but probably the same applies to this book. For learning Java, this book is better than revered Head First book from the same authors. I only understood Head First book when I downloaded and analyzed the source code. Otherwise, I see a lot of incomplete examples, it was like watching the movie from the half.
   
   This book gives you full understanding of the Java language. It explains what is possible, and what is not. It is complete. I don't speak about passing the exam, that was not my intention. I wanted to learn and understand the Java language. What was the most important thing to me was the limits of the language. Reading this book, all the time you have a feeling of control. Everything is explained, and you have a full control of the language. Not so many books explain all possible ways how to use the interfaces, how to arrange the source files,...
   
   Rare authors of programming books have this talent. The same feeling I had with the book "Programming C# with Visual Studio .NET 2005" by Jeffery Suddeth (ISBN:1411664477). Pure perfection. I would advise potential new and old authors of the books to read this book as a study guide of How to write programming books. Reading this book was an intellectual pleasure to me.
   
   Pero



3. This book is an excellent resource. I have 2 years experience with Java, and my company recently sponsored me the official SCJP course (CDJ-110A). I can honestly say that it is the biggest waste of time imaginable, as it doesn't cover anywhere near the material required for the exam. This book, on the other hand, provides clear exam objectives for each section. It points out common 'tricks' the exam may use to fool you, and provides good examples of exam-like questions. It is easy to read and full of examples.



4. I just passed the exam with 87% after reading this book. I spent two months reading the book and then two weeks some revision. When reading this book you keep discovering things that you know you should have known long before as a java programmer. The questions in the book tend to be harder than the actual exam, but they are helpful.
   
   
   I discovered a couple of minor errors from the book. But it's really no big deal.



5. i have just passed my exam with 97%. This book covers everything that you need to know for SCJP5 Exam. Once you read it you will feel confident but dont be fooled you are not finished just yet. you have to do a lot of mock exams which are available online. (for the mock exams and some help go to www.javaranch.com).
   The practice questions after each chapter are very important. These questions are very close to the exam questions. Solve them all before you enter the exam.
   I can not say the same thing about the simulated test included in CD, though you shall still go through once.
   Once again, this book covers 100% for SCJP5 EXAM.

4 comments about Core Java, Vol. 2: Advanced Features, 8th Edition.

1. Updated for Java 6, "Core Java Advanced Features" does not disappoint. This is for those of you who have finished volume 1, either this 8th edition or the 7th edition. Quite frankly, I think in the case of Volume 1 you can skate by with the older 7th edition. However, in the case of the eighth edition of Volume 2, there is quite a bit of expanded coverage to the tune of the resulting book being over 1000 pages in length. It follows the same format as past versions of Core Java Advanced Features. The authors start at the beginning of each topic and walk you through increasingly difficult programs and very well done illustrations and screen shots of applications that are really quite helpful. I include the table of contents since it currently is not included in the product description.
   
   1. Streams and Files
   2. XML
   3. Networking
   4. Database Programming
   5. Internationalization
   6. Advanced Swing
   7. Advanced AWT
   8. Javabeans Components
   9. Security
   10. Distributed Objects
   11. Scripting, Compiling, and Annotation Processing
   12. Native Methods
   
   Before you go out and buy expensive books on the topics in any one of these chapters, get this book and read the corresponding chapter. It will make whatever you hear or read from that point forward much clearer.



2. In my review of Professional Java JDK 6 Edition, I said I didn't think one book could cover such a wide variety of topics and expect to do a good job overall. This volume is, I think, an exception that proves the rule.
   
   It is indeed a monster book, easily several months of steady work to get through, and an useful reference afterwards as well. It is well put together, clearly written, methodically presented. I wouldn't put it down if that were possible. The coverage is broad and the examples are interesting. The topics also feel complete, not because they are thorough, but because they leave off right where intermediate-level programmers could work out most details on their own.
   
   I read the first and second editions years ago, and I must say this title has become a case study in steady, disciplined, tireless improvement and refinement of the original. It's 990 pages, but I haven't come across a useless sentence yet. The authors haven't just added on. They've refined their examples, improved and replaced others. Most importantly, they've realized a format that puts boilerplate and API tables to the side, allowing the reader to focus on the concept at hand. Complete code listings are in the text, presented in a way that makes it easy to gloss them in favor of the soft copy available by download.
   
   If you need lots and lots of code work on different topics to burn Java into your fingertips -- and there really is no other way to do it -- this book is an excellent choice.



3. The Core Java (vol 1 and 2) are simply superb books. If you are a developer looking for thorough books on this subject, look no further.



4. Like many reviewers I find the the Core Java series to be very valuable. However, be forewarned that the kindle edition is not a good representation of the book. The figures are completely useless either because they have not taken the time to convert them properly or because the kindle technology is simply incapable of displaying non-text content properly. I wish I had known this before I paid for the kindle edition of this book.

5 comments about Java How to Program (7th Edition) (How to Program).

1. I bought this book for a sophomore computer science class on OO and web-design. This was one of the worst textbooks I've come across. The examples are old. (Who really wants another Employee class example?). The text is full of 'helpful' facts that are often obscure and distracting. This book never really explained the most important topics of OO (such as polymorphism) in a way that I understood.
   
   Computer Science textbooks should not be sold based on weight but on content. Do yourself a favor and purchase Head First Java.



2. I purchased this book after I had taken a Java class that used the Head First Java book as a textbook. I could not stand trying to use that book, so I purchased the Deitel book. It is a great book to learn java and to use as a reference. I have continued to use this book in every java class I have had and even purchased another Deitel book (C#) because they are so informative and easy to use.



3. Used this book for a hybrid Introduction to Java Program Course. Didn't need to e-mail the professor at all for help on assignments or online tests. I recommend either jGrasp or Netbeans for your compiler. Used both and they were both extremely helpful.



4. There is no other book which is so complete and student oriented like this. It is worth any penny of its price. It covers programming from the basics and it takes you to an intermediate level of knowledge. The presentation of the ULM stuff in combination with OOD/OOP is super.
   
   If you want to learn Java from scratch this is the book!



5. I purchased this text for my class on Java Programming. I never had experience with any Object Oriented Programming (OOP) languages such as C++, C# and Java before. I love the way that this text introduces the concepts "Object" and "UML" and tries to familiarize you with complex terminology and structure of Java. Sometimes you feel confused with terms such as method, class, argument, identifier adn etc., but the way that this text presents and gives the examples for each of them is excellent. Case Study examples are complete with thorough explanations and are "oriented to objects".
   
   No doubt that I am confident in giving 5 stars to this text. However, I must mention couple cons I encountered in the text and I hope Authors will take'm into consideration in future editions:
   
   1) "Error Prevention", "Good Programming Practice" and other tips occur in the middle of the text quite frequently and therefore are sometimes a bit distracting when you read the text. However, sometimes they do contain very important concepts and definitions for terminologies which are very pricy to ignore or skip (sometimes I did so in order to focus on the main text:-( ). Therefore I would urge the authors to incorporate those tips into the text so that readers would neither skip those concepts nor be distracted by frequent occurance of the tips.
   
   2) I personally had difficulty in installing the JDK and JRE's latest versions and the directions in the text are not user friendly.
   
   3) The "Examples" folder in CD does not have Appendix M.
   
   Nonehteless, these cons do not affect the overall quality of the text, and again, it is highly recommended to own one!