5 comments about JSR-168 Portlet Development Simplified, Second Edition: Learning How to Develop Effective, JSR-168, Portal Applications, Everything from the GenericPortlet to the Struts and JSF Apache Portlet Bridges.

1. This is the right book for anyone trying to learn, or working with portal.
   
   The book covers just about every aspect of JSR168, and it does it in a very thought out and methodical manner. The book is definitely technical, but the writing style is very laid back, making it an enjoyable read.
   
   There's not other book on the market that does as good a job covering portlet development as effectively as this book does.



2. it is a good book, i read because the information, in this books help me to solve a lot of questions about portlet.
   
   read and you will see.
   
   i give five stars.
   
   guillermo urdaneta



3. Very similar in style and format as the Hibernate and JPA book by the same author. (Hibernate Made Easy: Simplified Data Persistence with Hibernate and JPA (Java Persistence API) Annotations)
   
   This book provides complete coverage of the JSR168 API, without going into peripheral topics such as skins, themes and third party extensions. There are sections on Struts, JSF and Ajax though, which are good.
   
   I like the style of these books, but the informal feel might not be for everyone. Sample content is available from the book's website. I'd suggest getting a feel for the authors style first by viewing it. If you like the way the author writes, you'll learn alot from this book.



4. I picked this book up along with Hibernate Made Easy, and found booth of these books to be written in the same funny and informative manner.
   
   Definitely a must have for portal development.



5. Its a very short book, but covers every aspect of jsr 168 programming thoroughly. A good book for getting an overall review of portlets. Must read.

5 comments about What is WebSphere? Java, J2EE, Por and Beyond! (Demystifying IBM's Middle Tier Technology).

1. This book is a good introduction and overview of WebSphere, but for the price I paid, I was simply amazed at the number of typos, grammar, and spelling errors. With all the money this author is making on this book (and I think it is overpriced), one would think that he could afford to hire a proofreader and clean it up. Just for fun, I kept track and found 50 typos/errors while I was reading, and since the book is only 280 pages long, that's one error every 5 pages! Poor quality, if you ask me. Although the content is helpful and well organized, the multiple errors give it a sense of being unprofessional.



2. I wonder if anyone proofread this book. Although the book contains a nice overview of what WebSphere is about, someone forgot to clean it up, but made sure that the hefty price tag was in place.
   
   Anyway, I recommend this book to a WebSphere newbie, as long as one can stand the errors (all grammar-related) and won't faint from the book's price.



3. I have over 10 years of software development experience and I am glad I chose this book to start learning about IBM Websphere Application Server. This book definitely delivers what it claims to in its title. It is written in a pithy, very witty yet technically sound style. Read this book for an insightful introduction to distributed computing using IBM Websphere platform.



4. Anyone who is new to the world of J2EE SHOULD read this book. Also anyone new to Websphere MUST read this book as an introductory book. It clears up a lot of questions for any newbie in J2EE (as well as Websphere) field. (A J2EE intern/newbie in my group borrowed this book from me for a couple of days and on the third day bought his own copy - He told me that this book helped him clear a lot of questions).
   
   This book lays a strong basic foundation on many topics in J2EE which is very very helpful in the long run. And I found a lot of stuff in this book which I was unable to find in a LOT of other books or online material . The author writing style is simple AWESOME/ AMAZING /BEST /SUPERB. I found a lot of other technical authors writing style to be boring and kinda intimidating. But Mr. McKenzie's writing style is simply fantastic, he explains the topics to point in a very crystal clear way and with a bit of humor which really makes the reading very enjoyable(and of course his explanation of technical details is pretty interesting/intriguing). (Also, I didn't see any author responding to questions/queries so fast.. I mean the author of this book Mr. (Cameron) McKenzie is lightning quick in answering your questions. I had a couple of questions in EJB related chapters and I e-mailed him regarding the same.. he replied to my e-mail with in 5 minutes FLAT with answers to my questions.. his explanation to my questions very crystal clear as always).
   
   I would rate this book 5 out of 5 stars (if possible more than that). Thank you Cameron for this awesome book.



5. I purchase the book based on some review. But it turn out it was really out-dated and some of the term the author himself can't explain well. It does has pulp fiction style, not suitable and serious enough for the real world at all. $65 for a 279 paged (2/3 of junk non-sense), pocket size out-dated little book? not worth it.

5 comments about Java Performance Tuning (2nd Edition).

1. (...)
   This is a substantial and comprehensive text on many aspects of Java Performance characteristics, explaining the effects of Java design and coding practices, and giving advice to help the Java Programmer design, code, and optimize applications to execute efficiently. It is not a programming tutorial for the novice, but will enhance the knowledge of an experienced programmer for Java specific concepts. Its goal is to explain how to tune existing programs to improve efficiency, but the explanation of the underlying Java Virtual Machine and the details of compiler code generation are so revealing that any developer will gain valuable insight into smart Java programming design.
   
   The book consists of 537 pages divided into 19 chapters and is quite easy to understand for readers who have programming experience. Each chapter ends with a performance checklist section to summarize what you need to do with regard to that chapter's illumination.
   
   The clearly organized chapters permit you to selectively read any of interest because they are mostly independent subjects. You can read a chapter on Strings and learn all about how these objects are implemented and the ramifications of various usages. It also addresses some algorithmic issues, such as sorting, garbage collection, and threading. I thought many of the revelations of code generation and object storage will seem obvious to programmers who have experience looking at generated code in other languages which will make for fast reading.
   
   The very comprehensive nature of the book provides valuable information for all Java developers, and yet is helpful for just a quick understanding of particular Java issues. I enjoyed just reading through some of the chapters to confirm or enhance my understanding of particular execution characteristics.
   
   (...)
   
   I rate this book 4 out of 5 for programmers with Java experience.
   
   Note: this book has nothing to do with Java Scripts.



2. This book provides good ideas on tactical optimization for performance gain but could have also covered architectural patterns and process for performance optimization.
   This book covers the areas of optimizing compilers, I/O, RAM footprint, small object management and deployment etc.
   
   Next edition may also cover architectural decisions (or patterns) which are costly to reverse later. Also, coverage on processes for performance optimization will be great in next edition. Getting a program to run faster costs money, and thus this business decision should have process ( or guidelines for series of high level actions ) to facilitate the optimization.
   
   Other things, I would like to cover in next edition are
   1) How to choose between "speed up the slow things" or "do the slow things less often".
   2) How to identify ACTUAL areas of improvement. i.e. Importance of automated run that reasonably simulates the program under its usual conditions. (Example, our test on performance gave excellent results. But European customers rejected the product because we had not simulated ocean hop of packets as 2 databases were in America. Or importance of using a multi-user simulation system to identify real problems i.e. transaction interactions etc).
   3) Importance of cohesive, loosely coupled and well factored modules for behaviour-preserving transformations of performance.
   4) Importance of measurement before starting optimization.
   
   Anyway, great book.



3. ... or "You had a whole SECOND to reply? In MY day..."
   
   First: if you are not a 'hardcore' Java programmer: do not bother with the rest of this review, and do not buy this book until you reach that point. It won't help enough to offset the damage it causes.
   
   That said, a bit of context: the project I was working on that inspired me to buy a copy of this book involved a telecom system that had to handle hundreds of transactions a second, with sub-second response times (yes, in Java). Not the biggest system, or the fastest, but definitely not "fancy GUI code", by any stretch of the imagination.
   
   Don't buy this book to learn how to use an optimizer; it isn't a beginner's guide. After buying it, I only ended up using perhaps two of the items covered in the book, while working on the project. But those two points were things that the several hundred collective years of development experience on the project had missed, and every other topic in the book warranted at least the question "did we check for this?"
   
   It is difficult to categorize the audience of this book; it is in the odd position of needing to be far too heavy on theory and detailed explanation to be a "cookbook", for it to be of any use, but it also has to cover topics so diverse that it is unlikely that more than a handful will ever apply to any single situation, so it isn't really a "how to" book, either.
   
   So why did I give this book four stars? Because a different set of points in the book applied on the next project I had to work on. But those 4 stars with a warning: for the audience and topics that it covers, this book it is *very* good, and for anything or anyone else, it will be, at best, nonsense; at worst, using it can be actively counterproductive (as another reviewer noted, several of the things the author covers are not for the faint of heart, and for very good reasonss).
   
   It failed to earn five stars for two reasons: first, while the author has a clear grasp of his material, his grasp of the audience seems to be hazy at times. Like the marketing of the book itself, he seems to have trouble deciding whether his audience is experts looking for that one golden tweak, or novices (who, in this case, should look for a more introductory book on profiling and optimization in general, or the tools they have available, in specific).
   
   The second reason is not a problem with the material itself, just the passage of time - this edition predates the release of the Tiger version (of Java, not Mac OS X), and thus does not cover it. However, anyone attempting to use this book to work with Tiger should, in my opinion, strongly reconsider doing so; while the fundamentals of how to do the analysis remain the same, the details of several of the issues the author discusses are *completely* changed in Tiger.



4. If you are a core Java developer/architect who does performance tuning on a regular basis this should be part of your library.
   
   Over time, this has been the most useful of the dozen or so performance books I own. It's scope is narrow - core Java tuning and it skates over the distributed computing smells that seem to be the most common cause of hot spots in today's Java apps. The author isn't afraid to describe unorthodox or ugly tricks when they can bear fruit. The custom Class object that seemed to offend some reviewers helped me track down a gnarly memory issue in an app that was too bloated for OptimizeIt to be practical. Doing the "wrong thing" to get the "right result" can be the essence of pragmatism. The section on StringTokenizer implementation is a great example of unpicking a typical performance issue from inappropriate use of a general purpose class.
   
   Performance tuning is a specialty that demands pragmatism, confidence, persistence, creativity and a high tolerance for ambiguity and uncertainty. I suspect that only a minority of the population of competent developers have the necessary assortment of personailty quirks to be effective performance engineers. Black and white thinking, sometimes a trait of smart developers, is a disaster for performance engineering.



5. The book covers a wide range of topics with some decent, but out-dated examples. As a collective whole, this writing will get you thinking. However, some suggestions provided are impractical and simply not effective enough to warrant implementation. Providing pros and cons in the majority of examples provides some jewels of information and things to think about, but it does not live up to the massive amount of difficult, wordy reading involved or the overly verbose samples.
   
   I was able to take some things away from this book, but not nearly enough to warrant recommending it.
   
   Sorry guys, it's a dud.

2 comments about Integrating and Extending BIRT (2nd Edition) (Eclipse Series).

1. This book is an impressive extension on "BIRT: A Field Guide to Reporting". The latter described BIRT to a newcomer, showing how to use its features. With a minimal discussion of scripting for customisation. While the scripting certainly involved programming, it was rather minimal, and most of the text showed a declarative layout approach to using BIRT.
   
   The Integrating book is the sequel. Strictly a programmer's book. It assumes you've read the earlier book. But now you need to take the customising [much] further. So here the text shows how to program in Java, not just JavaScript. Essentially, the bulk of the book explains the package org.eclipse.birt, which is freely available and has been built out with many classes. The problem to a programmer is the sheer multitude of those classes. An embarrassment of riches which the book tackles.
   
   Some classes relate to customising the UI. There is a charting API built on top of Java Swing. So you can key off your pre-existing Swing expertise. Swing is pretty easy to learn, and the BIRT graphics classes seem to continue this property.
   
   The only possible problem might be if you prefer SWT widgets for the better native look and feel. But the BIRT contributors correctly decided to support the most popular widget set, which is Swing.
   
   Other BIRT classes relate to getting data at the back end, from various possible sources.



2. It is a very useful book for anybody starting to use BIRT. However, some sections are slightly out of date vs. the new versions (2.2.2) of BIRT in 2007.
   
   The basic concepts in this book are still very useful, otherwise it is hard to find online information explained in such a systematic way and in such details.

5 comments about Java Servlet & JSP Cookbook.

1. Target Audience
   Web developers who are looking for real-life examples of the use of servlets and JSP.

   Contents
   This is a companion-type book that goes beyond strictly reference material to the use of different servlet and JSP features, along with working examples of code to illustrate the concepts.

   The book is divided multiple chapters that each cover a different technique or function:

   Writing Servlets and JSPs; Deploying Servlets and JSPs; Naming Your Servlets; Using Apache Ant; Altering the Format of JSPs; Dynamically Including Content In Servlets and JSPs; Handling Web Form Data in Servlets and JSPs; Uploading Files; Handling Exceptions in Web Applications; Reading And Setting Cookies; Session Tracking; Integrating JavaScript with Servlets And JSPs; Sending Non-HTML Content; Logging Messages from Servlets and JSPs; Authenticating Clients; Binding, Accessing, and Removing Attributes in Web Applications; Embedding Multimedia in JSPs; Working With The Client Request; Filtering Request and Responses; Managing Email In Servlets and JSPs; Accessing Databases; Using Custom Tag Libraries; Using The JSTL; Internationalization; Using JNDI and Enterprise JavaBeans; Harvesting Web Information; Using the Google and Amazon Web APIs

   Review
   I really like the O'Reilly Cookbook series. I read a lot as part of my ongoing study, and often it's easy to understand conceptually what is going on. But making the jump to practical solutions can be difficult at times. The Cookbook series gets plenty of use on my bookshelf as I do my day to day coding. And when it comes to servlet and JSP coding as I continue to learn more about Websphere Application Server, this book will surely become dog-eared like the rest of them. Bruce Perry has done a great job.

   As with most Cookbook titles, each chapter in the Servlet And JSP Cookbook is made up of a number of Problem/Solution/Discussion groupings. This format proposes a coding problem, states the solution to solve it, and then devotes the necessary space to discuss the solution both with text and code. By using this format, you can think through a working solution and determine how to apply that technique to your own problem. Perry covers a wide range of problems that will help both the beginner and the experienced coder. For beginners, the solutions for setting cookies with servlets and JSPs may be just what you need to get started. Experienced people will find the internationalization and JNDI/Enterprise JavaBeans solutions useful. I appreciate the fact that coders of all experience levels can get something out of this book.

   The only caveat I have on this book is that it is very focused on the Tomcat and WebLogic web application servers. If that's your platform of choice, you're going to get everything this book has to offer. For me, I'm partial to the WebSphere platform. While I will benefit from a lot of this book, there are chapters that will have no appeal to me, such as using the Ant package. I will also need to pay attention to the coding examples to make sure that the techniques are coded correctly for my platform of choice. Even with that warning, I would still highly recommend this book to all coders working in this area.

   Conclusion
   This is definitely a title that will be useful to you as you learn more about servlet and JSP programming. It will give you the ideas you need to solve real business problems you'll encounter as a developer.




2. Being an O'Reilly fan it is hard for me to find fault with their no-nonsense approach to technical books, but there is one MAJOR issue I have with this book.
   
   As a developer for a major corporation I cannot use custom libraries for my work, especially when the license (http://www.servlets.com/cos/license.html) does not allow for commercial use. Where it would be helpful to see details on creating say, a multipart request class, Bruce Perry instead uses the com.oreilly.servlet.MultipartRequest class to hide much of the functionality (this is just one example).
   
   This makes little or no sense. Developers in the real world need real examples. Hiding the implementation of such under the non-commercial license pretty much ruins much of the potential application of an otherwise well written book. If you buy this book realise that only some of it will actually be useful in the real world.



3. This book is exactly what it claims to be: a general reference to hundreds of "everyday" situations Java Web developers face. Just as any cookbook, it doesn't go into the "deepest" details about every little thing, and it does give examples of ways to not reinvent the wheel. Some reviewers see this as worthy of only 1 star... This is only a 1 star book for readers who like to reinvent the wheel and waste time on unnecessary details... if you're like me and have deadlines to meet, you'll find what you need here quickly and efficiently.



4. I'm not a big reviewer. I find writing a challenge, even if it's a positive experience, as it is now. I started learning Java a few months ago and bought a number of books on the topics I needed to really create a java website.
   I stumbled on this book as one of the ten or so I purchased.
   
   I haven't touched the other's since. This book has it all, written so clearly that you know the author is very familiar with her subject and understands it thouroughly. It was written in 2003 and discusses Tomcat server as release 4.0 but that does not matter one bit. I was truly able to use this book to put together a website. Servlet, jsp, even java script is covered. I found many questions I had assembled reading the other books being answered in this one.
   Murach's books should be proud of this and I notice that they don't publish a 100 books on a subject; just have a few. I'll bet they're just as good.



5. A good book. Not for someone looking for a "tutorial" or "introduction" on the subjects covered. However, a good reference book to find examples of specific programming problems for someone who already has a good understanding of servlets and JSP. Covers a good number of different aspects of servlet/JSP programming. I also found it a good book to convey some general knowledge in areas like using attributes, DB access, etc. I enjoyed selectively reading different chapters.

3 comments about Introduction to Programming in Java: An Interdisciplinary Approach.

1. Undoubtedly the finest computer science book published to date. This will be the standard for years to come.



2. This is the only textbook that really helped me understand programming in Java - I was so glad to find it!



3. Truly an excellent book: well-written, clear, and very interesting (unusual for a cs textbook). This book is a great introduction to programming, but also to the field of computer science, and is full of exciting examples of applications to problems in other fields, including physics and genomics. A real gem!

5 comments about Alfresco Enterprise Content Management Implementation.

1. This book is for final users of Alfresco, in that it does not contain any code/examples of code.
   
   It is probably useful for content creators and administrators.
   
   Having said that, the book really is Alfresco's user's guide, and a slim one at that.
   
   The layout is very well done and task specific instructions are clear and carefully described, albeit in a succinct way.
   
   For $59.99, the book could have been much more extensive.



2. This book, being the first one written on Alfresco has no competition and really competes only with the public information that is available on the web. The information in this book is all available in different sources (wikis, forums, official documentation and the source code), but this book does a great job of bringing it all together in one reference that is easy to digest.
   
   In addition to the information, it does a great job of providing examples and a walkthrough of the steps to be taken to see the examples work in any Alfresco environment, another plus.
   
   One of the few things I was disappointed in was the section on implementing workflows. This chapter does a good job of describing the differences between the two workflow models that are available in Alfresco, but lacks alot in the approach to explaining the differences between the two. Unlike other sections of the book, there is a real lack of examples that provide a little more 'meat' on the workflow capabilities. That said, you probably need a whole book on workflow and advanced workflow capabilities of Alfresco to really do it justice anyway.
   
   If you are just starting out with Alfresco, this is a great foundation-type book. With software changing regularly, this book was written with version 1.4 and version 2.0 is now out and this book does not cover Records Management/Web Content Management or any of the other new features, so if you are a seasoned user/developer and want to know more about the new features, you'll probably have to wait until the next book...



3. As an early adopter of a new open software product as Alfresco, it's very important to have the kind of structured and organized information this book gives us, that we couldn't find consolidated at Alfresco sites. The book also brings us some scenarios and good practices that are very useful and applicable to real situations.
   
   I just hope that upgrades and new versions of the book continue to be published, and even more specialized books on this subject.



4. This book provides detail that is difficult to find from the online documentation. The only thing I would like to see more on is customizing Alfresco from a developer prospective. Overall the book is a great help in getting up to speed quickly on the features found in Alfresco.



5. The book clarifies a lot of things but need an extension considering web content management and workflow aspects

5 comments about iBatis in Action.

1. The book is concise, good structured and it's enough expresivo. This is the first book that I read in English and I understand in its entirety.
   
   Congratulations Clinton



2. I now have a much better insight into iBatis because the authors provided both background design and detailed information about the product. It was much better than the documentation I found via the web (there's lots to be said for technical and editorial review of a book).
   
   The setup and code examples are excellent. I also like the writing style and structure of the book. Clear and logical.
   
   However, I would like an expanded section on using the Spring DAO with iBatis, as this is now the recommended approach over the iBatis DAO.
   
   Although I was already using iBatis, this book is a welcome addition to my library.



3. This is very good book with nice examples and I think this is even better book for users who have never used any form of ORM



4. claro y conciso..
   con ejemplos puntuales ,, este libro se deja entender a pesar de estar en ingles y de que mi nivel en java no es tan alto.



5. Since this is the only book available on Ibatis, so i purchased it.
   But the latest version of ibatis has a lot of changes and this book is based on the older version.
   I got a lot of information on ibatis online.
   Download ibatis and go through the docs( there is Ibatis_SqlMap.pdf ) and same some money ;)

5 comments about The Elements of Java Style.

1. I'm very disappointed at the amount content in this Book. Sun posted a Java style guide that was essentially the equivalent, but free. Equivalent in terms of topics covered while there were some noticable difference such as variable naming.
   
   One of the redeming qualities of the book though is that it can serve as a coding standard thus saving one from tidious chore of deciding on your own standards. In the end does it really make that much of a difference as long as everyone on your team is following the same standard?
   
   Best part of the book is the title.



2. Several years have passed since this book was first published. Many things have changed in the Java world since then.
   
   However, it looks like development at a corporate level of a software product without adherence to some sort of development and code standards is disappearing. This book contains a very good set of rules and code standards one can start with.
   
   Not that it is important to follow exactly some specific already existing guideline but it is rather vital to have one and keep going with this set of standards. The book suggests a wide range of various well described code standards so that a Development team might build their own set of rules using the book as an example.
   
   I would like to recommend any Development team to have this small but helpful book in their library.



3. Clear, consise and short enough that developers will actually take the time to read, and filled with enough common sense that very few disagreements come from the developers about this.
   We use this book as the basis for our corporate coding standards for our on-shore, off-shore and near-shore. The standards page on our wiki is very short and contains only the few places where we've chosen to deviate from the standards in the book.
   If you've ever tried to have a team develop standards from scratch, you know what a painful process that could be. This book got the whole team (in multiple countries) on the same page very quickly and let us focus our time on getting down to the business of writing software.



4. Other reviews here that attack this book for not being a good design guide are missing the point. This book is a set of practices to make your code easier to read and work better in groups. Each chapter is about some kind of convention (formatting conventions, documentation conventions, etc.). You're not going to learn to program with this guide; you're going to learn to make your programs more usable in a group environment. Yes, it is a pamphlet-sized book: that's the point.



5. As stated in the previous review this "pamphlet sized" book is invaluable to programs working in any sized group. Not only do you need programming style rules, these are pre-defined for you, so there is no time wasted with your team trying to decide on one. I am a project manager over a several groups of computer and software engineers, and after hearing more style arguments than I care to remember this book is now law at our company, it is also followed by our c/c++ programmers in a fashion of sorts... style is important, it does need guidelines, and if you dont follow them you may not have a job for very long... its common since!!!!

5 comments about Java and XML.

1. This book was probably useful back in 2000. Unfortunately, a lot has changed since then, and some of the information in this book is now flat our wrong.
   
   For example the chapter about DOM objects was not updated to include information about recent api releases. So when the book says there is no simple way to serialize a DOM object, that simply is no longer true. You can now do it with the JAXP api.
   
   The book has other problems as well. For example, the section that describes the difference between XSL and XSLT is extremely misleading and not helpful at all.
   
   This is one of the few books that I intend to return



2. Are you developing with Java and need to use XML? If you are, then this book is for you. Authors Brett McLaughlin and Justin Edelson, have done an outstanding job of writing a book that that cuts through all of the hype about XML and put it to work.
   
   McLaughlin and Justin Edelson, begin with the basics of XML. Then, the authors cover three ways of defining the structure of XML documents. Next, they introduce the Simple API for XML (SAX). They also cover less-used, but still powerful items in the API. The authors continue by covering DOM basics. Then, they discuss the various Level 2 and Level 3 DOM modules like Traversal, Range, Events, Style, HTML, Load and Save, and Validation. Next, the authors examine the Java API for XML Processing. In addition, they also show you how to SAX and how it compares to both SAX and DOM. They continue by examining JDOM, a Java-specific object model API. Then, the authors examine another Java-specific object model API, dom4j. Next, they cover JAXB 1.0 and 2.0, as well as the general basics of data binding. Furthermore, the authors show you how to syndicate content. They continue by looking at a variety of techniques for using XML in the presentation, or visual portion of web applications. Finally, the authors provide some brief overview of technologies not covered in depth in this book.
   
   This most excellent book shows you how to use the APIs, tools, and tricks of XML to build real world applications. Perhaps more importantly, this book offers a new approach to managing information that touches everything from configuration files to web sites.



3. This edition was published in Dec. 2006, so when I bought it Jul. 2007 it was the freshest book on the topic that I found. There are a lot of different Java XML tools with overlapping funtions SAX, DOM, JAXP, JAXB, Castor, JDOM, dom4j . . . This really help sort them out.



4. I'm almost finished with this book, but have yet to determine what its purpose is. There is a lot of code about a lot of APIs, but it is not clear how one should approach Java & XML using this book. I think this book was a product of O'Reilly's "Rough Cuts" program, and it is true the book is very roughly written and all the good stuff got cut. Maybe all the material which would make this a good book is on the website.
   
   I must admit I'm very disappointed with O'Reilly as of late. Their books are going down hill rapidly, and I find I'm looking at other publishers (APress) much more often. I used to go to O'Reilly's website almost daily to see what is coming out next, but now I'm considering removing the Ora bookmark from my browser because of lack of use and to create space for other URLs.
   
   I really wish O'Reilly would get their act together and start publishing some well written and well edited books again.



5. Ho trovato questo libro molto interessante.
   
   Copre le varie API disponibili per JAVA per gestire file XML: SAX, DOM, JAXP, StAX, JDOM, dom4j. Inoltre vengono trattati anche alcuni argomenti avanzati, utili per apprendere al meglio l'uso di queste API.
   
   Il libro e' colmo di codice ed e' proprio il codice ad essere utilizzato come strumento didattico. Codice e diagrammi UML riempiono tutte le pagine.
   
   E' un libro molto pratico, rivolto ai programmatori. E' necessario avere una piccola infarinatura riguardo l'XML: viene trattato brevemente nei primi capitoli.
   
   E' consigliato a chi ama libri con un approccio pragmatico.
   
   mircha