5 comments about Agile Java Development with Spring, Hibernate and Eclipse (Developer's Library).

1. This book tries to combine so many things in to one. Thus it looses the detail any technical person would like to see. It skims over Extreme Programming, RUP without saying much about it - it is understood as it is not the focus of the book.
   
   The architecture it discusses is just a three layer one, which I believe any programmer would know before hand. This talks about lot of freewares and then it goes through Hibernate and Spring, which I believe is not enough for a technical person. The books can be used for overall idea for a manager or a programmer who is totally new to the concepts.



2. I like the concept of this book. Combining a whole bunch of ideas that these days are well proven and likely to result in well written software and productivity gains.
   
   Agile, Java, Eclipse, Hibernate, Spring. All stuff that I am working with right now. Seems the perfect book to fill in the gaps in my current knowledge.
   
   Unfortunately, though the author may be a fine developer, he is not a great writer. This book to me had serious flaws, and unfortunately, I learnt oh so little.
   
   The book barely scratches the surface, glossing over any real detail and bringing not much more than what you'd get reading the home page of the respective products.
   
   Some may like the ultra-casual writing style, but I found all his diversions and personal asides distracting. Granted, it's easy to read when the writing resembles that of a spoken conversation. But I found the book to be disorganised, fragmented, and having a rushed quality to it. And just too lacking in depth.
   
   I realise that the author was attempting to cover a lot of ground (as he points out more than once) but this book could have been so much more concise. For example, he wastes his (and my) time reviewing alternative IDEs when already admitting he is totally smitten with Eclipse. If the author just hadn't been so keen on personal asides and spent a bit more time getting the structure of the book right, he could have covered the subject matter in much more detail.
   
   OK, so this book might be good if you want a crash-course in all those fantastic open source products. It might save you some time in getting your basic application up and running, if you've never used any of these products before. But if you're already familiar with them, or don't mind reading some online documentation, or don't mind having a quick play yourself, then your hard earned cash may be more wisely spent elsewhere.



3. Somewhere in the initial few pages, the author give his readers a few options before reading (or buying for that matter) this book. One of them was to trust his advice, agree that Spring+Hibernate+Eclipse are cool technologies and scrap the idea of this book.
   
   I continued reading but now I recommend accepting his idea and save some bucks or buy something more useful, maybe separate books on Spring and Hibernate (btw, Spring in Action 2nd Edition is now available). All of these are surely good technologies but the book never goes into detail of any one of them (and it was not supposed to) and for installation/setup refers you to "latest installation instructions".
   
   Without the depth of details on any particular technology, and lack of instructions on making you up and running makes this book feasible only for a small window of people who want to try out and be "convinced" themselves personally before eventually buying separate books on each technology.
   
   I did not comment on the content because content comes after the 'purpose' of the book. For me its a two-star book and does not even require a content review (read other reviews for content if you really want to buy this).



4. I can not believe how anybody who has read this book would honestly give it a 5 star. I read the whole book, waiting for that moment that I could say: Oh, that's what the author meant by repeatedly saying: "more to come later" or "we'll see this in later chapter" etc. That moment never arrived. This book looks like a hurried and lousy compilation of 5 day presentations on each subject that this books claims to cover, without proper editing and attention to detail.
   I read the book riding the metro in Washington DC and I can honestly say that I would rather see DC tourists block the left side of the escalators in the metro stations on a busy rush hour day than read or refer to this book again



5. This book tries to cover too many things. The book is more a Manifesto for Agile Development from an experienced programmer than a technical book.
   
   Thus this small book misses all the details any technical person would like to see. The book is definitely not a comprehensive API guide to Spring or Hibernate, nor does it intend to be. The author repeatedly said : "more to come later" or "we'll see this in later chapter" etc. But that moment never arrived...
   
   The books can be used to get an overall idea for a manager or a programmer who is totally a newbie to the concepts.
   
   The more interesting part is on Agile Development where it seems to be a Manifesto but definitely not a tutorial.

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.

1 comments about Practical JBoss® Seam Projects (Practical).

1. I purchased this book after previewing several other books and online resources in order to get up to speed on both the overall architecture of Seam and get a good concrete hands-on ramp up of the technology for a development project I'm currently working on to transition from a proprietary J2EE MVC application to a Seam-based system.
   
   Farley's approach to establishing a base application using standard JavaEE technologies and API's (JSF, EJB3, POJO gluecode/configs) and then walking the reader through the migration and enhancement of said application with Seam is very well delivered and serves to illustrate both the benefits of Seam as well as provide an understanding of why various aspects of Seam exist (e.g. annotation-and/or-configuration for component binding, enhancement to the JSF response lifecycle, the conversation context and application flow/BPM, etc.). By taking this "Practical" approach, I was able to rapidly get up to speed on the core principles of Seam and move past the usual configuration/familiarization thrash that one encounters when learning a new framework.
   
   The book's presentation is a comfortable conversational style but still well structured and the author takes the time to review and reference core concepts without the burden of diving too deep into the foundational technologies (which can be better researched in their own volumes/sites/forums).
   
   The only criticism I have is lightness on describing how to implement Facelets in Seam, but given that the JSF foundation is largely identical to a stock JSF implementation, it's a smooth configuration tweak to start using said technology with Seam (read: Google it).
   
   Highly recommended to anyone who already has a working knowledge of JEE5 and the core technologies as well as a great primer for what will be baked into JEE6 in the near future.

No comments about Simple Program Design, A Step-by-Step Approach, Fifth Edition.

No comments about Programming Flex 3: The comprehensive guide to creating rich media applications with Adobe Flex (Programming).

5 comments about Data Structures and Algorithm Analysis in Java (2nd Edition).

1. Well, I have to admit I did not expect much from this book. But to my overly pleasant surprise, I found this volume quite useful both as a resource for algorhythms and data processing...Forget the Bible, this is the only book one truly needs. And it's fun to say "Java." Amen.



2. All of the practical algorithms are left as un-answered exercises! Great in depth discussion of introductory algorithms, but very few examples, mostly pseudo-code.

   INFURIATING FOR INDEPENDENT STUDY, but good if you have a professor to explain everything as you go.




3. If you don't know Java, don't expect to be able to learn the things you need to for a class. If you learned how to do alorgithms in mathematics, it may not be enough for computer science. You probably want to get a supplemental or two if you have to get this book for class. It is quite advanced and a hard read.



4. It is a nice book but i expected something better. I don't know what it is but something is missing here. I like the C/C++ version of this book better for some serious learning. On the other hand this is a good opportunity to learn java programming at the same time if you haven't mastered it yet.



5. I felt the author has a firm understanding of the concepts and truly what he wanted to convey, but this book lacked a great deal for beginners or newcomers to Java. Far too many of the examples were tough to understand and in many cases simply un-answered. This is not a book for beginners.

5 comments about David Buschs Digital Infrared Pro Secrets.

1. Infrared light is close in the spectrum to heat. As a result, cold things like trees and water dramatically change their appearance. And the warm skin of people put out a more intense image. Again because of the heat effect, skin blemishes such as acne tend to disappear. This may offer some distinct advantages in photographing young people. Likewise the somewhat strange effect produced by infrared photography may have effects that appeal in industrial or commercial shoots.
   
   While there are a lot of books on taking, using, processing infrared pictures, in this book that only takes up about half the content of the book. The most interesting half is on getting yourself an infrared camera. At the minimal end of the game there's building yourself a filter that can be put on the front of a camera. Or, you might consider that some cameras are easy to convert to infrared photography only. He gives a list (many of these are under $100 on eBay that can be professionally or perhaps even converted by you.



2. Actually, as the author points out in several places in this book, digital infrared photography is exclusively near infrared (NIR)photography, and should not be confused with heat/thermal photography, which, as Busch says, is something else entirely.
   
   Indeed, the technical accuracy and depth of coverage are one of the strengths of this book. It explains the process of IR photography in enough detail that even those new to this type of shooting will be comfortable with the technical demands, which, after you've read the book, aren't that complicated at all.
   
   There are two other aspects that I particularly enjoyed. First, unlike most other books in IR photography, this one doesn't deal exclusively with landscape photography. Instead, the author invites you to explore architectural photography, close-ups, even sports (!) and other varied subject matter. If you thought of IR photography as a quirky special effect, you'll discover that it's a genre of its own.
   
   Second, the do-it-yourself parts of this book are commendable. The author shows you how to build an auxiliary viewfinder from parts salvaged from a single-use film camera, how to make your own IR filter on the cheap, and how to convert your own camera to full time infrared shooting. There are even step-by-step illustrated instructions for converting a popular camera model.
   
   None of the other IR books I've read touch on all the topics found here. This is highly recommended.



3. I picked up this book after already being really interested in IR photography, or as David corrects, is near IR photography.
   
   He shows you how you can convert your camera, but also recommends LifePixel for conversion, which I had done. He does not steer you wrong there with that suggestion. I do have some sample images on my blog at [...]
   
   David gives you several ideas for dIR photography and more than just typical IR subjects as well. This is a definate keeper.



4. This book is great. The information provided will help anyone that is thinking about trying infrared photography. Digital cameras make the process so much easier without the hassle of trying to find a pro lab that will develop infrared film. This was a good purchase and I intend to get lots of use out of it.



5. The overwhelming majority of this book is devoted to photography basics. There are no pro secrets. Everything in this book is available on the Internet at a number of IR photography web sites. It's unlikely that a pro photographer would be clueless as to figuring out which filter sizes a specific lens requires (it's printed on the lens) or that a tripod is a must for long exposures. His section on post-processing is limited to telling the reader to purchase expensive Photoshop plug-ins. It gives the impression the author is a shill for the plug-in authors. Don't waste your money on this book.

2 comments about Kicking Butt with MIDP and MSA: Creating Great Mobile Applications (The Java Series).

1. This book has many topics very well writen, i really recomend it.
   And it have new technology for J2ME



2. I really hate Netbeans, but in spite of that fact, and the fact that this book makes heavy use of the technology, I dug into the book. I have a real interest in learning about the development of Java programs on cell phones past the writing of small local applications and games, and this book seemed to fit the bill. I'm the happy owner of many of the author's past books, and this one didn't disappoint me either. At first glance parts of the book look rather sparse. That is because, for one, Knudsen doesn't see the point in just regurgitating the standard. The second reason is that much of the source code is on the book's accompanying website. If you are interested in writing mobile applications with Java, I highly recommend this book. I discuss the book's contents chapter by chapter as follows:
   
   Section: I Getting Started
   Chapter 1. Overview - explains why MIDP is such a good fit for mobile devices and describes how MIDP and the rest of the band fit together to form a powerful platform for mobile applications.
   Chapter 2. Tools - Building MIDP applications is surprisingly easy. This chapter describes several development alternatives and explains some of the magic that these tools provide. Also justifies Netbeans, which I dislike, but it's a fair trade-off to play with such cool stuff.
   Chapter 3. Quick Start -Describes a few simple parts of MIDP so that you can get something running right away. You'll also have a basic scaffolding upon which to build your later knowledge.
   Chapter 4. Core APIs - Don't assume that you know all this stuff, even if you're experienced with Java technology on the desktop or in a server environment. The constraints of small devices dictate that these APIs are more compact and less rich than their desktop counterparts.
   
   Section: II The Lives of MIDlets
   Chapter 5. The MIDlet Habitat - learn the details of how MIDlets live and die and how devices prevent bad MIDlets from performing bad deeds.
   Chapter 6. Starting MIDlets Automatically - Incoming network connections can start a MIDlet. For example, a Short Message Service (SMS) message arriving on a certain port or an incoming socket connection could launch a MIDlet. MIDlets can request to be started at a specific time. MIDlets can respond to specific types of content. For example, an audio player MIDlet can be set to handle one or more audio file types. Other applications can ask the device to launch a MIDlet to handle a certain type of content.
   
   Section: III User Interface
   Chapter 7. Basic User Interface - This chapter and Chapter 8 discuss the screens that LCDUI, the user interface, supplies and their supporting baggage.
   Chapter 8. More User Interface
   
   Section: IV Graphics
   Chapter 9. Creating Custom Screens - If the plain old LCDUI screens are not sufficiently jazzy or flexible for your application, you can create your own screen using a canvas. It's more work, but it's more fun. You can control almost all of the drawing on the display and you get fine-grained event information as well.
   Chapter 10. Custom Items - A middle ground lies between the easy path of canned LCDUI screens and the raw bravado of using Canvas. Custom items are your own items that can be placed into standard forms. A custom item is very similar to a canvas, but it has some additional equipment to allow it to be part of a form.
   Chapter 11. Using the Game API - One popular category of Java ME applications is games. Even when faster data networks make other types of applications more popular, games will always be an important part of the Java ME ecosystem. MIDP has a Game API designed to help you create 2D action or board games. It has a souped-up canvas and supports building a screen using multiple layers. The entire API consists of five classes that are discussed in this chapter.
   Chapter 12. Scalable Vector Graphics - The shortcomings of images on small devices are addressed by JSR 226, the Scalable 2D Vector Graphics API for J2ME. Scalable Vector Graphics (SVG) is a kind of XML for describing pictures. Because it is essentially a programming language, SVG can also describe animations and user interactions. JSR 226 is a standard API for displaying and manipulating SVG documents.
   Chapter 13. 3D Graphics - The Mobile 3D Graphics (M3G) API, gives MIDlets the ability to show 3D content. It is a scaled-down version of the desktop Java platform 3D API. The M3G API is a scene graph API, which means it knows how to render scenes that are described as a hierarchy of groups and objects. How to use the API is discussed here.
   
   Section: V Storage and Resources
   Chapter 14. Record Stores - MSA devices provide three ways to work with persistent storage. The first way is with record stores, which are tiny databases that contain records. The official name for this API is the Record Management System (RMS), which is covered in this chapter.
   Chapter 15. Reading and Writing Files - MIDP devices often have some kind of hierarchical file system. The PDA Optional Packages define a FileConnection API that provides access to a device's file system. It is a mandatory part of MSA and MSA subset. The FileConnection API is the subject of this chapter.
   Chapter 16. Contacts and Calendars - The Personal Information Management (PIM) API provides access to contact lists, calendars, and to-do lists on mobile devices. The API is the subject of this chapter.
   Chapter 17. Mobile Internationalization - A fancy phrase that means making your application run in different languages. Internationalization is handled by Mobile Internationalization API, the subject of this chapter.
   
   Section: VI Networking
   Chapter 18. The Generic Connection Framework - All network access in MIDP devices works through the Generic Connection Framework (GCF). The fundamental idea of GCF is very simple. Your application supplies a connection string, and GCF hands back the corresponding input and output streams.
   Chapter 19. Text and Multimedia Messaging - This chapter covers the Wireless Messaging API (WMA) which extends this capability of transmitting and receiving text messages to MIDlets.
   Chapter 20. Bluetooth and OBEX - teaches you the fundamentals of Bluetooth communication but does not attempt to cover the Bluetooth and OBEX (Object Exchange) APIs in meticulous detail.
   Chapter 21. XML and Web Services - describes how to use the XML parsing API, how to call Web services using the JAX-RPC API, and how to work with RESTful Web services. Examples will show how to parse a Rich Site Summary (RSS) feed and how to write a RESTful client for the Flickr photo-sharing service.
   Chapter 22. Session Initiation Protocol - Session Initiation Protocol (SIP) is a standard way to set up a call, videoconference, or other session between two network endpoints. This chapter is a broad overview.
   
   Section: VII Multimedia
   Chapter 23. Playing and Recording Sound and Video - Discusses the Mobile Media API (MMAPI) for working with images, audio, and video. There are some good detailed examples here.
   Chapter 24. Advanced Multimedia - expands on the promise of MMAPI with 3D audio, image processing and encoding, camera and radio control. The basics are in the book, the online software has more detailed examples.
   
   Section: VIII Security and Transactions
   Chapter 25. Smart Cards and Cryptography - an introduction to the Security and Trust Services APIs (SATSA). SATSA actually contains four separate APIs. Two of these are for communicating with smart cards, while the other two relate to cryptography. Only the basics are covered.
   Chapter 26. Mobile Payments - discusses The Payment API, which provides MIDlets with a simple API for making payments.
   Chapter 27. Know Where You Are - discusses the Location API for using GPS to determine where you are or where you want to go.
   Chapter 28. Application Architecture - a good capstone chapter presents ideas to help you with your application design. This chapter gets you in the right frame of mind to design your own application effectively and imaginatively.

2 comments about A to Z GIS: An Illustrated Dictionary of Geographic Information Systems.

1. Books about GIS are usually quite technical, surveying the applications and computer potentials of geographic information systems, so it's refreshing to note that A TO Z GIS: AN ILLUSTRATED DICTIONARY OF GEOGEPHIC INFORMATION SYSTEMS is something different: a simple set of geography and cartography definitions designed to defines values, coordinates, reference systems, representations, and GIS data processing methods and routines. Students of GIS will find this essential to understanding the terminology of both computer and geography worlds.
   
   Diane C. Donovan
   California Bookwatch



2. Have you rummaged through a GIS textbook for half an hour looking for a simple definition, never to find it? Have you wondered why a $100 "introductory" textbook has loads of extraneous information but not a simple glossary, or how it can be written so obtusely and still get past an editing staff? Well, this is the Allen Iverson of GIS books, "The Answer." It gives you GIS concepts clearly and succinctly, with great explanatory illustrations for the "visual learners" out there, which are many in geography I would think. This has been a "go to" book for me in GIS but also in Remote Sensing; there's no question whether to get it, only how much the bookstore will pay you to buy back that unused textbook that you blew $100 on.

5 comments about SCBCD Exam Study Kit: Java Business Component Developer Certification for EJB.

1. This is a very good book on a complex subject. Explanations of the concepts are easy to understand. Exam objectives are covered in detail with example codes and review questions.
   Each chapter covers the individual exam objectives as well as summarizing the gist. Logical organization of the chapters helps conceptualize even the toughest topics.
   
   The Quick Prep Appendix for last-minute cramming and free downloadable Whizlabs SCBCD exam simulator are very effective tools for the exam.
   
   I recommend this book as must have SCBCD exam preparation book that can be also used as a reference book on EJB.



2. I used this book as a primary preparation tool for the Sun Certified Business Component Developer (SCBCD) exam. Being a beginner in EJB, I found this book to be very friendly. I liked the layout of the book in general and the writing style of the author in particular. Only relevant pieces of code are presented to focus explanation of topic in question. A complete running application may be downloaded from the author's website. The multiple choice questions at the end of every chapter and ALERTs in every chapter made remembering main points easier. Deployment descriptor elements are clarified in considerable detail and they are explained well. Please note that there are errors in this book - some of them are fairly obvious such as using a capital letter as opposed to a small letter (Java versus java) while others are not so obvious but noticeable by experienced java developers. Regardless of its minor faults, I consider this book to be a valuable addition to my library. Normally I would have a cut a star for the errors but because of its content quality, I felt compelled to give 5 stars. I just passed the exam today thanks to this book. I know that I will not hesitate to buy another book from this author. Thanks Mr.Sanghera! I recommend this book highly without any reservations whatsoever.



3. This is a good book to learn the concepts of EJB but for the exam you need the HFEJB book.
   The details of Context objects (which method of Context object you can use in which method call of the Bean class) are more descriptive in HFEJB
   If you are planning to sit for the exam this book should be accompanied by HFEJB



4. What I was most impressed in this book was how clearly it's written and yet it goes deeply on those details that can always get you confused on a certification exam.
   
   I am very satisfied.



5. This book is an excellent read start to finish. Topics are introduced gradually, the same topics are dug dipper as we proceed. The author makes sure you understand clearly as we proceed.
   No confusions created with too many scribblings and notes, going back and forth; like in the "Head First..." I had to drop that one at end of 2 chapters, you can refer to that for some examples if at all.
   With this book I never had to refer to anything at all. I definitely recommend this book over the "Head First..."