3 comments about Java Pocket Guide (Pocket Guides).

1. This is a handy pocket reference/guide for the intermediate or advanced programmer. All materials are well-organized and illustrated with concise examples of code. It is "worth it's weight" and should be on every Java programmer's reference bookshelf.



2. This is a model for all reference books in my mind. Clearly written and to the point. There are sections covering all the main aspects of the language. It is well worth getting for any/all Java developers. Even though I know Java, I have been referring to it when I travel.
   
   An easy purchase.



3. I don't know about you, but when I'm confused about something, I'm really confused. I need an example to clear up my confusion or my memory. This book gives examples in the most superficial of terms. It is designed to be a quick guide to J2SE through the Java 6 Platform, and quick is what it is. It is not going to jump start you if you need a real jump start on an issue you have forgotten. The most useful information is at the very end of the guide where it talks about the Java Scripting API, tools, and UML. The first half of the book is oriented towards the Java programming language and the second half is about the platform components and some special topics.
   
   If you need useful examples in an accessible format I still suggest the Core Java books by Cornell. They may be somewhat unwieldy to lug around on trips, but they get the job done. Java Examples in a Nutshell is somewhat outdated, but it still can clear up some questions on parts of the language that haven't changed over the years. If you are new to Java I absolutely recommend against getting this pocket guide. You'll be lost. I include the table of contents since it is currently not listed in the product description.
   
   Chapter 1. Naming Conventions
   Section 1.1. Class Names
   Section 1.2. Interface Names
   Section 1.3. Method Names
   Section 1.4. Instance and Static Variable Names
   Section 1.5. Parameter and Local Variables Names
   Section 1.6. Generic Type Parameter Names
   Section 1.7. Constant Names
   Section 1.8. Enumeration Names
   Section 1.9. Package Names
   Section 1.10. Acronyms
   Chapter 2. Lexical Elements
   Section 2.1. Unicode and ASCII
   Section 2.2. Comments
   Section 2.3. Keywords
   Section 2.4. Identifiers
   Section 2.5. Separators
   Section 2.6. Operators
   Section 2.7. Literals
   Section 2.8. Escape Sequences
   Section 2.9. Unicode Currency Symbols
   Chapter 3. Fundamental Types
   Section 3.1. Primitive Types
   Section 3.2. Literals for Primitive Types
   Section 3.3. Floating-Point Entities
   Section 3.4. Numeric Promotion of Primitive Types
   Section 3.5. Wrapper Classes
   Section 3.6. Autoboxing and Unboxing
   Chapter 4. Reference Types
   Section 4.1. Comparing Reference Types to Primitive Types
   Section 4.2. Default Values
   Section 4.3. Conversion of Reference Types
   Section 4.4. Converting Between Primitives and Reference Types
   Section 4.5. Passing Reference Types into Methods
   Section 4.6. Comparing Reference Types
   Section 4.7. Copying Reference Types
   Section 4.8. Memory Allocation and Garbage Collection of Reference Types
   Chapter 5. Object-Oriented Programming
   Section 5.1. Classes and Objects
   Section 5.2. Variable Length Argument Lists
   Section 5.3. Abstract Classes and Abstract Methods
   Section 5.4. Static Data Members, Static Methods, and Static Constants
   Section 5.5. Interfaces
   Section 5.6. Enumerations
   Section 5.7. Annotations Types
   Chapter 6. Statements and Blocks
   Section 6.1. Expression Statements
   Section 6.2. Empty Statement
   Section 6.3. Blocks
   Section 6.4. Conditional Statements
   Section 6.5. Iteration Statements
   Section 6.6. Transfer of Control
   Section 6.7. Synchronized Statement
   Section 6.8. Assert Statement
   Section 6.9. Exception Handling Statements
   Chapter 7. Exception Handling
   Section 7.1. The Exception Hierarchy
   Section 7.2. Checked/Unchecked Exceptions and Errors
   Section 7.3. Common Checked/Unchecked Exceptions and Errors
   Section 7.4. Exception Handling Keywords
   Section 7.5. The Exception Handling Process
   Section 7.6. Defining Your Own Exception Class
   Section 7.7. Printing Information About Exceptions
   Chapter 8. Java Modifiers
   Section 8.1. Access Modifiers
   Section 8.2. Other (Non-Access) Modifiers
   Chapter 9. Java Platform, SE
   Section 9.1. Common Java SE API Libraries
   Chapter 10. Development Basics
   Section 10.1. Java Runtime Environment
   Section 10.2. Java Development Kit
   Section 10.3. Java Program Structure
   Section 10.4. Command-Line Tools
   Section 10.5. Classpath
   Chapter 11. Basic Input and Output
   Section 11.1. Standard Streams in, out, and err
   Section 11.2. Class Hierarchy for Basic Input and Output
   Section 11.3. File Reading and Writing
   Section 11.4. Socket Reading and Writing
   Section 11.5. Serialization
   Section 11.6. Zipping and Unzipping Files
   Section 11.7. File and Directory Handling
   Chapter 12. Java Collections Framework
   Section 12.1. The Collection Interface
   Section 12.2. Implementations
   Section 12.3. Collection Framework Methods
   Section 12.4. Collections Class Algorithms
   Section 12.5. Algorithm Efficiencies
   Section 12.6. Comparator Interface
   Chapter 13. Generics Framework
   Section 13.1. Generic Classes and Interfaces
   Section 13.2. Constructors with Generics
   Section 13.3. Substitution Principle
   Section 13.4. Type Parameters, Wildcards, and Bounds
   Section 13.5. The Get and Put Principle
   Section 13.6. Generic Specialization
   Section 13.7. Generic Methods in Raw Types
   Chapter 14. Concurrency
   Section 14.1. Creating Threads
   Section 14.2. Thread States
   Section 14.3. Thread Priorities
   Section 14.4. Common Methods
   Section 14.5. Synchronization
   Section 14.6. Concurrent Utilities
   Chapter 15. Memory Management
   Section 15.1. Garbage Collectors
   Section 15.2. Memory Management Tools
   Section 15.3. Command-Line Options
   Section 15.4. Resizing the JVM Heap
   Section 15.5. Interfacing with the GC
   Chapter 16. The Java Scripting API
   Section 16.1. Scripting Languages
   Section 16.2. Script Engine Implementations
   Section 16.3. Setting Up Scripting Languages and Engines
   Chapter 17. Third-Party Tools
   Section 17.1. Development Tools
   Section 17.2. Libraries
   Section 17.3. IDEs
   Section 17.4. Web Application Platforms
   Section 17.5. Scripting Languages
   Chapter 18. UML Basics
   Section 18.1. Class Diagrams
   Section 18.2. Object Diagrams
   Section 18.3. Graphical Icon Representation
   Section 18.4. Connectors
   Section 18.5. Multiplicity Indicators
   Section 18.6. Role Names
   Section 18.7. Class Relationships
   Section 18.8. Sequence Diagrams

3 comments about Eclipse Web Tools Platform: Developing Java(TM) Web Applications.

1. Though I have had some experience in Java, Eclipse, and WTP, a recent project required me to get more into depth. This book got me through the whole development process. It explained to me clean coding techniques when writing web apps in Java, how to get my web server up and running for use with WTP, to get my apps to talk to the server, debugging using different tools, and unit testing in a web environment.
   
   This book was an invaluable addition to my collection, and is also a great reference now that I have mastered these concepts.



2. Eclipse Web Tools Platform: Developing Java(TM) Web Applications
   
   This is an excellent book; I specially liked the iterative approach (for example, for presentation tier, iteration 1: HTML, iteration 2: add CSS, iteration 3: add Javascripts, iteration 4: XML and XSLT, iteration 5: DTD)authors have taken. I have used examples from this book, with Eclipse and NetBeans, of course for Eclipse user this book has added value, since it goes through configuration of Eclipse and recommended practices. Please ignore the gripe about errors in the code; there are two minor errors which are detailed in the errata on book's companion site, it doesn't take more than a minute to fix those two issues.
   
   Authors discuss All three tiers in great detail. How about this, by page 85 you would be deploying a simple web service (and you would be amazed how simple it is).



3. To give a brief background about myself. I have been one of the primary contributor and committer of the Web Tools Platform (WTP) eclipse tools project since its inception through WTP 1.5 release. I contributed the Validation Framework component for this project. I read a large portion of this book and can say that this most comprehensive book that explains the complete WTP in a step by step fashion that can be help you easily understand the whole WTP project, its sub projects, its components and features through several real world examples. I strongly recommend this book to all users and contributors of WTP.
   
   Vijay Bhadriraju, IBM

5 comments about Ant: The Definitive Guide, 2nd Edition.

1. This book can take you from zero Ant knowledge to being productive in a matter of days. After starting with some simple examples, it builds up the following concepts very well: properties and types, compilation, deployment, testing with JUnit, working with CVS, and Eclipse integration. I skipped chapters 8, 9, 10, and 12 because I did not anticipate a need for them right now. However, if I need to know about web deployments, working with XML docs, optional tasks, and extending Ant I know that this book covers these things too. To get the most out of the book, you need to download ant to your computer along with the example code from the book's web site. It is very easy to modify the code and see how different options for the various tasks work.



2. This book provides a good enough introduction to Ant, but it only takes you to the point of knowing how to use Ant and not the point of knowing how to use ant on a project of any size. As an introduction it works well. You learn how to get up and running with Ant very early on in the book, and you learn all of the key tasks rather quickly as well. Everything is explained clearly, and it seems reasonably organized. What it lacks is really any explanation of various best practices for using ant, whether on a small program or a large one. For a book of this size, I was surprised at the absence of this info and ultimately I felt that it was only a bit more useful than the free online docs for ant.



3. Apache Ant is the primary build tool for Java projects and this book is excellent introduction to it. Although the title is misleading - this is not really a definitive guide (its not really reference book for starters), it is well written and easily understood. If you work through this book from start to finish then I'm confident that you'll come out the other end as an Ant expert.



4. Web research on Ant revealed a lot of explanations, but they were very hard to understand. And I didn't want to waste time scratching my head. This book explained what Ant is and how it works in an approachable way without insulting my intelligence. The author obviously has a lot of experience in Ant and many of the other technologies it interacts with. While other comments have pointed out that it's not a reference, I can easily get those other details on the internet. This book got me up and running with Ant quickly and painlessly. It contained useful examples that actually worked when I tried to follow them.



5. This book is a regurgitation of O'Reilly web material. This book had a real opportunity to discuss Ant internals or at least something that can't be found on tech sites or the software documentation. Project wikis will undoubtedly replace the need for tech books of this sort.

5 comments about Groovy in Action.

1. This book is fantastic. Very well done, easy read. It was the first tech book that I read cover-to-cover -without getting bored- in a long time. The author does a good job of explaining how Groovy works under the covers and does a great job of detailing how to make effective use of it.
   
   The language itself is also impressive and I hope Groovy gets the attention it deserves. I hope all Java developers read this to see what they're missing in Java-land. :-)
   
   Hindsight is 20/20, I'm sure the authors are sorry they included the last chapter on Grails as they did. But I don't fault them, as I'm sure the publisher was not uninvolved in that decision... ;-)
   
   I'm giving it 5 stars anyway. Good work!



2. While getting a little long in the tooth (GINA was released pre-Groovy 1.0, Groovy is now above 1.5), the material presented in the book is still very relevant and helpful. The biggest issue is that some of the newer (and cooler!) features, such as ExpandoMetaClass, of the language are not covered.
   
   That being said, this is still a great introduction to the a language that will likely become an important player in Java shops as developers migrate existing designs to take advantage of the power the dynamic programming provides. The authors do a great job of explaining the concepts and syntax of the language, making it easy to quickly begin writing code of your own.
   
   While books such as Groovy Recipes: Greasing the Wheels of Java are now available that cover the newest features in Groovy, a perusal of GINA can help to flatten the learning curve.



3. This book is totally awesome. The book makes it very easy to jump around and come back to previous chapters. The book's online forum is great too. The author(s) respond very quickly. It is well worth the money. Order it now and you will be programming in Groovy very quickly.



4. For those of you who haven't heard of Groovy, Groovy is a scripting language that is built on top of Java. Since it is written on top of Java, a Java developer can pick up pick Groovy in a snap.
   
   I first heard about Groovy In Action (also known as GINA) during a Groovy presentation almost a year ago, the presenter was referring to Groovy In Action as one of the best references out at the time, After reading GINA, I was not disappointed. The roadmap given at the beginning of the book is a great guide to see how the book is organized out. As an added bonus, the book includes some great reference information at the end of the book. It contains Groovy Language information, a GDK API quick reference, and several great cheat sheets for items such as closures, lists, etc.
   
   The book is full of great examples that you can use (some of the examples illustrate some of the finer points of the language).
   
   In fact someone recently asked about where to find a complete specification of the Groovy Language. Guillaume Laforge, Groovy Program Manager and co-author of Groovy In Action, responded that the most current information can be found in Groovy In Action (source user@groovy.codehaus.org mailing list 3/16/2008).
   
   Groovy in Action is one of the Groovy books that is a must have for anyone looking to get into Groovy Development.



5. I feel like Groovy is like a programming language "Eintopf", it aggregates some best characteristics of a variety of programming languages. No matter which programming style you prefer - procedural, functional, object-oriented, meta-programming, static typed, dynamic typed... - Groovy has much to offer. The most beautiful thing is, you can easily combine different programming styles in one language and write most concise and self-explanatory code to solve your problem. With Groovy, you suddenly have so much mind-freedom, you have the choice of expressing your algorithms as close to the nature of the problems as possible.
   
   There are languages having very concise syntax but the code is not easy for human to read. There are languages and APIs require more strikings on keyboard than thinking. Groovy is different. You have all kinds of syntax sugar while the code still tells a literal story in your problem domain.
   
   The only fields I think Groovy might not be suitable are the machine-level infrastructures and image/audio/video processing. C and assembly languages are not replaceable by Groovy. In most other application fields, using Groovy can dramatically boost programmers' productivity and reduce programming errors.
   
   I started off by simply renaming all .java files in my test packages to .groovy files. Worked. Then tried out it's closures and curry calls. For me there are a lot more to explore. Haskel fans will like Groovy. Smalltalk fans will like Groovy. Python fans will like Groovy. Lisp fans maybe too. Java folks? I for one, have already been conquered. If you program at all, by all means do yourself a favour and have a look at Groovy.
   
   Groovy in Action is an excellent book on Groovy and programming. Get this book and get the insight, you'll be glad you do.

5 comments about Ajax in Action.

1. It's amazing how much the JavaScript world has changed.
   
   This book has a relaxing style, and it was enjoyable to read. However, it no longer represents what I think of as "modern" JavaScript. For instance, it doesn't cover closures until appendix B, and even then it tells the reader to avoid them. These days, having studied Dojo, jQuery, and Douglas Crockford's videos, it's clear that closures are at the heart of how modern JavaScript is written.
   
   The copyright for this book is 2006, yet the index doesn't even mention Firebug, YUI, dojo, or jQuery which are now staples of the JavaScript community. Although, dojo is at least mentioned in the list of Ajax frameworks and libraries.
   
   This book is an interesting piece of the history of JavaScript, but for those wanting to learn modern JavaScript, I recommend watching Douglas Crockford's videos instead.



2. i am very interested in AJAX learn and this book is essential for any person that work in the web, how web developer, web desginer and others. you can learn the structure and the metodology about AJAX and JavaScript too. It is great and interesting



3. I've bought the portuguese version of this book (AJAX em Ação), and I agree that it was incorrectly named.
   I have a good experience with AJAX, and I was looking for an "AJAX bible", with hacks and something like this... but, like other people here, I am disappointed.
   The book is excellent as a guide for project patterns that can be applied not just to AJAX, but to any web project. But the title, "AJAX in Action", suggest another type of content.



4. Looking for the latest DHTML tricks and Javascript libraries? You came to the wrong place: this was published in 2005.
   
   But I really liked this book. All you need is competence with HTML, CSS and Javascript, and Ajax in Action will help you understand what makes Ajax different from the traditional client-server architecture of web apps. It also introduces some design patterns and other basic considerations, e.g. cross browser issues. The second half of the book has several examples that illustrate what Ajax can buy you.
   
   If you're already doing Ajax, there's not likely to be much here of any practical value, and a lot of the basic issues have been finessed away with the more common Javascript libraries. But if you're looking for a higher-level overview of the principles of Ajax and the issues involved in delivering the Ajax experience across browsers, this is still very relevant.
   
   Reading Ajax in Action is not going to make you an expert. But this (or something like Head Rush Ajax) is a very good introduction.



5. This book covers lots of ground coming in at 600 pages of real content. I almost gave this book 3 stars until I re-read it. It may seem verbose for the more experienced programmer, but I think would be a perfect read for the novice Javascript programmer. It really is packed full of great implementation ideas and good practices, such as the use of software patterns (MVC, singleton, adapter) and extensive code refactoring. There are tons of screen shots, images, diagrams, code examples and snippets, and external references. Although the AJAX protocol is server-side neutral, the author implements the backends in Java, C#, PHP, and VB.NET.
   
   The biggest drawback is security coverage. Security issues in the AJAX world have really unfolded since this book was first published. This title does dedicate about 30 pages (chapter 7) to security. The author touches on the basics, like securely parsing XMLHttpRequest response data. However, I would highly recommend Ajax Security for a more in-depth study. "AJAX Security" is almost the size of this book, but entirely dedicated to security and about 2 years newer.
   
   The book concludes with five big example applications. The fourth example implements a live search. It employs XSLT for XML parsing and presentation, which really piqued my interest. For me, the live search example is the highlight of the book.

5 comments about GIS for Web Developers: Adding 'Where' to Your Web Applications.

1. The book is a *solid primer* for understanding GIS data and its usage.
   
   It will walk you through vectors, projections, and rasters. You'll be introduced to spatial databases and OCG (with a focus on Open Source tools).
   
   This will get you going... places :)



2. Prior to reading this book, my experience with mapping technologies was limited to writing Google Maps applications and using its geocoder. I didn't even really understand what a geocoder was.
   
   Scott Davis provides a friendly, easy-going assist to learning the bizarre complexities and conventions associated with real mapping technologies. I was frankly dismayed at the state of the art, with its odd compromises and incomplete, conflicting tools. But Scott leads the reader through the maze quite effectively.
   
   If you're ready to move beyond simple markers and lines, this book shows the way to _real_ mapping applications.



3. We have a hard time as software engineers mastering our own concepts. Once we are asked to work in a non-trivial domain like geospatially-enabled environments, it is easy to get lost (pun intended). This book acts as a map to the world of maps. It shows you where you are; in this case, building web-based applications that need to visualize spatially-oriented data. It shows you where you can go without taking too many trips down unnecessary rabbit holes. In short, Scott walks masterly on the very fine line of theory and practice making it both useful and instructive.
   
   In addition to the informational content, the book is one of the more beautiful computer books I've seen recently. The decision to go with color plates for the images is key. In order to fully appreciate the power of visual contexts like this, you have to see the richness of the data.
   
   I worked on one of the first "whole Earth" environments 14 years ago and would have gone bananas for a book like this. The field has changed pretty dramatically since then with the emergence of both the Web and rich and complicated standards like those we are seeing from the OGC. This book lays enough foundation of the theory and catches you up to the new and sexy tools available to us now.
   
   We are not genetically-programmed to stare at words and tables. We are visual creatures and gain real insights when we can see relationships literally laid out in front of us.
   
   Do your customers and users a favor and add some "where" to your applications. Do yourself a favor and pick up this guide to help you along the way.



4. GIS (Geographic Information Systems) is one of the most important development technologies to be applied in the past few years. By using GIS concepts you can learn to apply geographic code to any and all applications easier and better than ever before. With 'GIS for Web Developers: Adding 'Where' to Your Web Applications' you can learn the ins and outs of how and why you will want to add a GIS presence to your application. With plenty of maps, code samples, and a look at the different GIS viewers and editors out there in the world today, this is a good book for any developer that wants to learn more about GISs and their relationship to GPSs.
   
   Good introduction to the technology.
   
   **** RECOMMENDED



5. I was not familiar with GIS system and I got this book to figure out how things work. The book turned out to be a great help for me. Since everything was very new to me I ended up spending a lot of time to learn about the PostGres database, it PostGIS extention and Geoserver. So do not take it as a complete walk through tutorial but it certainly great help when you get stock somewhere. Bear in mind that I am quiet computer savvy and familiar with linux, java and such. Overall, I recommend this book if you are a web developer that wants to deal with spatial data and his needs are beyond things that can be done simply on google Map, yahoo map and such.

4 comments about The Definitive Guide to Terracotta: Cluster the JVM for Spring, Hibernate and POJO Scalability (The Definitive Guide).

1. A must have book to buy to understanding Terracotta Best Practices,I personally was an early adopter and has had much success, Terracotta has proven over the years to help ease the development of HA systems, that scale from the start...this book has real world examples (not just Hello Worlds! Programs) ..to build and deploy systems backed by Terracotta for your enterprise.



2. This book really presents an in-depth coverage of the power of Terracotta, backed by real world how-to examples.
   
   The only thing that could be better is the language. Sometimes the concept is explained in a very dense language upfront, so by the time you get to the example, you get a little lost and need to go back and re-read some paragraphs.
   
   Besides that, it's one of those examples where the content compensates the shape. A must have if you are looking forward to turning you application into a clustered solution.



3. This book is a must for anyone trying to understand and get real performance out of a custom terracotta deployment.
   
   There is a lot of information in this book that is either not on the terracotta wiki or is scattered across many sites.



4. This book goes into a lot of detail about how and why Terracotta was made. It goes into a lot of topics such as scaling, the jvm, synchronization, etc.
   It talks about the philosophy of terracotta and goes through in detail about the choices that you have when for example, you have to scale, and the tradeoffs of each of those choices.
   In short, this book is a good read, even if you are not going to be using terracotta just yet.

5 comments about Core J2EE Patterns: Best Practices and Design Strategies (2nd Edition) (Sun Core Series).

1. I bought this book for preparing for SUn Certfied Enterprise Architect assignment( part II). I am very happy with this book. It gives examples for all J2EE patterns in a very lucid way and this book has helped me a lot.



2. It is a MUST-HAVE J2EE architect/developer book. It provides the most important and relevant patterns in J2EE design and development based on Gang of Four. The architecture guidance and best practices described are very valuable.
   
   This book needs an update for Java EE 5. Not sure, those updates are posted on their web site.



3. This book should be on the desk of every J2EE architect. Not sure if some of the design patterns still apply for JEE5. We'll just have to see in the next edition.



4. When we learn and start programming we're attempted to write code to solve any problem without find to know if that is the best way. No matter if the code is about 3,000 or 300 lines, which matter is if you could solve the customer's problem. But a lot of problems were solved by experienced programmers and software architects and they have documented these problems for us. So, if somebody wrote tested-good-code, why we'll "reinvent the wheel"? My opinion is: study the progrmming language, try to write and solve a lot of problemns, and than study this book. After read you'll have much more skills to solve problems in shorter time. I recommend for intermediate through advanced programmers.



5. The book Core J2EE Patterns provides incredible value by offering insight after insight into the J2EE architecture. I don't have the first edition of this book and have read the second edition only, and it's truly a book worth owning if you're doing any sort of J2EE-based development.
   
   Core J2EE Patterns is especially impressive in the thoroughness with which it covers the essential aspects of the J2EE architecture. The experience of the authors shines through the pages. And I fully agree with the reviewer who notes that "the strategies in this book will make your applications more robust, make you more productive, and make your code easier to understand and maintain." Very true, especially the noted point about making your code easier to understand and maintain!
   
   Another useful book in the same category as Core J2EE Patterns (and well worth looking into) is Martin Fowler's book entitled "Patterns of Enterprise Application Architecture". The Fowler book paints the landscape of enterprise application architecture with broader strokes than does Core J2EE Patterns; that, of course, is to be expected, as implied by the titles of the two books.
   
   In sum, if you're doing any sort of J2EE-based development, you owe it to yourself to get a copy of Core J2EE Patterns!

5 comments about Core Servlets and Javaserver Pages: Core Technologies, Vol. 1 (2nd Edition).

1. Not a book for beginning programmers, however if you have minimal java experience and are proficient in other languages you will be able to figure it out.
   
   This book is an excellent read but has little reference value because it has no index. It is very informative if you are looking for something that explains the in's and out's and why's of .jsp and servlets, but if you are looking for lessons and sample code, you will have better luck looking for it online. But then again if you have experience, you can figure out the code yourself -not that difficult.
   
   P.S. There is a wealth of hints and code at java.sun.com That site coupled with this book was enough to get me on my way.



2. I bought this book based on reviews of others, and found it to be a disappointment. The coverage is mediocre at best, and a lot of the techniques that the author uses are outdated -- probably just carried forward from earlier editions of this book.
   
   The thing that bothers me most of all is that throughout this book, the author keeps referring the reader to Volume 2 for coverage of the more advanced topics. Unfortunately, Volume 2 has been delayed for over a year, and may not ever be released. Had I known Volume 2 wasn't coming out soon, I would have gone with a different author for learning servlets and JSP.



3. If you're learning web servlet programming this is a great book. I've found it hard to put down. The examples are great and the explanations are too.



4. This is an excellent book with lots of good examples. I'm new to servlets and jsp and I recommend it to anybody learning how to develop java web apps.



5. This has very detailed examples and explaination in the design and concepts of Java Servlets. Good examples help accelerate learning process. Very useful for servlet based web app development

5 comments about Java All-In-One Desk Reference For Dummies (For Dummies (Computers)).

1. when i took c programming, i tried the all in one desk reference for c. it was a godsend. so when i took java a semester later, i eagerly bought this book hoping it would work the same miracles. it did not. it doesn't focus so much on the OOP aspects of java, and frankly is very confusing. i was quite dissapointed.
   
   i tried two other java books after that, and finally got it right on the second try. 'head first java' is the holy grail of java books. don't waste your time, or money.. just get 'head first java' and thank me later :)



2. By far the best intro to Java I have ever encountered, detailed explanations of java programming concepts, followed by example code. Written in the tongue-in-cheek humor typical of Dummies books, even after becoming a highly experienced java programmer, you'll always keep this book within an arm's length of your computer.



3. 9 books in 1... All it really is is the good books that you should have stripped and thrown into one book and haphazardly executed. This book was an utter waste of $30 I spent on it. I do not recommend this book at all you won't really learn anything out of it. If you really want to learn Java go pick up the "Think In Java 4/e" by Bruce Eckel. I'll state it again this book is poorly executed and DEFINITELY is NOT made for a reference...



4. This book is "very" helpful. I am preparing for my masters in IT and it has helped me to prepare for some of the more challenging Java programs.



5. I found this book to be a great refresher. That is, having written Java in the past, writing mainly C# in the last 8 years, I needed to update my knowledge of Java since Java 1.2. The authors(s) do a good job of keeping the material from becoming too dry. Many programming books start with too much theory before diving into practical code. This book starts with a quick tutorial on two programming tools, TextPad and Eclipse, and does a good job explaining enough of both tools to get you started. The reason for two tools is that if you are new to a complex IDE environment, the author(s) introduce a text centric tool (TextPad) and a more advanced GUI based tool (Eclipse).
   
   As one reviewer noted, it is best to think of this book as one, larger book (paraphrasing). The author states that the book is not intended to be read cover-to-cover yet I found reading cover-to-cover was better for me. The material starts with the simple, "Hello World" style examples covering editing, compiling, and running code. Simple examples are interspersed with Java requirements for file naming, class structure, running examples, data types, if-then-else, loops, switch, exceptions and other introductory concepts.. Following books/chapters cover object oriented programming, more formal class structure, subclasses, inheritance, interfaces, inner classes, packaging ad documenting classes, String, Array, and collections, thread programming, network programming, regular expressions, recursion Swing (Java's GUI API), We programming files and databases, XML operations, and applications with drawing and animation.
   
   Jammed packed as this book is with nearly all basic concepts a beginning to intermediate Java programmer needs to know, the material is intended to get you started and only scratches the surface of what a professional Java programmer will acquire with time. In my opinion, there is a good balance of material with a decent writing style. I knocked one star off the review, however, because there are some rather obvious blunders in the book. To my knowledge, there are no errata posted for the book, so it may take you about one star's worth of head scratching to get around those blunders. Fortunately, this is the exception (no pun intended) and not the rule.