1 comments about Beginning Spring 2: From Novice to Professional (Beginning from Novice to Professional).

1. How can this be the first & only Spring authorized book?
   
   When I brought this book I was totally new to Spring but I needed to learn it since our project was mandated to use it. Even after reading the first three chapters (which the author states is required reading), I still couldn't quite get it. First, the author spends too much time in chapters 1 and 2 singing the praises of Spring and doesn't even present a standard "Hello World" solution. Finally in chapter 3 he does start getting into code but its rather convoluted and is only meant to show how/why the Spring Framework saves time versus doing things the usual way.
   
   I finally gave up and went and purchased the "Spring in Action" book by Craig Walls which is excellent for the beginner and even presents a relevent & simple code example from the get-go in Chapter 1. The Walls book is what the beginner needs ad explains every concept from both a historical and relevant use point-of-view.
   
   Now that I've been using Spring for a while, I can say that Minter's book is appropriate only if you already know the fundamentals and want to use it for quick reference (which I do) in its later chapters. But don't buy it expecting any "hand-holding" on your journey to master the Spring Framework.

No comments about The Definitive Guide to Apache MyFaces and Facelets (Definitive Guide).

5 comments about Pro Java ME MMAPI: Mobile Media API for Java Micro Edition (Pro).

1. This is an excellent book for those with an interest in creating Multimedia Applications for J2Me Mobile devices.
   
   I would say that the book is split into three sections:
   
   Section 1 (chapters 1 to 3): This section gives detailed information about the architecture of the MMAPI and how it fits within the J2Me platform. There is also has a good "getting started" guide to be found here.
   
   Section 2 (chapters 4 to 8): Deal with how one uses the Player object in all its forms from playing simple tones, to playing back captured and streamed video.
   
   This section was the most useful to me. It provides excellent
   background information about each of the subject areas. An example of this is that it gives a full history of the MIDI standard, and an overview of the protocol itself, before it starts talking about how you write the code to play a midi file in J2Me.
   
   Section 3: (the last chapter) is a case study, providing yet more code examples, and a companion blog site.
   
   The only criticism that I have, is that the book, could have delved into the realms of streaming media a little deeper. The company that I work for, weComm is actively involved in the mobile TV space and I was pivotal in the creation of our application for streaming TV, and therefore I was hoping that this topic would be covered in more detail. That aside, I was very impressed, the subject matter was covered very thoroughly, and I felt guided through the MMAPI as I was reading it.



2. This is a well written book. It's not for beginners but then again you don't have be a J2ME (Java ME) guru to understand it. The writing style is technically clear and straight forward without a lot of personal fluff.
   
   Since MMAPI is a subset of Java ME, the scope of the subject is fairly limited but the author covers it well. The only area I might like more explanation is with respect to DataSource and SourceStream. This is covered briefly at the beginning of the book, but it would be nice to know how to implement a custom protocol.
   
   The biggest problem I have had with the MMAPI is it's inconsistent implementation and the author is quick to acknowledge this. One could probably write a whole chapter about the quirks of various mobile devices.
   
   In conclusion, I doubt you will find another book specifically on MMAPI that has the depth that this one does. I highly recommend this book if you are looking to get your feet wet with the MMAPI.
   
   BTW, I really appreciate the time the editors spent to proof read the text as there are very few errors, if any. It's always frustrating to me when I read a book with a lot of code and spelling errors. That's not the case here. Well done!



3. Pro Java ME MMAPI: Mobile Media API for Java Micro Edition has amazed me. The book is unique as it covers and desmyifies one of the most fragmented and confuse Optional Packages for JME.
   
   I've read more than a dozen books about JME but this is the first book that has really cleared some doubts I had regarding Mobile Media in JME.
   
   I strongly recommend this book if you are developing Multimedia Applications using JME.
   
   Vikram Goyal has done an outstanding job by clarifying and detailing every aspect of MMAPI, discussing the way it has been specified, emphasizing the differences that may occur from one implementation to another and also providing clear, detailed and error free examples that illustrate the aspects being discussed.
   
   Also, the text is very well-written and I've found only 3 typos. Very impressive! Apress is also doing a wonderful job.
   
   Chapter 1 introduces MMAPI and presents its features and requirements as defined by the JCP - Java Community Process, compares MMAPI and the MIDP 2.0 Media subset, where it fits regarding the JME Software stack and at last it lists the manufactures and market players supporting MMAPI.
   Nice introduction!
   
   Chapter 2 explains the MMAPI Architecture, the main high-level interfaces, delivers an introduction to the supported protocols and content types, presents the relevant feature sets and the security issues one must take into consideration. It also details the MIDP 2.0 Media subset so that one can understand what's left out on devices implementing it.
   
   Chapter 3 introduces the reader to MMAPI hands-on programming by explaining two simple MIDlets. It also builds the foundation regarding the overall development process and environment.
   
   Chapter 4 is unique, it details the Media Player lifecycle, its possible states and transitions. It explains each state very thoroughly as well as Player events and how to work with them, even the limitations and issues regarding custom events. I've never read a book covering MMAPI with such a detailed explanation.
   
   Chapter 5 covers all the issues regarding the access of media over networks. It starts with a very clear explanation of Threads in JME as well as the security permissions for media acess over networks. Then it puts it all together in a very clear and easy to follow example.
   
   Chapters 6 and 7 are the best ones in my opinion. Those two chapters do pay the book, definitely.Vikram has been brilliant and desmystified Synthetic Tones and the MIDI protocol. He has remembered me of my of childhood, when I've had musical theory classes as it explains everything music and shows you how that all fits into programming with MMAPI. Those chapters are so complete that they have a lot of tips on how to convert from RTTTL to MMAPI format, the MIDI specification and message format and how to work with MIDI in MMAPI, how to create JTS files and other niceties. Thanks Vikram :)
   
   Chapter 8 explains how to work with Audio and Video, playback, capturing, storing, controlling, mixing, it's everything there. It also describes the details of Media Encodings and Sampled Audio as well as the GUI options for dealing with Video.
   
   Chapter 9 has a very cool Device Blogging application that builds upon all the subjects presented so far and also gives a good example of MVC pattern in JME.
   
   Well, the only criticism I have is regarding the section about Streaming Media and also the Appendix C about the JSR 234 - Advanced Multimedia Supplements. Considering that Vikram has proved he's really a subject matter expert He could have provided better sections about them.
   
   In fact, He has already written an article about Streaming in JME and it's available on his web site (so I forgive him) but AMMS is still to be covered. What about on the second edition of his book? Let's wait and see!
   
   A must have book, absolutely!



4. When I got this book I jumped straight to Chapter 9 viz. "Case Study: Device Blogging". This chapter nicely explains how to write a blogging Midlet for a phone device which includes writing a Blog post, capturing/uploading images to a blog, and capturing/posting audio to a blog. The author explains the MMAPI concepts using the MVC paradigm along with complete source code for client and server side processing of application and interaction logic.
   
   The rest of the book goes deep into the MMAPI architecture and concepts with the help of source code of working applications. The functional Multimedia player example in the 3rd chapter explains the role of various components of MMAPI architecture. A dedicated chapter on Media player lifecycle and events is very helpful in understanding the basic concepts of event handling. The book also covers some of the fundamental concepts behind controlling pitch, tempo, audio mixing with the help of examples.
   
   Chapter 7 is dedicated to the MIDI specification which is very comprehensive and well explained within the context of JavaME framework. Writing a book like this requires a thorough knowledge of both JavaME and the various subtleties of tone, pitch, sequencing, octaves, frequency, audio conversion and their treatment on the device and at the network level. In my opinion the author has done a great job.
   
   All in all this book is a great resource if you are planning to develop the next Mobile video sharing, photo sharing application or your next multi-media player for a Mobile phone.



5. I have a litte doubt and try to solve my problems talking with the writer email showed in the book, but I never received a anwser...

5 comments about Pro Apache Beehive (Expert's Voice in Java).

1. I have been using beehive since it was in alpha, but, I still found some parts of this book informative, enough to where I may have to change one of my applications, to make it better.
   
   I did find that there was too much talk about BEAs product, but, for those that may be coming from that framework to beehive, this may be important.
   
   Understanding how to use the various development tools, such as Pollinate, is useful, so their coverage of that is reasonable.
   
   I do think that if you are looking for an intro to intermediate book on beehive this is a fantastic book.



2. I am a seasoned WebLogic developer and this book allowed me to get up to speed with Beehive quickly. I was able to get the examples to work - but just had to make sure I use the version of Beehive that this book was written against.



3. I was quite impressed with the way this book was presented. While there were some sections that weren't quite right for me, overall the introduction sections and lead up, examples and prose all hit the spot and as such it was an enjoyable book to read.
   
   The book provides a "from the ground and upwards" introduction to Beehive so it does not require any prior knowledge to get started. This isn't too surprising for a framework with a comparatively smaller user base. It also has a very nice introduction to the available Beehive tools so that you can start working efficiently.
   
   While it is not approached as a Beehive marketing exercise (and this was a relief), I was a little confused between the BEA and Beehive offerings in the earlier sections. Maybe it is of worth for people moving to Beehive, but at the point where you're still confused about the starting concepts I found it a bit distracting.
   
   While I wasn't a complete fan of the framework itself, the instructions and examples provided make this a very useful book if you intend to give Apache Beehive a go yourself.



4. In general I was very disappointed with this book. The coverage of the Beehive toolset is disorganized and shallow. In many cases the authors simply copy text and diagrams from the Beehive online documentation. In fact, while covering the NetUI tags on page 59 they offer the following rational:
   
   "Note: The reason I've simply cut and paste [sic] the information from the Javadocs is because, at the time of writing this book, Apache Beehive is still in beta stage. Therefore, some of these methods might change."
   
   Got that? The documentation might change so we'll just copy it verbatium and stick it in the book. In the end it is probably a good thing because if the authors had just provided a URL to the documentation it would have been out of date by the time this book hit the streets.
   
   In point of fact, dispite being published less than six months ago, much has changed and this book is hopelessly out of date in many respects. For example:
   
   o The Eclipse Pollinate project, which all the books examples are based upon, is now in archived state. This means the project has reached the end of its life. No work is being done and the Eclipse update site is no longer active. As a result the only GUI tooling being offered for Beehive is a commercial product from BEA.
   
   o Most of the URLs listed in the book for resources are no longer functional. Try to find all the sample controls discussed at http://www.controlhaus.com.
   
   Surprisingly the bright spot of this entire book is the coverage of XMLBeans. I found the discussion lucid, understandable, and educational. Still, it's hard for me to justify the purchase of this book based on this 20 page chapter.
   
   In all I would recommend against purchasing this book. If you are interested in learning Beehive the documentation available on the Apache site is far superior and much more up to date.



5. This is not a bad book like some of the reviewers have pointed out. The explanations are simple, easy to understand and overall quite clear. The technology itself is very young, so I can see why there is not more depth to the book - but if you are interested in Beehive, this book is a good place to start.

5 comments about JSTL in Action.

1. Review
   One way to develop dynamic page content on a web application is to use JavaServer Pages technology. This allows you to embed bits of Java code, or scriptlets, within the HTML page. The web server interprets the scriptlet when the page is called and produces the content that is coded. This is all good, but there are common tasks (such as looping) that each developer had to reinvent from scratch each time it was used in a page. To prevent this repetitive coding, a common set of JSP tags were created to allow developers to concentrate on business logic instead of coding structures. This creation is known as the JSP Standard Tag Library (JSTL). That's what this book is all about...

   The book starts with an examination of how JSP and XML tags come together to form the basis of JSTL. This is followed by a number of chapters that cover the different tags that are used to control branching, flow, text formatting, and other various structures. After the basics of JSTL, the author looks at a number of common tasks encountered by JSP developers and how they would be coded using JSTL. Finally, the book wraps up with reference data needed on a regular basis as you use JSTL, such as the API.

   The writing is clear and concise, with an abundance of diagrams and code to illustrate the points. The mix of reference, tutorial, and practical examples is perfect, and every developer will be able to use this book in a number of situations.

   Websphere developers (both web application and portlet development) will get the most out of this book when it comes to the IBM/Lotus world. The use of JSTL will reduce the code complexity of your JSP pages and speed up your development efforts.

   Conclusion
   If you are developing JSP pages and haven't looked into the use of the JSTL area, get this book. It will save you time and effort in your coding, and you'll be glad you did.




2. This is a good book to learn about how to use JSTL. It has an excellent reference section, and the body of the book explains how to use the JSTL tags with many good example. On the whole, a very useful, readable book. One negative: The author has a sense of humor which some might find odd, and he interjects it throughout the book; at times it's distracting. But if you can get past that, you'll find this to be a good resource.



3. This book was very helpful for getting up to speed on JSTL. My company is about to kick off a new struts project, so we needed to get up so speed on using JSTL with Struts. There wasn't much coverage on this, but overall the book was good.



4. I have not read the book, nor do I plan to. But I do know that Shawn Bayern is the shiznit. Can anyone deny his caustic, "adult" wit? One look at the sultry wench on the cover will inform you of all you need to know if its contents.
   
   Huzzah!



5. It's hard to describe with mere words how incredible this book on JSTL is. Truly Shawn Bayern is the second coming of our Lord and Savior, Jesus Christ.
   
   While this book is great in helping people to learn about JSTL, it's also the latest testament of the Son of Man. Mr. Bayern's writing is excellent, and it so happens that it will be he who leads his flock to glory after the apocalypse.
   
   Those of us who purchase his book will find salvation. The others will be left below.

5 comments about Java Outside In.

1. Total garbage. The worst book I have ever encountered. I am taking (and dropping) a course called 'Introduction to Java Programming'. This POS was inflicted on the class. Our assignmnents are all from the book, so we not only have to try to figure Java out from the minimal explanations in the book, we also have to read Bolker's crappy code. This book just cost me $700. I'm dropping, yet I'd probably get an A if I continued on for 6 more weeks. I just can't take one more page of this miserable excuse for a textbook.

   Bolker, and his lacky Campbell (who, on his website, states that he can't see why anyone would use languages like C++ when there's SmallTalk. This guy's teaching?), start off with this big program, and, as another reviewer stated, tell you not to worry about the details. Huh? However, I disagree with that reviewer. I think it does go downhill from there.

   The reviewer from Boston who gives a glowing review and five stars: Oh, puhleassse, Ethan, reviewing your own book? No one using this book for a primary text, or a reference for that matter, would give it more than one star (if only there were no stars). This is by far the worst text book I've ever encountered.

   This is Bolker's exercise in pedagogic experimentation and theory. Bolker's theory (he states this) is that the two best ways to learn to program are by:

   1) Having a big program full of things that students have never seen thrown at them and they will somehow be able to read the program and all of a sudden go "Aha, I understand Java now).

   2) Reading well written code. (A little arrogant, aren't we, Bolker?) Bolker's idea is that you just read his code for hours and you'll become a great programmer. Sorry, fool, the best way to learn to code is to code.

   Oh, I forgot his journal concept. Those of us who've had the extreme misfortune to be taught using the Bolker method (I'm NOT taking the course at UMass Boston, BTW) also are required to keep a journal. We spend a couple of hours a week writing about our experiences using Bolker's executable programs: "I input a negative when asked for a positive and this is what happened:" Asinine.

   This book is equally horrible as an Intro to Java textbook, a teach yourself book, and as a reference book. It doesn't give enough explanation nor examples to be a good textbook, it would be impossible to teach oneself Java from it, and there is just not enough coverage and too much babble to be useful as a reference. Totally useless crap.

   Again, Bolker has this (incorrect) pedagogic theory and this book is the result. Theory is where it should have remained.




2. This is another great book to learn java. It has lots of real world examples and has a nice approach right from the begining. It is a little hard at the begining but I suppose thats how any new language would seem to a beginer. I propose for the second edition instead of that big Bank program, at the begining, there might be a test that evaluates wether you have the talent to be a programer or not.



3. I have been to Bolker's class at UMASS Boston and experienced the worst presentation of Java I have ever seen. The exact wording was, "You will learn a lot of Java in very little time." A promise never kept. You spend 20 hours a week not knowing what to do with HIS code for many reasons that I do not care to detail here. You never write code of your own making. You spend 5 of those hours writing a diary which isn't Java. The book itself is NOT an adequate reference for this language. In my opinion the man is due to retire. What I wanted to say is DON'T PURCHASE THIS BOOK to learn Java. Most if not all of the book is a presentation of a few small programs written in Java designed for classroom lectures. It is not a presentation of the Java Programming Language.



4. I am a junior majoring in Computer Science and Math and still find Java Outside as a great source to learn and review Java knowlege.
   
   For beginners, do not let the first chapter scare you since it has some more complicated programs. Instead, you should get excited and see what Java can do in day-to-day life, and what you can do with Java. I got rather excited because those are real examples rather than those that are vague and discrete.
   
   Starting Chapter 2, the authors speak in details for some of the most basic Java elements. The excercise were also helpful as a review source after reading each chapter.
   
   Prof. Ethan also emphasized on learning strategies which you wouldn't find anywhere else. To learn Java, you should always keep a journal of what you learned, what you are confused about, and what you did in order to understand it. I have implement this method to many other subjects.
   
   The authors really put their hearts into writing this book. I can sense how much they love this subject and how hard they try to make sure the readers understand and love what they are learning.



5. I took CS110 at UMASS with Professor Campbell. I have also taken classes with E. Bolker. Now, about this text -
   
   The text IS useful assuming that you as a student want to take the time to understand the Java concepts presented. Yes, the way Java is presented is different from traditional teachings. If you're the type of learner that needs everything spoon fed to you then this is not the book OR class for you.
   
   The learning method used assumes that those that are doing the learning are going to take the TIME needed to absorb the materials and concepts in the book. If you are willing to make the time commitment necessary to do that, you will find the book and the class an enriching experience.
   
   I am sure that those who have complained about the book are the same people that are taking classes in college looking for easy "A" grades, and are not looking to actually LEARN the presented material.

5 comments about J2EE & Java: Developing Secure Web Applications with Java Technology (Hacking Exposed).

1. This is one of the best books I've read on J2EE security. The recommendations in this book improved my exisiting production applications and development designs.



2. The book uses an example Java application which is intially very unsecure, and throughout the book the vulnerabilities of the example are discussed and countermeasures are written. Then the application is webenabled, creating new vulnerabilities which are fixed again, and so on. This way the complex material is covered in an easy accessible yet comprehensive way, without becoming lengthy. This book is a must have for any serious Java web developer interested in application security. Not recommended for beginners, though.



3. If this book had been titled differently, I would have had no
   reason for complaint: it gives a good introduction to Java
   Security, and how to deploy it in various forms.
   
   But it *is* titled 'Hacking Exposed'. That is now taken
   to be an indication of a particular approach to security,
   ... The blurb acknowledges it: 'The proven Hacking Exposed
   methodology' is the first thing mentioned under 'What You Learn'.
   
   And I bought this title without second thought -- I have
   nothing but praise for the previous books, and expected
   to find the same approach and the same quality here.
   
   In this book you find a lot of information on prevention, but
   very little on actual vulnerabilities. As a result the
   message is far less urgent. If I can demonstrate a 'hack'
   the message gets across very quickly: we have to do something
   about it now. But if all I can do is point to a text that
   says 'attackers can potentially attach a debugger to our
   application and watch the code as it runs', urgency is gone.
   
   There's another point there as well: 'our application'.
   Those words probably sum up the difference from, say, 'Hacking
   Exposed Web Applications'. This book is not from the point of
   view of the hacker that the previous books used so well to get
   their message across. This is 'we', protecting our assets from
   a considerably more nebulous hacker than has appeared earlier.
   
   The difference is the same as between an actual security
   incident on one hand, and the report of a threat analysis on
   the other.
   
   In short, this is not a Hacking Exposed book. It's a Java
   Security Exposed book. As such it probably merits four stars.
   
   But ... as it is marketed as a Hacking Exposed book, and,
   in my opinion, doesn't live up to the expectations that goes
   with that trademark, I'm afraid I can't give any rating at all.
   (1 star seems to be the lowest possible, so that is what I give it.)
   
   I'll be very careful about purchasing the next red book
   with "Hacking Exposed" all over the front cover. I just
   might find that I have bought 'Hacking Exposed - ISO 17799'.



4. This is a very good book on java security that starts pretty much from the ground up so you have to know much about security to read it. The first part of the book starts out with
   some of the java security basics (classloading, protection domains, etc.) and then goes through the JAAS, JCE, and JSSE modules.

   The second part of the book goes through how to use security in stand alone java applications and what pitfalls you need to watch out for. The book also details where security is lacking or not mature and what the alternative are.

   The third section of the book goes through security in the J2EE environment and where the J2EE containers can help out the developers by doing most of the work for them.

   Overall this book provides a very good overview of security in all the java environments while not requiring previous security knowledge. I highly recommend it.




5. This book has some nice examples and is fairly complete, but some sections are basically a regurgitation of the java.sun web site!
   In many technical books, it is common to find multiple authors, each writing a section based upon his/her expertise. Since each author has a specific writing style and personality, there is usually a person (or persons) charged with proofing and approving the sections as well as working to make the transitions seamless and consistent. This book was written by three different authors and it would appear to me that at least one of the authors turned in work that is remarkably similar to existing sources!

   Here is a sample of the JCE section in HackingExposed:
   "The Java Cryptography Extension (JCE) package provides a framework for encryption and decryption, key generation, key agreement, and MAC. Encryption allows symmetric, asymmetric, block, and stream ciphers, with additional support for secure streams and sealed objects."
   Now here is the verbage from the java.sun.com website:
   "The JavaTM Cryptography Extension (JCE) provides a framework and implementations for encryption, key generation and key agreement, and Message Authentication Code (MAC) algorithms. Support for encryption includes symmetric, asymmetric, block, and stream ciphers. The software also supports secure streams and sealed objects."
   

   To be fair, it appears that the problems are confined to the first section of the book. The final 2/3 of the book are closer to what I expect from the Hacking Exposed series.

3 comments about Web Content Mining with Java.

1. This book is a little gem packed full of ideas. For people who don't want the overhead of big enterprise solutions like web services, the techniques and code are lightweight and easy. Even as someone who has worked with Web mining before, I found a lot of helpful tips that I have put to good use.



2. I bought this book on the recommendation of javaranch.com. The review was right on, and I couldn't be happier that I took the advice. The code for servelets and applets supplied by Loton provides instant and hands on help to get and use information from the Web. It is the perfect Web mining guide.



3. This book may not seem an obvious choice for many readers. It's not about a particular API, certification, or other buzzword topic, and the title can sound dry and academic. Don't be put off! This is a practical, hands-on book which can take your software straight past the hype of web services and into using the resources of the whole internet in your programs right now. With no big middleware downloads, protocol specs, or head-scratching config files.

   The book walks you through how to read, control and extract information from existing web pages and web applications anywhere on the internet, how to read, send and process emails and newsgroup postings, how to recognise just the text or data you want, and much more. Source code is given for servlets and applets to examine and drive web forms, and usage examples include sending SMS messages and applying decision-making rules to internet share-price data. It's also full of ideas and suggestions to make you want to leap up and get started.

   When I got this book, I couldn't put it down. A lot of computer books sit on the shelf or send me to sleep, but not this one. Not only is it both topical and useful, but it hits a just-about-ideal balance between code and food for thought. The author has a real knack for useful solutions to complex problems.

1 comments about Starting Out with Java 5: Early Objects (Gaddis Series).

1. This is one of the better programming texts I have read, and it clearly and concisely breaks down difficult object oriented concepts and gives applicable examples. I would recommend this for anyone looking for a quick crash course in Java, or as an instructional text.

5 comments about Java Management Extensions.

1. Java Management Extensions by Java expert J. Steven Perry is a superbly organized and written reference and instructional resource to managing Java applications with JMX. Individual chapters address standard, dynamic, model, and open MBeans, dynamic loading, the monitoring class and timer service, and much more. A practical study of JMX architecture as well as a thoroughly "user friendly" how-to guide for technical managers, Java Management Extensions is an exceptionally useful and straightforward manual.



2. This book covers the fundamentals of JMX but where I was disappointed was that it uses a pretty basic queue example and doesn't really get into J2EE applications and praticle uses. I was left wondering when to use it. If I had it to do over I'd choose another book with more praticle applications for JMX.



3. JMX is a Java framework for managing enterprise applications in a distributed environment. The book Java Management Extensions takes the reader from a high-level mountaintop description of what JMX is in the first chapter, aimed at architects and management, who might be investigating the new technology, to a trench-digging description of how to expose a class for management through instrumenting an MBean.

   Perry's initial description of the JMX architecture in the first chapter does a good job describing the parts of the JMX and how they interoperate. It is a very high-level view of JMX and many abstract ideas are presented. On a personal level, my experience with the JBoss application server gave me a concrete example to refer to during this JMX introduction, which helped. Here, the reader is presented with many UML diagrams to illustrate the architecture.

   The next four chapters cover the nuts and bolts of how to construct JMX services. To use the JMX framework, a developer must become familiar with an object called an MBean. In a nutshell, MBeans are Java classes that implement an MBean interface (A process known as instrumenting), allowing the MBeans to be loaded into an MBean server and managed. In these chapters, Perry talks about four types of Mbeans, Standard, Dynamic, Model, and Open MBeans. After introducing each type of MBean, Perry gives simple code examples of how to build each type of MBean.
   
   Chapter 6 deals primarily with introducing the reader to the MBean server. Perry uses the reference implementation from Sun for the examples in his book. Real world MBean servers include names such as JBoss and WebLogic. The most exciting part of the book, I felt were chapters 7 and 9, where Perry talks about the JMX notification model and Monitoring classes. Firing events, filtering notifications, and creating monitors appear to be the real advantages to the JMX framework and are covered thoroughly in these chapters.

   Perry's no-nonsense writing style provides a succinct description of the architecture. At 312 pages, the book is the thinnest technical book on my bookshelf, making the read easier to manage.

   In summary, Java Management Extensions is a good book for developers who want to gain an understanding of what JMX is. Programmers new to JMX will probably find the first part of the book a good introduction to JMX and its architecture, while the last chapters focus more on how to put the framework to good use. Although Perry does not have a style of writing that entertained me, it was clear and to the point. He does cover his information thoroughly and appears to know the content well. JMX is a technology that I feel will be used heavily in the future, and for anyone who is intending to write a J2EE application that needs management or monitoring, JMX appears to be the answer.




4. It has been 4 years since this book came out. Despite the many high hopes in the computer industry in 2002, JMX has run out of conceptual steam. You can't tell that from the text. But since then, Service Oriented Architecture and Web Services have garnered far more mindshare.
   
   The text also does not indicate that JMX simply proved too hard in practice, as a useful management tool or console. If you read the book and try its recommendations, you are walking into a dead end. There will be very little interest by others in what you program.



5. If you're looking for an introduction to JMX, this book gives good coverage of the concepts and techniques behind instrumenting your applications. However, if you're looking for information on the latest and greatest in JMX, especially anything related to JMX remoting, then you should look somewhere else. This book was written in 2002, before J2SE 5.0, and a lot has happened to JMX since then. Starting with J2SE 5.0, JMX is a core part of the Java standard library and the JDK ships with a highly usable remote management application called jconsole.