3 comments about Pro J2ME Polish: Open Source Wireless Java Tools Suite.

1. I searched for something like that so long. The tool is definetely already state of the art to enable Developers producing professionell applications under the J2ME Plattform. This book supplement the already existing and good documentation and explains everything from higher perspective.
   
   Very Well done !



2. When you first learn J2ME, you learn about this fantasy world where all devices follow the J2ME specification to a tee. But in the real world, because of the interpretive nature of the specifications, no two devices really implement the specification exactly the same. So this requires either targeting a particular device or have many versions of you app to run on different devices.
   
   Man what a pain. But that is where J2ME Polish comes to the rescue. J2ME Polish provides pre-compiler directives to allow you to write code such that J2ME Polish's build script can automatically create different versions for you on the fly however you want. There is a lot more to J2ME Polish than just that, but this is a book review.
   
   So let's get to that review. Well, first Robert Virkus is J2ME Polish, well he is the architect and lead programmer for J2ME Polish. Who better to write a book about it? Consider this book the hard copy of the manual for J2ME Polish. If you are going to use J2ME Polish, then this book is a must. It is the reference book that you will need to find anything you need to know about J2ME Polish.
   
   Now, it isn't really a read all the way through the book and you can be J2ME Polish expert. You really need to be actually using J2ME Polish at the time, to better grasp what is being explained. The book can be hard to understand, not because of the writing, but because J2ME Polish is feature rich and there is lots to learn.
   
   I highly recommend using J2ME Polish and buying this book if you will be developing for more than one device, and also to get their cool looking GUI screens, rather than MIDP 2.0 High Level GUIs.



3. I'm a serious J2ME developer. I bought this book because it claimed to solve the 600 phone problem. It also promised to do some fancy GUI which are otherwise completely lacking in J2ME.
   
   However, right out of the box the first demo, the menu sample, fails utterly. Ant crashed because I didn't put an Ant jar file in the any classpath then the menu sample didn't work. I had to search some forum to find there is a bug in the latest RC4 download. Apparently no one at Enough caught or fixed it. To fix it I had to patch a css file deep inside the project. If that wasn't enough the actual menu demo looked horrible on WTK 2.5. Couldn't see the menu highlights and it scrolled incorrectly.
   
   Then I tried the roadrunner game. But the game didn't fit on the screen properly--isn't this the 600 phone issue? Ultimately, when I tried to exit, the game (or emulator) crashed. I looked at the jar file size and it was a whopping 462 KB on just 1,433 lines of source! Unreal.
   
   I tried the tabbing demo which looked decent and worked well enough but it was 430 KB on just 200 lines of source. This is awful.
   
   J2ME Polish depends on Ant and preprocessing of #ifdefs which were recognized a bad idea when C introduced them 30 years ago. C++ introduced const (and Java, final) partly for this reason. Actually, in J2ME Polish (and NetBeans) they're not #ifdefs but //#ifdefs because Java never bothered, and rightly, with this silliness--and here they are back again. They make the code less readable and they're virtually impossible to debug.
   
   Then there's this matter of integration of the IDE (I use Eclipse) and Ant. I mean, why bother with an IDE if you must still use Ant? Throw in some .css files, too, for good measure. I just don't get it.
   
   Indeed, I'm returning the book for a refund. I had enough from Enough.

5 comments about JMX: Managing J2EE with Java Management Extensions (Java (Sams)).

1. This book will be of particular interest to you if you're using JBoss as your app server, as JMX forms the fundamental glue used to implement the JBoss server.
   

   The book starts out with some nice introductory coverage for Standard MBeans, which are about the most dirt simple classes to code so I expected some good writing here. From there we start getting into Dynamic MBeans where the fun really begins. I was particularly interested in the implementation of ModelMBeans, which are dynamic MBeans that can map to a resource (like a printer for example) and provide automated attribute caching etc.
   
   While the Dynamic MBean coverage was fairly adequate I was pretty disappointed with the ModelMBean coverage. Not enough time was spent describing all the Info classes and Descriptor attributes you need to implement. I spent a lot of time experimenting, reading the JSRs, and working through a subsequent ModelMBean implementation chapter to figure things out. There are also numerous bugs in the sample code for ModelMBeans.
   
   The Chapter discussing the MBeanServer was a little light but reasonably well done. Enough to help you understand how it works which is all you need to program with anyway.
   
   One sorely lacking area is JMX notifications. The interfaces are briefly mentioned, but there is little by way of sample code, or in depth discussion of the default JMX notifications. Since notifications are based on the AWT Event model you can find plenty of other source material for how the notification mechanism works, but I'd like to see more detail on the JMX standard messages etc.
   
   I enjoyed the JMX standard services section. They were very instructive, and helped indirectly patch together some of the notifcication stuff.
   
   The JBoss chapter is, of course, quite good with detailed information about how JBoss uses JMX, how everything fits together in JBoss with JMX. All in all it's a great case study of what you might do with JMX.
   
   This book was a good introduction to JMX, but I felt it lacking in certain areas of detail. Since there are relatively few JMX books (in fact I think this might be the only one) it's not a waste of money, just not as insghtful as I'd hoped.




2. The example code, ...doesn't match the examples in the book. The files are all in a single directory instead of being seperated by chapter. This makes it more difficult to work with.

   Some of the examples will no longer compile due to changes in the JMX spec. There's no errata files.

   Other than the difficulty of the examples, the book provides a good introduction to JMX.




3. Although the contents in the books are a little haphazard and the samples don't run out of the box, its has excellent content.
   This is definately not an intro to JMX if you're not ready to poke around.
   Interestingly the difficulty in running the samples and the poking around ultimately led me to get a much deeper understanding of the JMX concept.
   Its sort of like how you remember the directions well after you've been lost a few times and havinng to figure your way out of it.
   If you use open source software and are used to poking around to troubleshoot its an excellent book. Just don't except too much handholding.
   Thanks guys for introducing me to the fascinating world of loosely coupled systems based on JMX and dynamic proxies!!



4. First reading this book and then the JDMK 5.0 Tutorial from Sun I was struck by how much of it is copied from the tutorial. The tutorial seems very well written and complete, and I would recomend it before this book.



5. While JBoss has been successful in various aspects of its operations, this book by them is now obsolete. The industry has largely moved away from JMX. The book was written at a time when JMX seemed like the Next Big Thing. Alas, the book does not indicate that in practice, JMX proved too intricate. Since then, Web Services and Service Oriented Architecture have become more popular choices, for building dispersed applications.

5 comments about WebSphere Application Server Bible.

1. I recently started a job that is using WAS for their application server. I needed a reference book to help jump start me, and I felt this book did a great job. It covers the install and admin pieces quite well, and I am beginning to go through the development sections. I like the fact that they have a lot of code examples and an overall running project example. I get alot of use from looking at actual working code. The book does use the WSAD(WebSphere Studio Application Developer) tool to illustrate the examples, but I just used my favorite editor and Javac with out any problems. Overall this book explained well the things I needed to know and I would recommend it to others.



2. Complete, detailed, easy to read and understand, this book should be shipped with every copy of Websphere Server. The best money I've spent on a technical book in years. If you are developing applications with Websphere, you should own a copy of this book. It clearly explains how to exploit J2EE technologies in your application architecture, as well as how to take advantage of the features of Websphere Server. Invaluable as a learning guide or as a reference.



3. This book is an excellent resource for WebSphere administrators and WebSphere developers. In fact, I have attended instructor-led courses by several major system providers and this book taught me more about J2EE programming than either provider. Examples and a complete application are available for download and they're in .jar .ear format which makes importing and running in WSAD much easier than generic texts. The target audience is somewhere between beginner and intermediate student. The language and detail level is effective for Java students. You won't need a dictionary of OO terms to follow the author's explanation and purpose of components.



4. I am glad others found the book useful. I found it nearly worhtless although I was pleased with the WSAD 4 coverage. However, explanations are minimal and trying to deploy your first app to WebSphere 4 using this book was a waste. After reading and re-reading everything it said, we still had no success so we just dug in, trial and error, several days and finally got it. Discussions on virtual hosts offered us nothing but a few descriptions that only make sense after you understand what a virtual host is. With paragraph after paragraph labeled understanding, I would have thought some would have been imparted - we needed quick understanding in a real project and the way things are today, we needed it fast. The book gets rarely referenced by myself. There is just not enough in depth explanation to save one from the school of "hard knocks". A student, with time may get some value as an introduction but overall I was disappointed.



5. I bought this book because it was marketed as a guide for the beginners and intermediates. Lie.

   I needed to learn websphere for my job, so after the first few chapters I had to stop because the thing started to fly way over my head. All I needed was something to explain me the basics and the most common architecture and mechanics.

   This book doesn't do that. Maybe if you are a veteran with Websphere, this might be good, but if you are looking for something to get you started, stay away from this book.

No comments about Microsoft Office FrontPage 2003: Comprehensive Concepts and Techniques.

5 comments about Java Demystified.

1. It seems to cover everything you need to become productive right away. The tech jargon is kept to a minimum. Everything is explained for you. You can follow along with examples using your computer. I simply copy the examples and then change them to the specs the Prof wants for homework. Worth the dollars.



2. This is my third Demystified book and I haven't been disappointed at all. All are an easy read and full of just the code you need to get programming quickly. I knew nothing about Java nor programming before reading this. Now I can program in Java. Don't be mislead. It is not an end all book. But it has just the right blend of Java to make you productive right away by building useful applications.



3. Comeing from Coldfusion and Action script, this book was just the right thing for me to get started with java.
   Its still a long way but this book definitly helped me a lot!



4. How can one review a book half of which is difficult to follow?
   
   Perhaps the book should be renamed to "Getting Used to Java Syntax". The basic language elements are reasonably well presented. However, the second part of the book, which attempts to describe more advanced concepts, does not impart much understanding. I am still mystified by Exceptions and Multithreading.



5. I picked this book up after I got dumped in the deep end, needing to modify Java code in some NIST image processing software. The good - I could follow the examples readily - I'm 100 pages in in a couple of hours, and I'm readily learning the specifics of Java structure that I need to start modifying code.
   The bad - it looks like the book was mechanically spell-checked, but not grammar-checked. There are a lot of sentences, in and out of the code examples, where I just had to shake my head. One example was flat out wrong - on page 92, where the it says that an index is a number from zero to "1 minus the maximum number of elements in the array". This will give you a non-positive number. Not a world ender, but catching so many of these on a first skimming pass makes me a bit leery of how good the rest of the examples will be.

5 comments about Java for RPG Programmers: 3rd edition.

1. This is a pretty good book for RPGIV programmers wanting to migrate to Java. It compares all the functions of Java to RPGIV in a way that is very understanding to non-object-oriented programmers. It's a much better book than the past Java books i've read (which are intended for university students familiar with C++).

   What this book does lack however are self-excercises. It's merely a good reference book to learning the basics of Java. The authors do a good job of explaining the necessary components. This book also lacks a lot of 'interactive programming' samples other books offer. There were hardly any 'GUI' programming to practice on your home PC...mostly command line tests they show you. It's not a bad book overall.




2. I started with a book called Java 2 from Scratch and did a lot of scratching of my head. I think it'll be a good book for me eventually, but not right now. I needed something better to get my feet wet. A co-worker lent me his copy of Coulthard and Farr's book and I spent an evening with it. Afterwards I went to Amazon and ordered it.

   If you are an RPG programmer (I'm from the ILE RPG IV side) and want to begin learning JAVA, this is the book to start with. It does a good job contrasting RPG with JAVA to as to give a decent reference point. No other book does that and I found it to be most helpful. When I finished the book, I felt a lot better about the language but I need to go further with something else (Ivor Horton's book is probably going to be the something else).

   I thought the chapter on the Java Onion was really well done and very informative. The chapter on Threads was completly over my head. I'll return to that topic at some future point. The OO chapter was good but I found Jennifer Hamilton's Object Orientation for the AS/400 Programmer does a better job explaining these concepts. Over all these guys did a real fine job.

   By the way, I had the privelege of attending their Java seminar at the Fall Common conference in Baltimore and they really made the seminar enjoyable. You should catch one of there presentations some time. They're a good team and keep your attention. They do a good job.

   The one beef I have is they left me hanging on page 418 with the MsgBox class. They say it would be simple to add the line of code to your program to use the class. Maybe I'm being stupid, but it wasn't simple for me. They should have at least shown you how to use it because I still haven't figured it out. Phil or George, are you reading this? Maybe someone can e-mail be and let me know. Aside from that irritation, I really liked the book and would recommmend it to any RPG programmer looking to start learning JAVA. A word of caution, it's not the end all. It's a start but you will defintely need to move to something meatier as a next step.




3. If you have RPG III or RPG/400 code or this same code that was converted to RPG IV, then this book gives you little to go on but an education in ILE programming techniques. I think that if you were a C or Java programmer trying to understand RPG IV, this book would probably be very helpful.

   My impression is that RPG IV should have been called RPG-C. That would have been closer to what it seems it was intended for, RPG to attract C programmers. I think that if one had their applications designed and written in ILE RPG with service programs and proceedures, etc. then this book would be helpful in learning the java language.

   If your programs are designed around RPG III, converted or not to RPG IV, plan on having to learn two languages as you attempt to understand Java.




4. Many readers coming to this might like what is described about java. Very different from RPG. The biggest change is the intrinsic object oriented nature of java. If you use RPG 3, then this will certainly be the most distinctive part of the narrative. RPG 4 programmers will at least be familiar.
   
   There are many neat features about java that you should note. Like the higher level data structures, Vector, HashSet, Hashtable etc. These have been thoroughly debugged, and can save you much time recoding. Another difference is a full widget system. RPG came of age when graphics meant character oriented tables. Speaking of characters, java comes with internationalisation. Whereas RPG shows its heritage from an ascii background.
   
   Unsurprisingly, the book has an extensive section on connecting java to a database. Some readers will perk up at this. You can closely compare functionality with RPG. Here, the latter is probably still stronger. But the java designers at Sun have done a competent job with JDBC.



5. You couldn't ask for better service and a product in better shape. Thanks for your service.

5 comments about Oracle PL/SQL Developer's Workbook.

1. This book covers a wide range of material. In this sense it is good for someone of every level but it also means you will only use a part of the book. Each chapter is structured like a quiz - answer the questions and then review the answers. It does not work you through problems but there is a lot of useful material in here that you will not find anywhere else.



2. This is a great book to test your PL/SQL knowledge no matter what level you are at. In fact each chapter is devided into 3 sections: Beginner, Intermediate and Expert. This is an excellent book to get after you have worked through a PL/SQL course and want something to give you the extra edge on all the various PL/SQL topics. There is some very good hard to find information in here.



3. I thought this book was great. If you like getting into specific, real-world programming tasks and figuring out the best solutions then this book is for you. He provides helpful explainations along with his solutions. There are a lot of top-notch, practical techniques that you learn as you get into the nitty-gritty of working on small pieces of pl/sql code. There are also questions that test your conceptual understanding of different facets of pl/sql programming --- questions that you could face on a job interview. Even though I've been a pl/sql developer for a few years, I found this book very useful.



4. If there is any book which will "fine-tune" one's knowledge of PL/SQL, this is it. It is written in Feuerstein's inimitable style which will keep you engaged with the book much longer than any other peer book of it's kind. There is so much to learn from this book really - and it applies to beginners as experts alike. This book explores the tiniest nuts and bolts of PL/SQL in an exercise-like format which gives the reader a chance to ponder on the problem before he/she looks up the answers. And I must add, you are in store for a lot of surprises when you look up the answers in the second half of the book ! (escpecially in the experts' section)



5. If there is any book which will "fine-tune" one's knowledge of PL/SQL, this is it. It is written in Feuerstein's inimitable style which will keep you engaged with the book much longer than any other peer book of it's kind. There is so much to learn from this book really - and it applies to beginners as experts alike. This book explores the tiniest nuts and bolts of PL/SQL in an exercise-like format which gives the reader a chance to ponder on the problem before he/she looks up the answers. And I must add, you are in store for a lot of surprises when you look up the answers in the second half of the book ! (escpecially in the experts' section)

1 comments about Accelerated GWT: Building Enterprise Google Web Toolkit Applications (Accelerated).

1. This was the first book that I purchased as I begin to learn GWT. I had high expectations; I guess I was drawn in by the title. But after a first quick read I cannot recommend this book. A significant part of the book was dedicated to simply listing the widgets that are available in GWT and describing them ... I really don't need to read a book for such information, and particularly a book that has the word "Enterprise" in the title. I expected to see information that was geared toward large-scale and robust application construction, but instead the text seemed to meander through topics with a lack of true cohesiveness and direction.
   
   A much better book, in my opinion, is: GWT in Practice, and excellent book for both beginning and intermediate GWT programmers.

5 comments about QuickTime for Java: A Developer's Notebook (Developers Notebook).

1. With Apple changing QuickTime for Java so anything you made when
   use QTJava under MacOSX Java1.3 no longer worked under Java1.4 these required changes to most of your older QTJava code- if you wanted to have your code now run under Java1.4. Apple also moved classes to a new packages so to make the developers nightmare complete. BUT DONT WORRY! This book will show you workarounds for them missing classes (sequence grabbing is back! what a gem). Also covers all your needs as a new developer to the powers of QTJava. Time to make your very own QuickTime player in a few hours! You won't believe the stuff QuickTime can do under the hood. This books covers just more and more stuff as you go though it.
   
   For me this QuickTime for Java book will be sitting next to the older most excellent book from Bill Stewart. I hope all books become as clear and well written as this one from Chris Adamson- top work. Sample code all over the shop; step by step stuff. Cuts to the tasks you will have to tackle without lengthy messing around. Brilliant buy if you want to do cool hardcore design media in java. Or just play a nice sound track in the background of your killer application - maybe u want to make the next video editing studio app, or your own media player, or a streaming server, or a image editor, or or or; you want ta take a ride?
   
   Then again don't buy it! I wont have a job to go to in the morning! :).



2. With this type of walkthrough book I usually expect to see just the basic features of the technology explored. This book goes surprisingly in-depth, covering topics like adding effects to playback, transforming movies during playback, overlays, and a wide variety of topics.
   
   All that is crammed into a trim 200 page frame. This is achieved by concentrating mainly on the code, and effectively using a minimum of images. That's a trick given the graphics intensive nature of the topic.
   
   This is not a book for beginners, it's a fast-paced walkthrough for experience developers who want something less referential than the JavaDocs.



3. While at first I thought O'Reilly's new "developer's notebook" series seemed a bit hokey, this book is extremely useful. It's concise and to the point, but full of good examples and information. A plus of the small size is that it's more to-the-point and cheaper than a typical O'Reilly book (which very often seem to ramble on and on about marginally useful information, seemingly in order to justify their $45+ price tags).



4. This book is great!
   
   This notebook makes all the QuickTime supported formats available to a Java developer. Like all the books in the notebook series, plenty of code, plenty of information to get up and running.
   
   I really liked the information on reading the tag info from MP3s and AAC files, very useful.
   
   Multimedia and Java made simple.



5. This book is the one that should have been written for Java Media Framework, if only that API had ever lived up to its expectations. If you want to add media to your application, and you are using Java, Quicktime is your best bet. However, note that if the Quicktime for Java API doesn't seem very Java-like or object-oriented at first glance, then that's probably because it's not. That is because with Quicktime for Java you are not working with pure Java. Instead, you're invoking a flat C API to create and manipulate C or Pascal data structures using a thin Java wrapper. If you can live with that and you still want to use Quicktime for Java, this book is the essential guide and tutorial you need to get up and running. The book does not waste your time with API printouts or a Java programming language tutorial. Instead, like all books in the Developer's Notebook series, it gets down to business quickly by demonstrating working Java code for a number of useful tasks when working with media.
   
   First, it tutors you on how to set up Quicktime for Java on a Windows machine. This task is more complex than you would think, and this book hits the mark on the subject. Next, it shows you how to play movies and audio files from your Java program. Next, the book tackles the editing of movies from a Java application. This includes topics such as cutting, pasting, going to specific frames of a movie, and "flattening" a movie. In Chapter four, the programmer is introduced to working with Java components and importing and exporting graphics. In chapter five, the user is introduced to working with QuickDraw, the Apple-originated drawing API. This is essential, since QuickDraw is what is used to work with captured images. Thus in this chapter the reader is taught how to transfer data between images and a movie. Next, the art of capturing both video and audio is explored, including capturing audio and video to the same file. The chapter is rounded out with the code for a motion detector. Chapter seven is devoted entirely to audio media. There are particularly timely topics here, such as how to read information from MP3 and from iTunes AAC files, how to provide basic audio controls, and how to build an audio track from raw samples. Similar information is provided in a separate chapter for information specific to video media.The final chapter discusses the effects available in Quicktime for Java, as well as how to add text captions and timecodes to your media.
   
   All in all, I think the Developer Notebook format works well for this subject. At the beginning of each chapter there is an outline of the topics to be covered. For each topic there is a "How Do I Do That?" section that includes a short piece of Java code that performs the specified task. There is also a sample of the output you would expect to see on the screen that should result from executing the code. Next there is a paragraph entitled "What Just Happened?" that explains the code just shown, and finally each topic usually ends with a "What about.." section that answers common questions you may have about extending the code just shown. All code in the book can be downloaded from the book's website at O'Reilly and Associates.
   
   This book is essential reading for anybody who needs to understand how to code with Quicktime for Java, and it is far better than any other publication on the subject that I have encountered. Amazon does not show the table of contents for this book, so I do so for the purpose of completeness:
   Chapter 1. GETTING UP AND RUNNING WITH QUICKTIME FOR JAVA
   Setting Up QTJ on Windows
   Embedding QuickTime in HTML
   Preflighting a QTJ Installation
   Compiling QTJ Code
   Opening and Closing the QuickTime Session
   Playing an Audio File from the Command Line
   Chapter 2. PLAYING MOVIES
   Building a Simple Movie Player
   Adding a Controller
   Getting a Movie-Playing JComponent
   Controlling a Movie Programmatically
   Showing a Movie's Current Time
   Listening for Movie State-Changes
   Moving Frame by Frame
   Playing Movies from URLs
   Preventing "Tasking" Problems
   Chapter 3. EDITING MOVIES
   Copying and Pasting
   Performing "Low-Level" Edits
   Undoing an Edit
   Undoing and Redoing Multiple Edits
   Saving a Movie to a File
   Flattening a Movie
   Saving a Movie with Dependencies
   Editing Tracks
   Chapter 4. WORKING WITH COMPONENTS
   Specifying a Component's Type
   Exporting Movies
   Exporting Movies to Any Installed Format
   Importing and Exporting Graphics
   Discovering All Installed Components
   Chapter 5. WORKING WITH QUICKDRAW
   Getting and Saving Picts
   Getting a Pict from a Movie
   Converting a Movie Image to a Java Image
   A Better Movie-to-Java Image Converter
   Drawing with Graphics Primitives
   Getting a Screen Capture
   Matrix-Based Drawing
   Compositing Graphics
   Chapter 6. CAPTURE
   Capturing and Previewing Audio
   Selecting Audio Inputs
   Capturing Audio to Disk
   Capturing Video to Disk
   Capturing Audio and Video to the Same File
   Making a Motion Detector
   Chapter 7. AUDIO MEDIA
   Reading Information from MP3 Files
   Reading Information from iTunes AAC Files
   Providing Basic Audio Controls
   Providing a Level Meter
   Building an Audio Track from Raw Samples
   Chapter 8. VIDEO MEDIA
   Combining Video Tracks
   Overlaying Video Tracks
   Building a Video Track from Raw Samples
   Chapter 9. MISCELLANEOUS MEDIA
   Creating Captions with Text Media
   Creating Links with HREF Tracks
   Adding Timecodes
   Creating Zero-Source Effects
   Creating One-Source Effects (Filters)
   Creating Two-Source Effects (Transitions)

1 comments about Computing Fundamentals With Java.

1. Written in 2002, Mercer's book teaches Java from scratch. A well done pedagogy. That gets across the ideas in object oriented programming, as well as specific fluency in Java. The general purpose lessons and ideas in OO are timeless. And largely transportable to any other OO language like C# or C++.
   
   The text also has a short history of how OO programming arose. Showing the earlier structured or procedural programming approach, as exemplified by Fortran or Pascal.
   
   The coding examples are also a good introduction to writing graphical programs. Where the code often waits for user commands. With the associated ideas of registering callbacks (called listeners in Java) and of simple multithreading.
   
   The biggest problem is that the Java is somewhat dated. Java has been through 2 major revisions since 2002. However, those tended to expand the set of classes in the standard distribution. Newer Javas are a superset of the Java treated in the book.