2 comments about Agile Software Construction.

1. The book takes far too favourable a view of Extreme Programming [XP]. It ignores increasing results from industry about the brittleness of XP. You would benefit more by looking up "Extreme Programming Refactored: The Case Against XP" by Stephens and Rosenberg. It goes into gory details about actual XP attempts, including the famous initial one at Chrysler.
   
   Which is not to say that Hunt's book is entirely wrong. Parts of it, like the need for unit testing, are not bad at all. It should be adopted in many projects. And the waterfall approach does have severe problems. But you can buy into agile programming without necessarily going to the extreme of XP.



2. This book ostensibly focuses on "emerging methods and approaches that are loosely described as Agile and shows how to apply them effectively...." Topics covered include Agile Modeling, Extreme Programming, Feature Driven Development, Agile Methods with RUP and PRINCE2. The author's a Brit (hence the reference to PRINCE2, pretty much unknown outside the UK). There's an overwhelming emphasis on Agile Modeling and XP and, although the books introduction states that it "....brings together a range of the most popular Agile Methods," Scrum, probably the second most popular Agile approach along with XP, receives only around one page and half a dozen cursory references.
   
   While the author emphasizes XP heavily, there is very little attempt to examine the limitations of XP. The coverage of Agile Modeling is pretty lightweight and it's not really a "how to effectiely use Agile" book either. Overall, my assessment is this is pretty lightweight, not especially usefuland there's better books out there that focus on how to introduce and use Agile effectively. There's also better "overview" books out there with a more inclusive coverage of Agile Processes and Approaches for those who want an introduction. And for non-UK reader, the PRINCE2 coverage is pretty much irrelevant.
   
   Not worth your time. Wasn't worth mine either but I'd already spent it so I thought the least I could do is spare others the pain. Sorry John. Better luck with the next one.

No comments about Java 6 VTC Training CD.

5 comments about Programming and Deploying Java(TM) Mobile Agents with Aglets(TM).

1. The content covered in this book is both extremely useful and well written. The basics of mobile agents and why you would want to use them, the security issues involved and the fundamental issues facing someone wishing to implement their own system using Aglets are all examined. The code examples are all easy to follow, gradually grow more complex and demonstrate the power of the Aglets package. The latter part of the book covers more advanced topics such as design patterns found in mobile agent based applications and an in depth look at the Aglet Framework, the underlying structure behind the programmers Aglet API.

   If you are currently, or are thinking, about doing anything with aglets then this book is a MUST read. Even battle hardened agleteers can learn the best way to build and optimise their aglets.

   If you simple want to find out more about mobile agents and see them working within a successful framework then this book is also for you.





2. The book is an excellent read. When I started the book, I knew every little about Agents. By the time, I was done I knew much more. The writing is extremely clear, interesting and understandable. Unlike many of the Agent fanatics, Lange and Oshima carefully explain the problems with Agent technology as it stands today.

   All of this translates into a book that is useful to read even if you do not care about the Aglet technology. It is a good book for anyone who wants to understand the state of the art of Agents and see how one particular Agent implementation works.




3. This is a great book about an exciting technology. The concepts are presented in a clear and concise manner. Unlike many computer-related books, it is not at all repetitive and doesn't dwell on minor issues. The programming examples are reasonable.



4. The IBM Aglets Software Development Kit is, to me, the most promising leap to intelligent and mobile application development yet. I applaud the research and development by IBM, Danny B. Lange, and Mitsuru Oshima.

   But this book creates more questions than answers, and with IBM's lack of current up-to-date documentation, I cannot see the java developer community embracing this NOW as the next logical java leap; which I think it is.

   My initial excitement waned after I purchased this book. Many of the examples did not work. Written to the JDK 1.1.5, no comparison/contrast with ASDK 1.0.3 and 1.1.b2 is mentioned. Furthermore, the Tahiti server (Aglet Environment) is not even explored. To me this is a fatal oversight because an aglet cannot exist without an environment. That environment at least initially is Tahiti which comes with the ASDK the book mentions.

   In short, this work is excellent in concept and poor in real-world implementation. The authors should work on a second edition. Is it worth buying? Easy. For understanding the Java Aglet concept, yes. Implementation, no.




5. This book falls short in terms of its coding examples, none which worked. The book presents the coding examples in a very confusing manner. There are some errors in the book (particularly in the usage of URL on page 48, for example). The "dispatch" context is no where to be found in any of the aglet jar files I downloaded from their website. The programming examples are not explained very well and there is no discussion of what code goes with what in order to execute the mobile code correctly. As I examine the code and attempt to use it, I get the impression that the authors didn't check to see if the code worked properly. This book is a total waste of money, and my advice to the authors is to take there time and re-write the book to make sure that the code works properly, discuss specifically what "jar" files are needed for the classes used in the book, and to explain in a more thorough way with their code examples how to construct mobile agents. Also, the authors need to provide a website to download the code examples as opposed to forcing the readers to write the code from scratch. This method of obtaining code has become a standard for all the books I've bought, and saves time and effort, and allows the reader to think about how the code is working. In general, I was very frustrated with the examples in the book, none which were consistent with the aglet jar files I downloaded from the Tokyo IBM website. I hope another addition is in the works.

5 comments about Hello World(s) -- From Code to Culture: A 10 Year Celebration of Java Technology.

1. You know you're a geek when your coffee table books feature programming languages... Hello World(s)! - From Code to Culture: A 10 Year Celebration of Java Technology.
   
   Contents: The World of Possibilities; The World of Choice; The World of Curiosity; The World of Community; The World of Adoption; The World of Inevitability; The World of Today; The World of Tomorrow
   
   I had a real hard time trying to figure out how to frame this book. From a visual perspective, it's very nice. Heavy page stock, colorful graphics, and unique page layout. On the other hand, after you've spent 30 minutes reading through the approximately 100 pages, you'll wonder what you should do with the book now. Then I noticed the "author"... Sun Microsystems. This is one of those coffee table books produced by the company who owns the subject matter, and it's the type of book you can give to clients and other tech geeks who are part of the Java movement. Given that framing, I understand its function and am inclined to cut it a bit more slack in terms of reviewer rating.
   
   There's nothing in here that you probably haven't already heard in other books on Java. Granted, this style of book allows for more color and background as to what was going on at the time, and what some of the players were thinking during crucial moments in Java's history. I enjoyed reading it, but I was a bit surprised that all the "historical" material that revolved around dates seemed to end at 1999 or so. I almost felt like this was a dot.com era book that finally made it off someone's pet project list after three or four years, but that wasn't updated with more current events.
   
   So, do you run out and buy this book? Depends... If someone *gives* you a copy, by all means take it and enjoy. Heck, stick it on your coffee table with pride (after you move the pizza boxes off). But if you're looking for in-depth analysis and historical perspective on Java, you'll likely end up walking away feeling less than satisfied...



2. Scary that a ten year anniversary of Java is already upon us. To celebrate, Sun put forth this book, which walks us through the short and tumultuous history. It describes how Java grew from ideas in the early 90s, which were inspired by Sun's longstanding slogan, "the network is the computer". And which predates the Web.
   
   Indeed, the book shows at a nontechnical level how Java has largely delivered on this promise. More so than any other alternative. However, the book is rather sparse on technical details. Or even about the personalities like Joy and Gosling. It is a coffeetable book. Rendered somewhat bland because Sun itself put it out. Sure, the text has all sorts of free flowing and casual phrases. But there is very little of substantive details. Not just about the technical aspects.
   
   What we still need is a book that goes into far more detail about how we went from Oak to Java. It need not necessarily have to have a lot of programming level information. But it should also give insight into the key players. Along with commentary on how Java has actually and ironically delivered little in significant tangible revenue to Sun. Though, to be sure, it has helped give Sun immense mindshare in the programming crowd. That book would need to be written by someone independent of Sun.



3. "Hello Worlds" celebrates Java turning 10. With special paper and pictures galore, the book walks through the history of Java.
   
   This is not a technical book and reads like the story it is. Cute anecdotes are included from the programming language's conception to launch to present day. There's even a post-it note with how the name Java was picked. And of course, Duke - the Java mascot - is in there.
   
   The book takes less than an hour to read, but makes a nice commemorative item. It also makes a great holiday stocking stuffer in the $20 range. I know I enjoyed reading about the origins of Java.



4. This is a nicely produced coffeetable book that sets out the ten years of Java from a concept of how household devices might be controlled to where it is today - such as on a whole lot of cellphones for example. The book is not a technical one. Instead it is a celebration of the language with large color photos, good graphics, and the tale of how Java happened. There are the stories of the "Oak" and "Green" days, how the basic premise of Java as a language for controlling consumer devices had to be scrapped and started over, and then how the Internet finally gave the language that "big break" and the purpose it had been looking for.
   
   The book takes you to the splitting of Java into three targeted platforms, and to where we are today, which is Java Everywhere: Phones, smart cards, PC's, the Internet. There are also lots of pretty interesting tidbits of information. Lots of it I knew, but there are quite a few odds and ends I did not know. For example, this book tells you what names for the language preceded Java, and why Java was ultimately the name that stuck.
   
   This being a book by Sun intended to celebrate Java's tenth birthday, there's not much in here about what bothers people about the language. For example, don't expect discussions on the problems caused by the language carrying its Virtual Machine wherever it goes, and that Java's "write once run everywhere" GUI's can often turn into "write once, debug everywhere" GUI's. However, there's no denying that this language has been and can be downright fun to use - no PR-based coffeetable book could invent that fact out of thin air. Also, it is much easier to use than C++ even if they are suited for different types of tasks.
   
   At any rate, reading this book has resulted in some serious flashbacks for me anyway, since I've been using the language from the beginning. This is a pretty light but interesting book that will get you remembering and thinking about Java's progress over the years, which is probably the reason Sun produced it in the first place.



5. I was looking for an intro to Java - what is it all about, why does it work everywhere but all of the books I scanned were very specialized programming books - seems odd that this is the only intro book but it is!
   Beautiful book with great pictures and history - quick read but you will understand what why it is on everything from phones to mainframe computers.
   cheers, lee

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.

4 comments about J2ME Games With MIDP2.

1. Recently, on buses and trains, I've noticed people using cellphones to play games. On these dinky little screens, with a keypad instead of a keyboard, and with tinny audio. But even having all these constraints, such games have their attraction.

   This should be the draw to you, to program one of these mobile devices. If the hardware runs Java, then, as Hamer explains, J2ME is used. She describes how Sun stripped out a lot of Java classes, to arrive at a minimal subset that is aware of the severe constraints you face. Limited power. Small screen. Small memory. Intermittant and low bandwidth. No mouse. No keyboard. Get the picture?

   Yet even under all these limitations, Hamer shows how you can use J2ME and version 2 of MIDP to construct cool games. In many ways, it is harder than writing for a desktop or laptop or game console. But the best attitude is to regard this as a challenge of your ingenuity. Perhaps using this book, you will be the author of the next Tetris.

   I'm only half joking when I say this. Because there is something about this field that I don't think Hamer explicitly points out. If you go through the book, you should come to the conclusion that you can code an entire game by yourself. Realistically, this is no longer true for games on the other platforms. These are now storyboarded and written by a team of programmers, with often a million dollar budget. With J2ME and this book, you can still do it all.




2. I really enjoyed this book. The author does a solid job of explaining everything you need to know to write games for MIDP devices. If you are familiar with Jonathan Knudsen's book on J2ME (probably the best book on the subject), this book expands the single games chapter into a fun and interesting book.
   
   The book starts with a quick sample showing us how to use the Sun IDE and how to run our games on the emulator and how to download our games to a phone. The author shows a couple of example games, a maze and a jumping game, that give a good overview of the basic techniques games use on MIDP devices. She then expands those examples by showing proper use of threads and shows how to play tones and music during a game. Storing information (such as high scores or user preferences) is demonstrated. Downloading game enhancements such as new levels for a dungeon game are also demonstrated. The book is full of well-commented code samples (worth stealing) that show the techniques being discussed.
   
   The author of this book has a nice, easy to read style of writing. Her enthusiasm for the topic comes through and makes you want to try the many sample games. If you have been spending too much time on enterprise programming then playing around with some MIDP games might be just the antidote and this book will get you started on the fun.



3. This the the right title for this book. It is basically a review of the code of a few simple games (like a cowboy jumping tumbleweeds, or a simple 2d maze) with very little space devoted to theory and explanations.. both of the APIs and of the internal logic and algorithms. Not that this book isn't useful.. it is but you have to wade through a lot of code, and I think the author could have done a much better job if for example she had taken the time to EXPLAIN the maze generation algorithms instead of just saying "look at the code". In short, more time and effort on the author's side, less on the reader.. and I think this book was written in very little time and with very little effort.



4. I really wanted to like this book, but it turned out to be just a collection of very long code fragments with no annotation and little explanation. There is a great topic here, and there are some good ideas, but the knowledge is locked in the code.
   
   If you are the type of person that learns by reading code then you will already have learned the APIs by looking at the sample code. The reason we buy technical books is to teach us how to use the APIs through a combination of well annotated example code, well organized reference material for the APIs, and illustrations that demonstrate best practice code flow. This book only has the code and a little explanation, the reference material, and effective illustrations are missing.
   
   I recommend this book only if you can't find any other material on MIDP2.

5 comments about AJAX and Flash Development with OpenLaszlo: A Tutorial (A Tutorial series).

1. The online documentation for openlaszo is very good, especially the interactive examples, where you can try out what you just learnt. I spent quite some time reading tutorials and writing some of my own laszlo code.
   
   The reason I bought this book, is because I expected to get a deeper understanding on openlaszlo, and an easier to follow description of more advanced concepts, than the one provided on the online documentation.
   
   I got the book about an hour ago, I browsed thru it, but I have to say I am disappointed: off the 300+ pages about a half are API's, which you can get online easily. The page numbers on the Table of contents are messed up: All references from Chap 11 thru the index are page 197 ! (Please next time: somebody look at the table of contents before printing the book !
   
   If you did not look into openlaszo yet, and you are just interested in how you can make great looking UI's using open source technologies, I still think this book is worth reading, but if you already spend a fair amount reading thru the online docu, this book is probably not for you.
   
   Actually, the book says it is a tutorial .. probably I just need to wait for a reference book, so I still give it three stars.



2. I ordered this book using 2nd day shipping. I need to evaluate whether openlaszlo is a replacement for flex. I am not expecting a lot except that I can get a little bit more than the online documentation.
   
   The books is just a reprint of online documentation. Each chapter just reprints the tag/attributes/methods. The examples the author gives are so simple that they don't teach me anything more than the documentation.
   
   Then finally comes the last chapter that teaches how to integrate google map. The author thanks to Manabu Togawa for allowing him to reprint it on the book. He did just reprint the code and didn't give any explanation of the code.
   
   The only thing intuitive I found in this book is the appendix A: Introduction to XML and appendix B:Introduction to JavaScript. If you don't know these two, you may want to buy this book?
   
   I doubt that author has done anything in OpenLaszlo himself.



3. The online documentation for Laszlo is pretty good, and has the advantage of interactive examples. But there are a huge number of tricks and undocumented details that can be very frustrating to figure out. My hope was that this book would help in those areas. Unfortunately this was not the case.
   
   As others have mentioned, this book is just a rewrite of the online reference manual, and not a very good one at that. In most cases the online docs are more complete and easier to follow. The "A Tutorial" subtitle is not accurate, as the book is almost entirely reference material. Only the two pretty good appendixes on XML and JavaScript basics are anything resembling a tutorial.
   
   Unfortunately, errors in the book make it more of a liability than an advantage to own this book. The inaccurate contents, index, and typesetting errors are mostly just annoying, but it is shocking a publisher would let such blantant errors get through. Far more problematic for a professional programmer are the errors in the content. We thought we had actually found some valuable information in the book regarding working with data, that was not in the online documentation. After wasting a day of programming, we discovered the reason the feature wasn't in the online docs is that it was never in Laszlo to start with.
   
   I strongly recommend sticking with the online documentation, user forums, etc. and not bother with this book.



4. First off, this book wasn't put together well at all. What I mean by that is the index and Table of Contents page numbers rarely match. How this got past the publishers is beyond me but it makes this book really difficult to use as a reference. I bought this book in hopes for more of a tutorial than what was available online but alas it's mostly a reiteration and provides very little value. If you can get over the fact that the page numbers don't match the TOC and index then it's a decent reference but really no better than the docs that come in the openlaszlo.war and at least those links work ;).



5. What I am looking for is how openlaszlo integrated with Ajax.
   
   And ajax is in the title of this book.
   
   But after I got the book, it just metioned what is ajax (I know that very well) . There is nothing about AJAX in openLaszlo( I am eager to know).
   
   What in it is all about the tag description from openlaszlo.
   
   I felt that I was misleaded and lied by the auther.

5 comments about Essential Java 2 fast: How to develop applications and applets with Java 2 (Essential Series).

1. I've read a number of begining java book and this one is definitly the best to start with. Other "introductory" programming books have a tendancy to throw out too much infomation all at once and give conveluded descriptions of the basics. This book gives excellent examples of the basics of java and object oriented programming. It covers more effectively in just over 200 pages than books 3 times its size. There are many aspects to this language that are specific and can be learned elsewhere but for the beginner to java this is the one you definitly want to start with.



2. I can only now after reading about three books on Java give this book a fair review. I gave it three stars primarily because right on the front cover it say applications and applets, yet this book is more than 90% devoted to applets. After reading a few books on Java I have found applets to be completely useless. The book is clear and well written and if you want to learn applets it is great. Also I would not recommend this book to any one that has absolutely no knowledge about Java. The title of the book says fast and it isn't lying. The author explains one topic and immediately moves to the next.



3. After reading a few Java books, I've found this book to be effective in delivering java concepts fast and efficiently. This is NOT a reference book but a book intended for those who'd like a good overall basic knowledge of the language in a few weeks. It's written relatively simply with easy examples relating to real-life objects and not abstract mathematical formulas (some of us are no good at maths). Finally, you will need some idea of OO concepts before tackling this book.



4. If you are a structured programmer (e.g. Pascal or Fortran) and want to make the jump to Java programming, then this is your book. I have bought several other introductory Java books and they are just two thick and tedious at the beginning for someone with programming experience. While several of them have better explanations of the concepts and history of object oriented programming, this book is great for all the good stuff in a short and effecient manner.



5. As a newbie to the Java world, I found the book excellent, especially the "hands on" examples.

   In order to gain the most from the book, one must patiently and devotedly work through the examples that Cowell has given.
   There are a few mistakes within the code, as well as a few missing 'import' statements, but I found this to provide an additional challenge to 'getting' the examples up and running.
   
   Over all, the author's style is excellent as are his descriptions/comments of why he does, what he does.

   Personally, I do not think that one will go wrong with purchasing this book. I have certainly learnt quite a bit.

4 comments about Hacking Java: The Java Professional's Resource Kit.

1. This book delves into some of the tough real world issues you will run into when building a java application, not just an applet with cute animation. I especially liked the CORBA ORB demonstration to deliver real multi-tiered client/server applications in java. In addition to this being a fine book by itself, on the CD-ROM enclosed with Hacking Java, you receive the complete text of another good java book Special Edition Using Java, plus 4 other books AND a "publisher's edition" of Microsoft Visual J++ Java development environment. This book is a great value



2. I really liked this book. It deals with very important topics from basic to quite advanced in a very straightforward manner. I use it all the time.



3. You will not be sorry if you buy this book. The book uses a straightforward approach to some of the complicated as well as simple issues. The book is very well organized, and explanations are very clear. I would not recommend it for the beginners, but even if you are just getting comfortable with Java, this book would be an excellent value. CD that comes with this book is also very helpful.



4. This is an excellent book. There are many topics covered in a straightforward manner that you won't find anywhere else. Many clever solutions - I learned a lot from using this book and I've been programming in Java for a while. One of the few computer books worth the steep price.

5 comments about Borland JBuilder Developer's Guide.

1. I have followed the instructions for the example in Chapter 11 very carefully (twice!!!) and was unable to get the program to run successfully. There is some problem with the jTreeCourses and the CoursesPanel in the jSplitPane, they don't appear on the panel when I run the program.

   I then looked at the code on the CD and found that it was different from the code the book guides the user to generate.

   What a waste of time and money!




2. I was able to use many of the design guidelines in the EJB chapters. I found them useful out-of-the-box. The sample code showed me how to implement it. I would like to see more pattern implementations within this book.



3. I was able to use a couple of the pieces of the code in the project I was working on - thanks it saved me lots of time.



4. The book's stated audience is intermediate to advanced level Java programmers, yet 75 percent of the book is an introductory tutorial on how to write Java applications, not how to use JBuilder. The first 200 pages were JBuilder-specific, well written, and they got me up to speed quickly with using the enterprise edition. The rest of the book was not at all helpful - I bought the book to learn to use JBuilder effectively, and learn some tips and tricks from those who have been using it for some years, not how to use JDBC and IO.

   I also found the section on JBuilder's data-aware components to be severely lacking. JBuilder obviously has a robust toolset, and a quick explanation of two of the provided components was inadequate. The inconsistency in the "In Practice" sections was also disturbing. A product of several authors, but it would have been too easy to notice and solve this problem to be forgiven.

   All that said, the book is well written and organized, hence the 3 star rating. But beware of the stated intended audience and book content before you buy.




5. I have never seen a book which so often would reference a topic or word or idea that it goes on to explain LATER in the book or section. Weird. It does seem comprehensive but not a easy read or anything. I have read better. I am glad, though, that it is NOT JBuilder specific because I am just learning JAVA and it is good to have JAVA information rather than just JBuilder interface information.