5 comments about VBA Developer's Handbook, 2nd Edition.

1. Good reference book... help you find tricks to do automation and to maximize the output of your VBA code. Not for newbies.



2. This book has gotten me out of many scrapes. It is a rare book that can be read from the beginning, while trying out the sample code, as a way to learn the language, or as a reference book, to look up how to use a certain function effectively while writing code. Don't let the title fool you, this book is for those coding in VB just as much as it is for those using VBA. If you are going to buy one book on Visual Basic, let this be the one. If you are going to buy one book on Visual Basic, and see one movie this year, then buy this book and see Amelie. ;)



3. In the introduction the authors state : "To make it possible to stuff as much code into this book, we've had to dispense with material specifically geared for beginners"
   
   I like that - a lot of 'reference' books I've purchased waste many chapters devoted to topics that I would expect to find in 'Inroduction' or 'Beginners' - titled books.
   
   This tome however (all 1073 pages of it!) is totally dedicated to useful code snippets and sound programming principles.
   
   Despite its size I find the book logically structured and very easy to locate the information I need, very quickly - the "Contents at a Glance" page helps immensly.
   
   I'd definitely recommend this book for any VBA developer as an essential resource.



4. This is really the best book i ever found. I have bought several books for Excel VBA. Non of them will explain as detail as this book. Besides, for those people who really interest in VBA, this is really a good book where you can start solve more complex problem.
   
   Non of the books so far i found will teach you how to create data structure using VBA e.g binary tree, linked list, queue and stack thru VBA implementation. it is worth while to keep this book for your future reference...



5. but I wanted to calculate an average cost per day. Obviously the number of days in a month depends on the month.
   
   No problem. Pop in the CD included ... copy ... paste into your VBA Module ...
   
   Locate your spreadsheet's cell ... type "=dhDaysInMonth(Month)" ... done.
   
   If you've written any macros at all or even recorded one ... you will appreciate the amount of work you're buying for a little over thirty bones.
   
   Highly recommended. As page 196 says, 'You'll get better performance (and fewer bugs) by taking advantage of the work that's already been done.'
   
   This book is a bargain.
   
   Mange Takk!

5 comments about Statistics: An Introduction using R.

1. The title of this book is a misnomer. It is not an introduction to statistics at all, although it does do a very clear review of courses in descriptive statistics, regression, ANOVA, ANCOVA and GLM. If you don't know statistics, and want to learn, this is not the book for you.
   
   This is, however, a truly excellent book that gets you up to speed very quickly on a wide variety of statistical applications using R as the tool for solution. If you have a reasonable background in statistics and want to use R as a substitute for SAS, SPSS, BMD or other package, this book will teach you how within a week. (Make sure you download the examples from the referenced website.



2. This book is the best I have found for an introduction to the R statistical programming environment. It is also a very good textbook for introductory statistics. The supplemental material at his web site is excellent as well.



3. This book purports to be an introduction to statistics using R. R has exploded in popularity and today is probably the most powerful system available for doing statistics, having surpassed the older Splus and SAS. Thus you do well to learn R early on as you begin statistics; it well suits the novice and the expert. To make things even better, R is both open source and free with an excellent, supportive online community of many people. The online mailing lists are a treasure trove of valuable resources. There are now several introductory books to R, including one by Verzani, one by Dalgaard, and one by Crawley.
   
   Crawley's book is a _very_ rapid tour through a lot of statistics. There is no real way that a beginner could properly digest the material. Moreover, he often assumes far too much and then assumes far too little. For example in one early chapter he covers the basics of General Linear Models (GLMs), an intermediate to advanced concept. At the beginning of the next chapter, he is explaining basics about the slope of a line! There are a lot of similar examples that left me scratching my head.
   
   There are good pearls in the book that are quite nice, however this book should really be for those with some exposure to statistics.
   
   A better introductory book is "Using R for Introductory Statistics" by John Verzani. That book was more clear and better organized.



4. This book does a good job of what its designed to do. I would have to agree with another reviewer that finds the topics covered in this book a little too much for a intro statistics book. My intro class certainly didn't cover variable transformation and other more complex topics. I would have to say that I don't feel 100% comfortable navigating through R now, but I have exponentially increased my understanding. I wasn't too impressed with the last few chapters. It seemed as if the coverage of material decreased as the complexity of the statistical tests became more complex. The secion on survival analysis, for example, spans only a few pages. That being said, you do get the R code right in front of you to expose you to how the code needs to be set up. This book also comes with matching chapter lessons that can be downloaded from the authors website. Unfortunately, many of the exercises are nothing more than repeats of the same material in the book. This hurts. I like learning through structured examples...And I prefer more rather than less. So if you are really motivated to learn R by working through some elementary inferential statistics (standard deviation, t-tests, and anovas) then this book can produce results. If your looking for more advanced content (information on examples installing and using packages affiliated with R) than this book doesn't won't meet all of your goals. I would recomend it to someone with little or no knowledge of R and the patience to work through the basics on your own.



5. If you have already had some experience with statistical methods and are looking for a refresher or a way to quickly pickup the basics of R, this is the place to go. It has a wonderfully conversational tone that is missing from far too many scientifically oriented books, and he brings quite a few insights into the practice of statistics that are more difficult to pickup from the heavily theoretical books.
   
   I would agree with a previous reviewer that there is a bit more space than necessary dedicated to relatively simple concepts, but such minor transgressions are easily overlooked given the overall effectiveness of the book.
   
   I would recommend this book as a refresher/introduction to R, or as a companion book to a college course on statistical methods. The author doesn't cover theory at all (on purpose), so keep in mind this is purely a practical book.
   
   I would have given the book 5 stars if it weren't for a few typos that might confuse beginners or people who have a tendency to read when you're a bit to tired to do so (for example, on the bottom of p59 he says lower bound when he meant upper, nothing you wouldn't catch with a careful re-reading).

3 comments about The Definitive Guide to iReport (Expert's Voice).

1. Very good book, it is very practical, concise and clear. Examples are very usefull and you can start with almost no knowledge about insides of jaspereport



2. This was a complete waste of $50. I am a Crystal Reports designer, and wanted a resource that would bring me up to speed with the expression language. This book is 300 pages of screen shots with no examples of input! I don't need to know how to navigate the UI (I learned that in much less time than reading the book would require.) Instead, the critical information - writing conditional expressions, building parameters, creating running total fields - was omitted.
   
   If you have any comfort level with report writing, save your money or buy a reference guide to Java or Groovy.



3. The book is great, helped me learn new techniques to use and to use new tools, such as graphics or subreports.
   I recommend to new and experienced users.

5 comments about Eclipse.

1. One of the problems with Open Source software is getting good books describing it. Sure it's possible to get documentation on-line, but sometimes there is no substitute in having all the information in one convenient book. Steve Holzner has done a good job in describing the various aspects of Eclipse. Coverage includes: the Eclipse Java Development Tools and Workbench, Ant, CVS, building Swing apps, SWT, JSP along with a host of other topics.



2. Online documentation has its place, but I like books better for learning. I found Eclipse's online doc especially lacking when it comes to *learning* about this complex product. Sure there's a ton of stuff, but most of it just seems to describe the ten's of thousands of options that the tool provides. (Personal Rant: Do we really need all of these options? Can't anyone see that just because you can do something doesn't mean you always should? Can't anyone see that a lot of these options just get in the way of using the product?)
   There, I feel better now. So when it came time to learn about Eclipse I reached for a book. I can recommend this book because it is good but I can't recommend it because it is getting dated. And that's just the nature of the beast when you write a book about a product as opposed to a technology. (The latter also gets out of date, but not as quickly. Maybe it's because there are less screen shots of actual components.)
   For the most part the screen shots of the dialogs and menus are still useful, i.e. even though the product's UI has changed you can still easily go from the book to the component you are looking at on the screen. But... well, here are the versions of various products covered in the book versus the versions of these products today:
   Eclipse 2.1.1 vs. 3.1
   Ant 1.5.3 vs. 1.6.5
   Tomcat 4.1.29 vs. 5.5
   Struts 1.1 vs. 1.2.7
   Another thing I did not like: they used "poor programming practices" in their chapters on JSPs and servlets. For example, in JSPs they used scriptlets and in servlets they output a bunch of HTML. I don't like it when a book does stuff "we're not supposed to do anymore."



3. This book a a very good start for Eclipse new users in the way that it presents all basic features of Eclipse 3.0. I recommend it to any one.



4. I bought this book and have been making my way through it to teach myself about Eclipse. I did fine for the first five chapters, but after that the trail grows cold because the book is based on Eclipse prior to the 3.0 and later releases. I began having lots of problems because the instructions and screen shots no longer came close to matching what is actually in Eclipse 3.0. So I gave up after chapter five.



5. Time has started to diminish the value of this book. Chapters 6, 7, and 8 deal with building GUIs using the V4ALL Eclipse plugin, which is now classified as Obsolete. Also with Eclipse 3.3 now available (the book focuses on Eclipse 3.0), a new edition of the book is definitely needed.

5 comments about An Embedded Software Primer.

1. I am in embedded world for 8 good years and brought this book to know something which I dont know. This book is purely for fresh graduates out college.(that too only when they havnt worked hard in their courses) also if you have been in industry but didnt get chance to work on actual system then this can be of little help for you.
   
   Dont buy it if you have already spent a couple of years on actual systems. You wont benefit much.



2. I've done quite some application software design. But I'm totally new to embedded software design. I found this book is very useful for me. The whole book is very clear and illustrative. It provides many useful points in designing embedded software that my be overlooked by application software engineer like me.



3. I think microC/OS is a good example of small operating systems such as TOPPERS/ssp(smallest set profile). This book describe Hardware fundamentals for the software engineer (chapter 1) for examples VCC(Voltage Connected to Collector), And gates and Or gates and D Flip Flops.
   Advanced Hardware Fundamentals(chapter 2) describe Busses, DMA(Direct Memory Access), and Interrupts(also in chapter 4).
   Survey of software architecutres(chapter 5) is important articles.
   Introduction to real-time operating systems(chapter 6) include semaphores that is traditional technology.
   All of the contents are good for primer. In the CD-ROM there are answer of the problems(exercise or practice) and additional programs.
   ps.
   microC/OS is made by Jean J. Labrosse.
   He make a new book, microC/OS-II.



4. This book hits most of the major points in embedded software programming, clearly and concisely. It it almost 10 years old, though, and some of the discussion shows it (especially hardware). It would be great if they would do a second edition, as the book is a great read otherwise.



5. Many people would argue that the material in this text is far too basic. I think this is precisely the strength of this book. I enjoyed reading this book despite being an experienced embedded developer.
   
   There is no one-stop-shop in embedded software development. If you adopt it as a career, there are many things you will need to learn over time: architectures of multiple processors, a variety development tools, RTOSes and a lot more. For the most part the book stays clear of the specifics of all of these. However, it does teach you the fundamentals of all of them. The information about hardware interfacing, processors, interrupts, shared data problems, RTOS based design, and common mistakes is sufficient to get a new-comer started quickly. In my early days, I spent hours, sometimes days, chasing bugs similar to those this book teaches you to avoid.
   
   In short, the book is just what says it is: "What you need to know to get started with embedded systems development". I would highly recommend it to any newcomer to this field.

5 comments about Mastering Microsoft SQL Server 2005 Express Edition (Mastering).

1. I give this book five stars not because the entire book is great, but because chances are there will be a few parts that 'serve' you well - which is most likely why you buy this book. One or two of these gems (such as adding Encryption to a connection string to automatically encrypt all data moving from sql server onto the network) will be worth the price of the book many times.
   
   The intro on things like normalizing is weak and chances are you will not learn anything here (if you do not know the basics about normalizing a database schema, then chances are some tutorials on the internet will help you better).
   
   Sections on backups, locks, internal workings of sql server, smo objects for custom management apps, logs, etc are all well written and helpful.
   
   A few performance metrics for various typical approaches would have been appreciated, the type of things you have to dig through white papers for.



2. I have bought this book for my teaching purposes targeting a "new starter" group. Introductory chapters are good. It has abundant representative pictures. But as the topics progres the book becomes having a little problematic. If you think to buy this book as a self study guide, it is maybe better to look for another one.
   On the other hand, SQL Server Express Edition does not have so much book-style resources. This may force the reader to buy this book (as in my case!)
   But as a last opinion, this book is not a "must have book"



3. .
   
   Microsoft has developed a FREE, yes that is FREE, SQL application that is actually rather good.
   
   This book will get you up and running on SQL; database concepts and design; trouble shooting your databases as well as introducing you to Visual Basic Express...another FREE app from Microsoft
   
   It isn't as robust as SQL Server, but is far better than Access.



4. Microsoft realeased a free version of SQL Server to compete with mySQL and it's actually quite excellent, especially given its price tag. This book makes the book claim to have you 'mastering' SQL Server, but of course no single book could do that. Instead, it provides a very comprehensive tour-de-force of all the features, bells and whistles, and relies on you - dear, Internet-connected reader - to research areas of particular interest to you.
   
   The biggest flaw is that there's not enough information to get you up and running in the first place. Literally, the installation instructions for SQL Server Express are esoteric, and there's a couple of missing pieces of information, without which you're going nowhere. But a little digging around on the Net will have you running fairly quickly.
   
   Overall, a great little book for the price.



5. I have been creating applications that use Access for the last few years, so it has been awhile since I used SQL Server.
   
   With this book I got up to speed on client/server databases, permissions, stored procedures, triggers, T-SQL. It should be the start for anyone who is interested in this "free!" new SQL Server.
   
   I found it very helpful, well written, succinct.

5 comments about Access 2003 Programming by Example with VBA, XML, and ASP.

1. As programming books this one did actually have something I could use and gave an example of how to use it. It even gave the code.......what a thought. Most programming books offer little more than lots of pages of "stuff" you cannot use. The book took you through the process of how to code a "Message" box. This one actually did have a few things one could use. Not a good beginner book, intermediate to advanced. This book coded you through modules.....good idea. The one thing I didn't like about the book was it did not go deep enough into data base design or normalization.



2. All you can learn to a program MsAccess, as a reference book.



3. This is not the book for beginners. But this is the book for users who have a good foundation with the basics of Access- forms, reports, and queries- and want to learn how to use VBA to improve their database. I'm working on a project where I need to reprogram many aspects of the database, and this book has been invaluable. I have plenty of Access books for reference, but this book is the secret weapon for Access programmers.



4. A book about Access that tells about the different aspects of the software as this book does is worth having on the book shelve. I recommend this book to anyone who needs as I do to have an available book to give examples as well as explain the details and tell about each area of Access databases. It's not a exhaustic concordance of Access but it has enough info to allow one to build some sophisticated databases. Not exactly for the beginning Access programmer but for the intermediate and advance programmer it would be an asset. I want go into detail but you need to read through the pages to understand the valuable resource it is. If you need reference material this book is for you.



5. I really like this book. We still use Access 2003 at work, so I wanted a book specifically for that version and specifically for VBA. I am already a fairly experienced Access user, but was not as experienced in VBA. As anyone who's used Access knows, you need VBA to make just about anything work. I'm very pleased and have gained a great deal of experience from this book. Very good examples and written well. I'm very happy and use it nearly every day.

5 comments about HTML: A Beginner's Guide, Third Edition.

1. I purchased this book for an Introduction to Web course and found it to be an excellent resource. Some chapters are more detailed than others but overall, it was extremely helpful. There are lots of examples throughout the book as well as excellent chapter reviews. I would highly recommend this book to anyone just starting out learning HTML.



2. Having no knowledge of code, this book was great. I created my whole site with code...rather than having dreamweaver create it for me! I would recommend it to anyone just learning about website creation.



3. this book was a good beginner's html book. if you're coming from a programming background though, you'll be able to tell that it was not written by a programmer (which she herself admits to). but that's okay, since you end up learning the subject material anyway.
   
   i had to subtract a star because there were some misstatements (e.g. writing 'attribute' instead of 'property') and quite a few code mistakes, as another reviewer pointed out.
   
   i don't agree with the 2 star reviews. this book is a lot better than that.



4. I was facing HTML issues like making banners, adding code to pages made on templates and embedding video files in my blog, so I bought this book.
   
   You'd think all those things would be in it, but only the third is. The word "banners" isn't even in the index. Neither is "templates."
   
   These are very "now" issues for people like me. I strongly recommend the next edition be more thorough.
   
   CSS is also invoked more frequently than it is explained. This needs work.
   
   I do not wish to discourage the author. I just think the next volume could improve over this one in key ways.
   
   I also do not care for the use of the author's favorite camp and school for all the examples. I admire her enthusiasm but found it tedious. I suspect most people would not be bothered, however.
   
   Issues pertaining to blogs could be expanded.
   
   For me, a three star book. Useful, but I'll have to buy supplements.



5. it's a very helpful book especially for begginers like me.. it helped me alot excell in what im learning in school.

5 comments about Agile Java(TM): Crafting Code with Test-Driven Development (Robert C. Martin Series).

1. I'm not a beginning programmer, or even an absolute Java novice, so maybe this book isn't really aimed at me. My biggest gripe is that the code snippets continue on and on making the book very poor for anything other than cover-to-cover reading.



2. I've gotten about 6 chapters into this book and I love it. I've been developing Java for almost 7 years and am currently teaching myself Agile principles and this book comes as a great help.



3. This book is primarily for new programmers who want to learn Java as their first programming language. The book can also be helpful for programmers familiar with test driven development (TDD) but new to Java, or vice versa. I am an experienced Java developer, and I found that going through Agile Java presented me with a new and better way of approaching Java code development. This book covers Java 2 Standard Edition (J2SE) version 5.0, but covers only a few of the additional APIs at an introductory level. Technologies that are used pervasively in the majority of enterprise applications, such as logging, JDBC, and Swing, are presented in Agile Java. Some of the information, such as that on logging, will teach you all you need to know for most purposes. Other lessons, such as those on Swing and JDBC, will give you a basic understanding of the technology and will tell you where to go when seeking further information.
   
   The core of Agile Java is fifteen lessons of about 30 pages each. It starts with baby steps in Java, TDD, and OO. The book finishes with a strong foundation for professional Java development. The core lessons should be read sequentially since each lesson builds upon the previous ones. Once you have completed the core lessons, you should have a solid understanding of how to build robust Java code. If you haven't completed the fifteen core lessons, you should not assume you know how to write good Java code. Each of the fifteen core lessons in Agile Java has you build bits and pieces of a student information system for a university. This single common theme helps demonstrate how you can incrementally build upon and extend existing code. Each lesson also finishes with a series of exercises. Instead of the student information system, the bulk of the exercises have you build bits and pieces of a chess application. Some of the exercises are involved and quite challenging, but they are where learning the methodology really begins.
   
   There are three additional lessons to cover a few more Java topics. Two of the lessons present an introduction to Swing. These two lessons will provide you with enough information to begin building robust user interface applications in Java. But the bigger intent is to give you some ideas for how to build them using TDD. The third additional lesson presents an overview for a number of Java topics that most Java developers will want to know such as JARs, regular expressions, cloning, JDBC, and internationalization.
   
   I really liked how the author integrated the three concepts of Java programming, TDD, and object-oriented design without confusing matters. The book is very clear with good illustrations. I highly recommend it. The following is the table of contents:
   
   Lesson 1. Getting Started
   Lesson 2. Java Basics
   Lesson 3. Strings and Packages
   Lesson 4. Class Methods and Fields
   Lesson 5. Interfaces and Polymorphism
   Lesson 6. Inheritance
   Lesson 7. Legacy Elements
   Lesson 8. Exceptions and Logging
   Lesson 9. Maps and Equality
   Lesson 10. Mathematics
   Lesson 11. IO
   Lesson 12. Reflection and Other Advanced Topics
   Lesson 13. Multithreading
   Lesson 14. Generics
   Lesson 15. Assertions and Annotations
   Additional Lesson - Swing, Part 1
   Additional Lesson II. Swing, Part 2
   Additional Lesson III. Java Miscellany
   Appendix A: An Agile Java Glossary
   Appendix B: Java Operator Precedence Rules
   Appendix C: Getting Started with IDEA
   Agile Java References



4. This is my new favorite-book-to-give-to-anyone-who-is-learning-or-using-Java.
   
   The title is misleading in that this book is about much more than just the Agile Programming stuff. While it does a great job talking about Agile techniques and always starts by creating a unit test, the book really is about all aspects of Java (specifically Java 5) programming. Anyone who takes the time to work through the examples will become a much better Java programmer.
   
   OO patterns, collections, type safety and more are covered and explained in the context of a rich, in-depth example. And because the author has you construct a high-quality test suite around the example, you are free to experiment with different ways to implement each new feature - thus proving to yourself the benefits of Agile design.
   
   Just like it says in one of the quotes on the cover, this book is now required reading for the Java programmers at our company.



5. I had originally bought this book for son who was going to spend the summer working for my development team writing unit test for our database POJOs. I was so impressed way in which concepts were incrementally introduced I read the book cover to cover. It is now the only book I recommend to beginners and I introduce it as a 'must' read for all my new hires.

5 comments about Java EE 5 Development using GlassFish Application Server.

1. Full Disclosure: PACKT Publishing provided me a free copy of the book to review.
   
   Overall Reviewer Rating: B+
   
   From the back cover:
   
   "Who this book is written for
   This book is aimed at Java developers wishing to become proficient with Java EE 5, who are expected to have some experience with Java and to have developed and deployed applications in the past, but need no previous knowledge of Java EE or J2EE. It teaches the reader how to use Glassfish to develop and deploy applications."
   Given that description of the book's goal and scope, I would say that it is a "mission accomplished".
   
   I came across Glassfish V2 this year while doing research for a client SOA project. After downloading it ([...]) and spending a few days exploring its robust features, I decided to continue evaluating it for selection as a possible core component for the team's ESB and SOA efforts. While juggling a number of other priorities, I contacted the publisher and offered to review their book.
   
   Chapter Outline
   
   1: Getting Started with Glassfish
   
   Reviewer Comments: Clear and concise. What I would add in the next edition: Coverage of more in-depth discussion of configuration parameters - and performance / tuning parameters.
   
   2: Servlet Development and Deployment
   
   Reviewer Comments: Good basic introduction to the topic of Servlet Development - without burdening the reader with the additional complexity of learning application frameworks.
   
   3: JavaServer Pages
   
   Reviewer Comments: Good basic coverage of JSP topics.
   
   4: Database Connectivity
   
   Reviewer Comments: Covers JDBC and JPA. A decent survey of Entity Relationships (One-to-One, One-To-Many, and Many-to-Many). Covers Composite Primary Keys. The author, to his credit, notes that Database access code should be encapsulated in Data Access Objects (DAOs) - and provides suggested links for further reading.
   
   5: JSP Standard Tag Library
   
   Reviewer Comments: Discusses the Core JSTL tag library as well as Formatting JSTL, SQL JSTL, XML JSTL, and JSTL functions.
   
   6: JavaServer Faces
   
   Reviewer Comments: Basic coverage of JSF and JPA.
   
   7: Java Messaging Service
   
   Reviewer Comments: covers setting up Glassfish for JSM, working with message queues and topics.
   
   8: Security
   
   Reviewer Comments: Discusses various types of realms (Admin, File, Certificate, JDBC, Custom) - and how to utilize Glassfish's built-in security features.
   
   9: Enterprise JavaBeans
   
   Reviewer Comments: Sub-topics covered include Session Beans, Message-driven beans, Transactions in Enterprise Java Beans, Enterprise JavaBean Life Cycles, EJB timer service, and EJB security.
   
   10: Web Services
   
   Reviewer Comments: Sub-topics covered include developing web services with JAX-WS API, Developing web service clients with JAX-WS, adding attachments to web service calls, exposing EJBs as web services, and securing web services.
   
   11: Beyond Java EE
   
   Reviewer Comments: Sub-topics covered include Facelets, Ajax4jsf, Seam.
   
   Appendix A: Sending Email from Java EE Applications
   Appendix B: IDE Integration
   
   As a bibliophile, I have a few pedestrian observations of the mechanics of the book's production:
   
   1) The book appears to use a bit larger font than I usually see in technical books by other publishers - a positive - as I don't have to squint to read the text. The quality of the paper appears to be good. The binding appears to be fair-to-good.
   
   2) The book makes extensive use of ample screen shots to capture the specifics of step-by-step instructions when covering the installation and configuration topics in chapter-1. Screen shots of the Glassfish administration screens are also provided in latter parts of the books where appropriate.
   
   3) Coding examples are also liberally provided throughout the chapters (Example Code for the book is available at http://www.packtpub.com/support).
   
   4) "Notes" and "Tips and Tricks" are appropriately identified throughout the book using two icon designations.
   
   Some things that would have made this a better book:
   - Some commentary from the author on how Glassfish does some things better/worse than other application servers.
   - A "Further Reading" section at the end of each chapter with recommended books or web links
   - A Chapter on Debugging Applications within Glassfish
   - A Chapter on Tuning Glassfish
   
   If you are looking for an introductory survey of Java EE development topics, then this book is a good choice. It is not intended as a definitive reference for Java EE - so don't judge it against that kind of yardstick. The author does not assume that the reader is an advanced Java developer - but does expect that you have some familiarity with the language.



2. My overall opinion of the book is good. The book is very well written, and the code examples in the book work. Working code examples are the number one criteria for me. The code examples start with some examples in Chapter 2 that are used throughout the remainder of the book. This provides a coherent flow through the book. You may also download the code examples from the Packt Publishing support site.
   
   I would recommend it as a book to have on your development bookshelf.
   
   The book claims to be the complete guide to installing and configuring GlassFish. I would not give it that much credit. There is room for more extensive books on GlassFish. There are a number of topics that are very general and have nothing to do with the actual configuration of the server. A better book summary would be a guide to installing, configuring, and developing applications for the Glassfish server. It is really a Java EE 5 tutorial which features Glassfish.
   
   As a book on GlassFish, it is very light in its coverage. As a tutorial for developers acquainting themselves with Java EE 5 and deployment on Glassfish it is very good. In my opinion it is targeted at developers familiar with J2EE who want to switch to JEE5, or junior developers trying to get a better comprehension of the EE environment. It is not for novice programmers.
   
   Chapter 1
   
   Getting Started with GlassFish
   
   This chapter covers getting and installing GlassFish. It is very basic, but will get you up and running. It also includes how to set up your JNDI database connections. The majority of this information can be readily found on the GlassFish site on Java.net. There is a good example of how to set up multiple domains on GlassFish which is not easily gleaned from the site. There is a chart which shows how the --portbase command line option is used to set the ports on which GlassFish services connections. This provides the best explanation for this command line option and graphically depicts what the results are.
   
   Chapter 2
   
   Servlet Development and Deployment
   
   This chapter is a very basic tutorial on servlet technology. It includes writing a simple servlets, web.xml files, and deployment file layout (war files). It includes some examples on html forms, request forwarding and response re-direction. There is nothing GlassFish specific and the files will just as easily deploy on Apache Tomcat unaltered. There is one item of note which is sun-web.xml related which has to do with how to change the context root. This is used if you do not want the default deployment context to match the name of the war file.
   
   Chapter 3
   
   JavaServer Pages
   
   This chapter again has a basic tutorial on JSP technologies. There is a really good example of creating custom JSP tags and how to use them. Again, there is nothing that would prevent the war files from being deployed on Apache Tomcat. I wish that the author would have covered Unified Expression Language (EL) in more detail. It is more central to this technology on JEE5 platforms.
   
   Chapter 4
   
   Database Connectivity
   
   This is the first chapter which covers a really important topic in the enhanced JEE5 database access functionality, new Java Persistence API (JPA), and its reference application server (GlassFish). The first example shows a servlet and how to connect to a database using the old form of JNDI lookup without resource injection. The next example shows the simplified version using resource injection of the DataSource. This removes all the plumbing of fetching our data source.
   
   The next section covers Java Persistence API (JPA) and provides an in-depth tutorial. This is a key concept in JEE5. It introduces the Entity annotation on a POJO to convert it to a persistable object. The simple example that follows it demonstrates correctly how to to use JPA in a non-thread safe environment of a servlet using a UserTransaction. It also covers the persistence.xml file.
   
   This chapter is a must for anyone who wants to learn JPA. The sections on entity relationships, and composite primary keys are done extremely well.
   
   This chapter concludes on Java Persistence Query Language (JPQL) which is the follow-on from EJB QL.It is very light. I wish the author would have covered this very important topic in more detail. That being stated, the code sample is a perfect example.
   
   The book is worth purchasing for this chapter alone.
   
   Chapter 5
   
   JSP Standard Tag Library
   
   This chapter is a basic tutorial on the JSTL. I found a number of syntax mistakes, which were submitted back to Packt. The SQL JST Tag Library is covered. It was very simple. There is one note on No Suitable Driver SQL Exception which is often a hard thing to track down.There is nothing substantive about this chapter.
   
   Chapter 6
   
   JavaServer Faces
   
   This is another JEE5 technology that needs more coverage in general. This chapter provides a good foundation on the reference JSF implementation. It is very well written. I am a big advocate of JSF and thoroughly examined this chapter.
   
   The introductory examples are well done and give a good overview of the technology. The example Customer bean is the same bean that is used in JPA in chapter 4. This shows the consistency and flow between chapters. In this case we use the bean as a managed bean in the JSF context.
   
   The chapter also explains the changes needed in the web.xml file for JSF.
   
   The section on validators is very well done. It includes an example using the Apache Commons Validator framework. The point is to show that you should look for good validators rather than creating your own. Roll your own for domain specific requirements. It also covers validator methods in some detail. It also covers another useful utility from the Apache Commons Language Library.
   
   There is a section on customizing messages that provide feedback to the user on various validation errors. It contains a section on how to modify the default messages on GlassFish. It is nice to know how to do this, but I would encourage users NOT to do it. You can Google for the default messages to see what they mean. If you change them, that option no longer exists. Also it is not intuitively obvious where the message is coming from. There is another example using a message bundle for your customized messages. I would HIGHLY recommend using this method.
   
   There is a wonderful section on integrating JPA and JSF. This is a must read, and covers the practical side of JSF and JPA. It uses a model-view-controller paradigm. It shows how to use the JPA as a managed bean that gets set from the JSF page and saved/modified from the controller servlet. This is an excellent example of how to do it.
   
   Finally, the chapter closes with a reference to the JSF Core components. I personally believe that this should have been an appendix. It really does not contribute to the flow of the book, or chapter. I went through the reference with a fine-toothed comb. The examples are really clean. I submitted some errata for the section, but it was done very well.
   
   This is another chapter that makes the book worth purchasing.
   
   Chapter 7
   
   Java Messaging Service
   
   This is a chapter that has a very specific setup for GlassFish. Most of the previous chapters were general enough on the specific technologies that they could be used on Apache Tomcat. The JMS server setup which is covered for GlassFish is very specific to the server.
   
   The first part of the chapter covers how to set up the JMS connection factory, and JMS destination resources (Queue and Topic).
   
   The examples that follow are very well done on how to use the various topics and queues.
   
   I was really impressed with the authors examples. They were clean. I questioned one of the examples on durable topics, only to discover that the author was correct.
   
   Chapter 8
   
   Security
   
   This chapter seems out of sequence. The Enterprise Java Beans (EJB) and Web Services chapters follow it. I would have recommended it to follow those two chapters. The author does cover securing EJBs and web services which require a security pre-cursor, but it seems to disrupt the flow of the book.
   
   This chapter was a big disappointment. The topic is covered in minimal detail. This chapter is so important that it needs more coverage.
   
   Here are some of the major omissions:
   
   * Setting up a SSL/TLS connection using a self-signed certificate, or CA certificate
   * Setting up an LDAP realm
   * Optional attributes for the various realms
   
   There is coverage of the various realms with a focus on file and JDBC.
   
   The JDBC realm is complex. I understand that setting up a JDBC realm requires more work, but I am not sure how many people would use this type of realm.
   
   The file realm coverage is detailed, but I am not sure that any enterprise would use this arrangement. It is not scalable.
   
   The example login form using j_security_check is very useful, as well as, the example LogoutServlet.
   
   The certificate realm is covered in fine detail. It is one of the best examples of how to configure this setup.
   
   The LDAP and Solaris realms are weak. There is nothing here but a placeholder explanation. I can imagine that most enterprise users will have an LDAP domain that they will connect to. This topic could have included an example using OpenLDAP with its configuration in an appendix, or using openDS (http://opends.dev.java.net).
   
   The JDBC realm setup has a number of serious errors which were reported as errata.
   
   The section on defining custom realms is ok. It glosses a topic which requires more detail. I would HIGHLY recommend using a pre-defined realm instead of defining your own.
   
   Chapter 9
   
   Enterprise JavaBeans
   
   This chapter provides a good tutorial on the JEE5 EJB 3.0 technologies. It covers the use of the new @Stateless, @Stateful, and @MessageDriven bean annotations.
   
   There is an excellent example of using a stateless session bean as the DAO controller for JPA. It is well done. This is followed by another excellent example of how to use DAO EJB in a web application using resource injection.
   
   Transactions are covered in very good detail. There is an excellent table which explains the various types of container managed transactions, and the @TransactionAttribute annotation.
   
   The real jewel of this chapter, in my opinion, is the section on Bean-Managed Transactions which includes an excellent example with all of the correct annotations.
   
   There is a section on the new EJB Timer service. I wish they would have included a practical example, but the included example gives you a feel on how it works.
   
   EJB Security is covered lightly. There is a great note about automatically matching Roles to Security Groups on GlassFish. It is a very well hidden feature, and one which I was not aware of. This simplifies some of the security mapping and is a great time saver.
   
   This is another good chapter.
   
   Chapter 10
   
   Web Services
   
   This chapter provides a good tutorial on Java API for XML for Web Services (JAX-WS). It has some simple examples, and demonstrates the great GlassFish web service testing facility built into the platform. The tester is a web based page which allows you to enter values and see the results, as well as, the SOAP messages (Request and Response). This is a real time saver and can help a developer check the expected messages quickly.
   
   The chapter includes a section on how to include attachments and expose EJBs as web services.
   
   The chapter concludes on a light coverage of web service security.
   
   Chapter 11
   
   Beyond Java EE
   
   This chapter covers some alternative and complementary technologies for JSF like Facelets, Facelets Templating, Ajax4jsf (providing AJAX functionality to JSF applications), and Seam. The chapter includes some sample applications and how to install and set up these technologies.
   
   Appendices
   
   The appendices include coverage of using JavaMail and integrating GlassFish into various IDEs.
   
   Again, I would recommend this book for anyone who wants to learn the basics of JEE5 programming with GlassFish.



3. I do have to agree with others who remarked that the book is not a comprehensive discussion of GlassFish. In this respect, it is somewhat of a downer. But, perhaps albeit inadvertantly, its best merit is elsewhere.
   
   Over the years, the Java world has grown hugely from just the Java language. Roughly, the latter is more or less J2SE. But in the J2EE field, or what Sun seems to just be calling EE, many extra layers of code and packages have been added. Entire books have been written on each of the topics of servlets, Java Server Pages, Enterprise Java Beans, Java Server Faces, Java Messaging Service, JDBC, Web Services and Ajax. Where do you start, if you don't know any of these? One answer is right here. This book. Heffelfinger gives a concise overview of each topic. Enough technical details that a programmer can understand and appreciate. More to the point, you can see how these tie into each other.
   
   Frankly, you'll still need those other books, to do serious coding in a given topic, or between topics. But the understanding and top level view here is valuable.



4. I had pretty high hopes for this book but I'm pretty bummed out. It seems well written and I'm sure it is good for some people but just about everything in this book is available for free elsewhere. I wanted a book about GlassFish and really specific stuff like configuring a domain *in detail* and not a recap on how to run the basic commands. JNDI in GlassFish - I don't think it's covered. Writing applications with the Java Web Start and the nice appclient utility - not covered. Sure, most of that is mentioned (as in...the words are used) but basically this book is for people who want to learn how to write the simplest servlet, ejb, and web service and with the exception of the security chapter, pretty much none of it is really specific to glassfish. Oh well. I'll probably refer to this book on occasion when something isn't working and I want to check my sanity but for the most part this will sit under my much better books on EJB and JEE in general.



5. I concur with the readers who say this book isn't just an "intro to Glassfish", that it's more of a "summary of the components of the Java EE 5 specification with emphasis on how to configure and use those components specifically with Glassfish". And that was just fine with me, because I was kind of looking for both, and in this book I got both.
   
   We considered Glassfish as a platform of choice for deployment of a revised/updated version of a sample application (for a new edition of a book). We wound up backing off from using Java EE 5 and stuck with J2EE 1.4, for a variety of reasons. In going through this book, though, I discovered it summarizes numerous aspects of Java EE 5 in brief, readable, understandable form. The chapters on JDBC, JSTL, JSF, JMS, and EJB3 were concise summaries that covered the material well and offered solid examples. Each of these topics has had whole books dedicated to them, so it's nice to see a book that wraps itself around these individual topics and conveys the essence of what they're about succinctly.
   
   Usually the books that attempt to cover EVERYTHING in something as broad as a J2EE/Java EE spec call themselves "bibles", and indeed that's a good name for them as they attempt to be the canonical be-all and end-all on the subject with enough laborious text and sideline commentary to be considered "biblical". While none of the chapters here is a deep thorough tutorial, each one provides enough information for you to get your head around the topic at hand, leaving with enough understanding to seek out deeper information elsewhere. That's an important thing for a book like this to do, and it's not something to be scoffed at or dismissed. In my day job I'm working with JBoss 4.2 using Java EE 5 features like EJB3 and JMS, and this book provided useful information on those subjects clearly and concisely, and explained more than a few things to me that I hadn't gotten before. The chapter at the end on Facelets, Ajax4Jsf, and Seam provided very brief overviews of those approaches/packages, again just enough to explain aspects I hadn't understood.
   
   I may use Glassfish in the future for personal projects, as it looks like it is a robust implementation of the Java EE 5 spec, and this book will definitely be a good guide to development and deployment of Java EE 5 apps for that environment.