5 comments about Java 2 Micro Edition: Professional Developer's Guide.

1. This book is an excellent presentation of the current world of Java in embedded devices with enough detail to get someone started but also not too much of detail to get people confused. It provides a good overview of the problem space of resource restricted operating environments and performance tuning. In a very structured way, the book describes the J2ME specifications and discusses CLDC implementations from Sun (KVM for Palm), Motorola and RIM. As a little goodie the author also describes Waba. Generally, the tone of the book is very light making it a very pleasant reading experience.

   As a bottom line, this book is extremely recommendable for everybody with Java experience who is new to the embedded Java space!




2. This book is an excellent presentation of the current world of Java in embedded devices with enough detail to get someone started but also not too much detail to get a reader confused. It provides a great mixture of background and hands-on information. In a very structured way, the author shows the problem space of resource restricted operating environments and provides some guidance on when employing Java in a device makes sense and how to tune and address performance issues. After an overview of the J2ME specifications, three actual implementations of the CLDC/MIDP are discussed in detail (Sun's KVM for Palm, Motorola's J2ME SDK and RIM's Blackberry JDE). All of those implementations are included on the CD, which allows for some really good hands-on training. As an additional goodie the book also discusses Waba.

   Generally, the tone of writing is very friendly making this book a very pleasant reading experience. The bottom line is, that this is an excellent introductory book to J2ME for people who know some Java already!

   I definitely cannot agree with some other reviewer's perspective in regards to the author just having collected the Tech Tips he wrote into a book. However, this book together with the Tech Tips make a great combination to jump start J2ME development.




3. This is a great book to help you get a handle on the Java2Micro Edition. Need to know the difference between a Profile & aConfiguration? Wondering where PersonalJava fits in with regards tothe J2ME?

   The weakness of this book is the 'code' aspect. Theauthor goes through various implementations with a Tic Tac Toe game,but fails to go through in any detail of the main API's that aren'texactly in the J2SE (Records, Connector, how to draw low-level, Highlevel GUIs, etc..). Also, after reading this book it failed to mentionwhich DataStructures are available. Also, the detail of theimplementations is either slightly out of date, very light orboth.

   Besides all that, it is a good book (hell it's the only J2MEbook that I know). For an overview book you couldn't ask for more.Easy writing style and helpfull diagrams, but not overdone. I wasinspired enough to write a J2ME game...




4. Although this book was published about a year ago, it still has an incredible value to everyone seriously interested in developing applications in J2ME. It is one of those few books that is capable of covering major topics without being too broad and digging deep into details without being boring.
   Eric explains how to think in Java in J2ME. The thing is that normal Java programming paradigms often will not apply to J2ME, since we have to work in a very constrained environment. The author from the beginning gives you an overview of what can be done and what should not be done with J2ME. Those first chapters are worth the price of the book alone. Subsequent chapters cover the essentials of J2ME for different hardware platforms including Palm OS.
   All in all, I think this book is a must for everyone who intends to write professional software for mobile devices.



5. I like Eric's books normally; but this one is a bit dated and not much more than a review of the J2ME specification, which you could obtain on the internet without buying the book.

   Lots of spec stuff and very little 'how to...' stuff. Give it a miss and buy his newer book with Ortiz as the co-author.

5 comments about Javascript Programmer's Reference (Programmer to Programmer).

1. Pleasantly surprised that this book contains a CD-ROM. What's amazing is that the disk contains not only the entire book but actually has more in it than the printed material. They say they would need to print two volumes to fit all the data in.

   I don't use the book anymore. Besides being (deliberately) incomplete finding items is quicker using the CD-ROM. The electronic version is styled as webpages strewn with hyperlinks (I didn't and don't even bother checking out the pdf version). If you have enough hard disk space copy the entire CD-ROM and use that copy instead. Accesing the reference is much faster that way. Create a shortcut on your desktop or on the Quick Launch bar or anywhere it's most convenient.

   Please note that this is not a beginner's book! Buy this only when you've gotten up to speed on JS programming. This is purely a dictionary-like reference for JS programmers. I myself bought it while my understanding of JS was at kindergarten stage. Needless to say 'reading' it then was a disappointing experience. My fault, not Wootton's. These days I refer to it every now and then to check on syntax and usage.




2. This is alphabetically arrangement of unrelated concepts that only have in common that theyre are linked to JavaScript.

   This is pretty much useless if you are looking for an anwer to a meaningful question. It is only useful in the case where you know the class/method and are looking for the table "which browser does it support it".

   I definitely do not recommend it.




3. This book has almost no value (aside from a door stop). The information is incomplete, even for the time it was written. I applaud the effort of running scripts to ferret out "undocumented" information but even that information is presented in a useless fashion. Skip this book even when it is stacked high on the remainder pile.



4. This was useful in context. If you had to write crossplatform javascript for 4.x browsers, it told you what features worked in which browsers. Overall, it merits 3 stars because it saved me a lot of time back then.
   
   The book is utterly useless if you aren't already proficient at Javasript. There are no examples. It seems like other reviewers were expecting a "how-to" book, and this was not a how-to book.



5. While I havn't found the book useful, the CD ROM is priceless. I have used the accompanying reference for more than 5 years now, and it is still my primary reference for javascript programming being surprisingly comprehensive.

3 comments about Developing Mainframe Java Applications.

1. As a COBOL programmer, I'm glad I could read a book that presents Java without mystery or hype. I appreciate seeing Java at work with IBM mainframe technologies that I've used for years.



2. Ever read a FUNNY technical book? I love this author!

   How nice to find a Java book written for the stodgy old mainframe folks...

   Thank you Mr. Marco




3. Yes he is funny and down to earth, yes he speaks "mainframe". This book does an excellent job of explaining Java to the mainframe crowd BUT... 2 bones to pick.
   First problem I noted was that sometimes, in trying to show the examples of PL/1 and COBOL, the language becomes very confusing about how it would work in each of the languages. He is not clear.
   Second, his COBOL examples have glaring syntax errors. Seems like a simple thing that should have been verified. It is not just once or twice, it happens throughout the book.
   If you need a good intermediate level book and can get past the noted problems, he will take you through the process of learning Java. Most importantly, it is the only book I've found that addresses the mainframe environment and java. Another good choice for getting started in rudimentary java is "Java for the COBOL Programmer" by Doke and Hardgrave. That book does a better job of teaching the COBOL person but is just a starter book. Developing Mainframe Java applications has wider depth and range.

5 comments about Practical JavaScript for the Usable Web.

1. A task oriented book that, notwithstanding a small number of pages, manage to break some new grounds and cover a few advanced topics. Not suited for a complete programming novice, but if you have some programming experience and want an intelligent introduction it may be a great choice. Also recommended to JavaScript freaks looking for some refreshing material



2. A task oriented book that, notwithstanding a small number of pages, manage to break some new grounds and cover a few advanced topics. Not suited for a complete programming novice, but if you have some programming experience and want an intelligent introduction it may be a great choice. Also recommended to JavaScript freaks looking for some refreshing material



3. Fresh and enjoyable read. This book is a great companion to a solid Javascript reference after you have dabbled in some Client side scripting.



4. This is the perfect book if you want to refresh the Javascript you learned some time ago, or if you've gone through some on line tutorials and would like to get the whole picture.
   It's less than 400 pages, but packed with information. Very clearly written and easy to read. It explains a concept and shows you examples, pointing out where you could make mistakes and giving advice for best practice. For an absolute beginner though, I think it would be a bit too fast-paced - if this is your case try Paul Wilton's other book.



5. The book gives a narrow introduction on JavaScript for an intermediate programmer, so it is cutting corners. Many of them, nuf said!

5 comments about JSP, Servlets, and MySQL.

1. This is the worst technical book I have ever had the misfortune to read. I was originally excited to purchase the book as the Table of Contents outlined topics I am interested in studying. However, the book is riddled with text and code errors. In fact, the author had the audacity to change the downloadable source code after the book was published. Therefore, you can't even get the code source for the examples in the book, and the new code comes with no instructions! In addition, the author does a poor job of explaining the concepts he is trying to teach. M&T Books should be ashamed for publishing this poorly edited text. I truly feel that I have been swindled by this company/author and would like a full refund. The book is so bad that I will avoid all M&T Books in the future.



2. I picked up this book because I had already decided that I was going to use JSP and MySQL together to create my web site. Quite frankly, I haven't learned anything from this book that wasn't done better in other books, which is a shame because this is an area that really deserves a more thorough treatment. In several areas he just fills several pages with code and hardly explains it at all, other than a few lines--so why bother showing the entire example? This is a clear case where better editorial review would have helped to focus the book on material that would have been more helpful to the reader.



3. This book has a very interesting title and the TOC look great too, but unfortunately the content is carelessly chosen/written. I don't want to repeat the error in the code listings. I just want to mention about design problems in this book.

   JSP has its born-with problem that it is hard to set boundary for Server Programmer and HTML Programmer. These 2 kinds of work need different skill set. That's why separation of Data and Presention is very important to JSP web site design.

   The author of this book carefully avoided to include much JSP code in HTML pages, but his design leads to another extreme: almost every control (forms, buttons, links) are generated by JSP code. This approach will create a nightmare for JSP programmers for changing the appearance of the web site.

   So besides coding error, this book has design issues. I really can't imagine who should be the audience...




4. The TOC sounded great, so I bought the book. I hate to reiterate what other reviewers have already said, but it's true: there are so many errors it's rediculous. It was painful to figure out why I wasn't understanding some of the material (for example, the SAME SQL statement produces two DIFFERENT result sets on page 208/209)when in fact it was just a very poorly edited book. The book's topics are perfect - now someone needs to go through it with a pitchfork to weed out all the errors. Not to mention that the example code you can download has been refactored (to put it nicely). It's an expensive lesson in wasted money and time and frustration, but from now on, I'll always check the reviews here before ordering any book.



5. I found this book very helpful. I knew nothing about JSP, servlets and mysql. My previous experience came from a standard university course in Java. The book took me through setting up tomcat, mysql,etc. It started me off using the technologies. The book is built around a core example. I didn't reproduce and test the code supplied but dipped in to take what I needed. Downloading the code from the website was confusing. Overall this book has been very helpful. I found the content concise and to the point. Thanks to the author.

5 comments about Mastering RMI: Developing Enterprise Applications in Java and EJB.

1. I agree with all the negative reviews already posted, but I was so frustrated with this book I had to add another voice of criticism.

   The book was obviously a manuscript dump with no editing that I could detect. Why Wiley thinks they can charge this amount for no work at all is beyond me. It is littered with grammatical errors, incomprehensible sentences, and annoying repetition. In short, it is nearly unreadable. To add insult to injury, there are countless summaries which condescend to tell the reader that she should now have a good understanding of the covered material, and can move on. Don't be so sure you will have a good understanding. I did not, and I've been using RMI for some time.

   As others have stated, the examples are contrived, and not very well written. There is very little here of use for those developing large-scale distributed systems.

   Save your money (considerable money, in this case) and stick to Sun's website.




2. As the title states Mastering RMI does contain all the information necessary to master the subject of RMI. However, the explainations are not as clear as they could be. And, I found the pictoral diagrams to be of little value. If you are looking for a book which simply gives you what you need to use RMI you may be dissapointed. This book provides COMPLETE coverage, including the underpinnings of the technology. While this may be interesting reading it tends to divert attention and time away from the practical aspects of RMI. If your one of those programmers that has the time and desire to explore all the nitty-gritty details of the subject, regardless of their immediate benefit, than you will probably find this book a good read. Otherwise, if you just want to get up-and-running with RMI their are simpler and quicker routes you can take.

   I hope this helpes :)




3. I totally disagree with the negative reviews on Öbergs book. I always admire authors who makes things easíer to understand, not making them seem more intelligent than they really are. A good teacher is one who can make things understandable, not the opposite. If you have read 3-5 RMI books before this one you may get disappointed as some of the other reviewers. It's an excellent intoduction to RMI, but don't expect to find some magical new/hidden, features of RMI here. Maybe the title should have instead been "An Introduction to RMI with Lots of Good Explanations." If you need an introduction to RMI, where you don't have to read a lot "between the lines", then this book is a good choice. I've stopped searching the internet for explanations about RMI after I got this book. There are lot's of hello world RMI introductions out there on the web, but Öbergs book goes far beyond them all. A good introduction.



4. I have been on RMI mailing list for half a year. This book clearly explained most of the frequently asked questions on the list. I think by reading first half the book, I understood RMI better than the half year I spent on RMI mailing list.

   I agree that some examples were not given enough explaination, especially non-RMI related codes. E.g, the IdentySocket
   .




5. I purchased this book after doing some research into RMI via the internet to give me a more solid understanding of RMI, which it did. However, when applying my acquired knowledge to a real-world application, I found that I was missing a HUGE piece of the RMI puzzle. RMI over the INTRAnet is a wonderful thing; however, when trying to implmenent RMI over the INTERnet, and the RMI server is behind a firewall, you are in for a painful migraine. This is a show-stopper for my employers, I wish that the book mentioned something about RMI and firewalls. There are workarounds for the firewall, but they are by no means easy and you will not find them in this book.

5 comments about Pure Java 2 (Pure).

1. I've been programming in java for 2 years now. This is the fifth java book that I've read. It's the best one so far. The book reviews how to use necessary classes in the jdk that would benefit most java developers. It also sheds light on subjects that other books don't really cover. It teaches you how to code with the jdk, but it also explains what is happening in the java virtual machine so you understand exactly what is happening with your code. Reading this book has really helped me understand programming in java. It's not really geared towards teaching java or object oriented design, but if you have some java experience and you want to take it a step further I would highly recomend this book. There were only 2 minor drawbacks that I saw. First, it doesn't go in depth for some subjects. For example, if your trying to target in on using java swing this book will just give you the general overview but not enough to create a really nice gui. Second, there are minor typos in the code. ..................



2. This is a good book for beginners looking for a reference and HowTo on Java. But does not go into detail about any of the advanced features of Java like Java Beans, etc.



3. This book has a logical structure, and it is didactically superb and very well written. It is highly recommende for people who want to make the second step, as it picks you up where the typical tutorial stops.

   The book is unique in concept, as it doesn't just show you how things can be done, but also how they should be done in order to produce reusable, and object-oriented code. Eg, when Litwak explains multithreading, he shows you that there are in principle two ways to do it: inheriting from the Java class Thread, or implementing the Runnable interface. Ok, that's in "Thinking of Java", too, but Litwak also explains you why he thinks that inheriting from Thread compromises object-orientation. But he is never religious about these things, he just explains you what it possible, and what criteria you might want to consider to make your own decision of how to do it in a real-life project. And this is, what makes this book so valuable: it connects the abstract concepts of object-orientation with the code and advice for real-life programming practice. The book helps you not only to find some solution, but it helps you to find your own way to the most general or the most suitable solution. At last I understand what re-usable code really is, and how I can write it myself!

   So, why not five stars? Because there are incredibly many typos as well in the text as in the code examples, especially in the first part or the book. With only little knowledge of oo concepts or Java it is easy to identify them, but they can certainly confuse a reader with no knowledge of the language or objects and such. It's not that bad in part two. It looks as if part II has been written first, and part one was created only shortly before the deadline. Pity! What about a revised edition, SAMS?




4. This book has a logical structure, and it is didactically superb and very well written. It is highly recommended for people who want to make the second step, as it picks you up where the typical tutorial stops.

   The book is unique in concept, as it doesn't just show you how things can be done, but also how they should be done in order to produce reusable, and object-oriented code. Eg, when Litwak explains multithreading, he shows you that there are in principle two ways to do it: inheriting from the Java class Thread, or implementing the Runnable interface. Ok, that's in "Thinking of Java", too, but Litwak also explains you why he thinks that inheriting from Thread compromises object-orientation. But he is never religious about these things, he just explains you what it possible, and what criteria you might want to consider to make your own decision of how to do it in a real-life project. And this is, what makes this book so valuable: it connects the abstract concepts of object-orientation with the code and advice for real-life programming practice. The book helps you not only to find some solution, but it helps you to find your own way to the most general or the most suitable solution. At last I understand what re-usable code really is, and how I can write it myself!

   So, why not five stars? Because there are incredibly many typos as well in the text as in the code examples, especially in the first part or the book. With only little knowledge of oo concepts or Java it is easy to identify them, but they can certainly confuse a reader with no knowledge of the language or objects and such. It's not that bad in part two. It looks as if part II has been written first, and part one was created only shortly before the deadline. Pity! What about a revised edition, SAMS?




5. There are some features of Java2 that this book does not cover. The book consists of three parts, an introduction to java, a deeper explanation of some of the core techniques of Java 2, and an API reference. The introduction has unfortunantely lot of typing errors, so if you are unfamiliar to java, this may be more difficult than it should be. The technique reference is one of the most usefull parts of the book, where there are an deep, weel-documented explanation of some of the core features of java2. The best thing about this book is in fact the small notes, tips and tricks, wich points out a lot of pit-falls which should be avoided. If you are familiar with java, and need to go further and learn more, this is a book for you.

5 comments about Java(TM) Network Programming and Distributed Computing.

1. This book is an introduction to four major areas: networking, Java language, Java network programming, and Java distributed computing. Dozens of published books are specifically dedicated to each of these topics in detail, but this book is trying to give a reader a taste of all these technologies at the same time.

   The book is easy to read. Most of the material is clearly explained and illustrated. Code examples (demos) are clean and complete. The demos are not contrived, but present to the reader interesting implementations that may be reused and give a good idea of how programs that are commonly used may work (SMTP, POP clients, HTTP server, etc.). Each of the demos is followed by a detailed explanation that focuses on how the demo works.

   I like the book, although I think that the chapters covering Java language programming are extraneous: if you don't know Java, you should learn it from Java language specific books first, and only then venture into the advanced topics of Java network and distributed programming.

   The book reminds me somewhat of the classic "Unix Network Programming" by Richard Stevens, which was a must for any C/Unix programmer more than a decade ago.




2. Most of my experience in network programming comes from W. Richard Stevens' "UNIX Network Programming", where there's lots of detail in the TCP/IP protocol, and using C to implement it. At the time, the professor teaching the course tried to provide us with comparable programs in Java, but not having a good Java networking book to consult from was a drawback to those segues.

   This book serves as an excellent companion to Stevens' book, so that you can get the feel for how Java accomplishes networking capabilities. I still prefer the TCP/IP detail that Stevens' book provides, but that's mainly because I like the language independent concept of networking.

   I created a small client2client messaging applet, sent it to a couple of friends for testing, and enjoyed how quickly and easily it was to get it working. Java abstracts a lot of the detail away from the user, since it was designed from the get-go to include networking capabilities, and this book uses those abstractions to its advantage. I'll probably want to get my hands dirty and see how much hands-on control I can get with Java sometime later.

   (Reilly*2)'s book is a great way to just jump into network programming without getting your head too tangled with TCP/IP intricacies. This is not to say that the book doesn't cover those details, but it doesn't delve into them as deeply as Stevens' book does. In my view, that's a drawback to it being an absolute reference, but for many who just want to start developing client/server apps, this may be just what you're looking for.




3. One of the best books I've purchased.

   I bought "Java Network Programming and Distributed Computing" for Sun's Developer certification exam which requires knowledge of the information given in every chapter, for example RMI, sockets, serialization, and threading.

   The book progressively gives you information you need to understand how the different protocols work, when, where, why, and how to use them and gives good explanations of its source code examples.

   I feel I received more than my money's worth and will be looking for more titles by David Reilly and Michael Reilly.




4. If not for its minor typo errors in the text and code, I would have given this book 5 stars.
   If you're a bedroom Java programmer like me, then you can repair the code easily. Also the code examples weren't "perfect" implementations of Object Oriented Programming concepts but I believe this was intentional considering the latter would have been an additional layer of complexity and would have detracted from the book's instructional value.

   The chapter on Servlets could have been longer by providing simulated web-based transaction (i.e. two-player tic-tac-toe or even against the server, or a simple business transaction using a non-database source -> text file).

   The bonus JavaMail chapter was superb! If you excel in AWT/SWING, then you could make a GUI-based e-mail client with this chapter!

   In my opinion, the RMI and CORBA chapters could have provided a little background on distributed computing theory. While the book overall is clear and well-organized, those without distributed computing theory background (like me) would have trouble understanding these chapters (i.e. where did the words stub and skeleton come from?) I bought this book for the networking and not the distributed computing chapters, anyway, so don't let my inexperience with distributed computing make this book any less worthwhile.

   I'm just being my own opinionated self but I found this book to be truly excellent and personally give it 4.5 stars!




5. Very happy with the content of the book, but very disappointed that the book only lasted a week before it fell apart.

No comments about Java How to Program (8th Edition).

5 comments about JSP Examples and Best Practices.

1. I agree mostly with what some of the other positive reviews read. The discussion about different design patterns was interesting to read.

   However, I did get caught up on the source code in the book. I would think that a book is supposed to be about "best practices" would handle quotes in database inserts/updates. Is it common practice to assume that your form data will never contain erroneous information that will cause your system to fail?

   I don't want to harp on this book too bad (many others are worse), but I am still searching for a solid JSP book that has sample code on how to build a solid/useful application from start to finish, while maintaining a clean separation of business logic and actual presentation.




2. I am teaching myself server-side Java programming. After reading, using, and reviewing many books on Java server-side web development, I had found they fell into two categories: Beginner and advanced. The beginner books typically introduce a lot of bad coding practices, such as filling JSP pages with java code, or using outdated examples of Servlets that output HTML. After a few chapters of this, they jump to the Struts framework, thereby never helping the reader build good coding practices and skills.
   The advanced books get quickly into frameworks like Struts, and also employ EJBs. EJBs are not needed in many web applications, where they introduce unneeded complexity. What I wanted but couldn't find was a good book that covered the middle ground: how to build applications based on JSPs and Servlets that demonstrate good design and coding practices, with a realistic sample application, and yet understandable for someone learning the J2EE technology.
   When I found this book I was surprised to see that it concisely and clearly presented all the key topics I had hoped for. I found it by accident, because I never would have guessed from the scant 3 or 4 reviews on Amazon that it would be worth looking at.
   Prerequisite knowledge for this book is basic Java skills and an introductory understanding of JSPs and Servlets. I liked this because so many beginner books spend a lot of time going over the basics. The book covers all the key intermediate-level topics you'll need to get started coding good Java web applications. This book goes beyond others I read in also showing how to use JUnit to do unit testing, and Ant to do application deployment. The author demonstrates these so clearly and simply that a person new to these tools will find it easy to follow and put to use.
   Finally, the author finishes with taking the reader through how to build a basic but solid application framework that even the beginner to frameworks can follow. This framework is no Struts with its relatively steep learning curve. By the time the reader has got to the framework chapter he has learned what he needs to understand the framework. As if this were not enough, the author then shows how to deploy the framework, and then use it to build a sample application. All this is done in slim, concise, easily-to-follow chapters and code that is clearly and completely presented. You won't have to go hunting through the source code download or CD to research a bunch of code that is not illustrated in the book itself. It's all in the book.
   A previous review rated this book low because he thought it didn't have a realistic application. I don't know what he is looking for exactly, but I thought the application was quite real enough in giving a fully functioning, realistic, web application. It is no super app, but neither is it a toy app. Again, it aims for the later novice to intermediate-level skill set. And I think it succeeds well.



3. I can save you money on the purchase of this book. If you can answer "yes" to the questions below, there is no need to buy this book:

   * Do you know what JSP and servlets are?
   * Do you know how to separate presentation and business logic with JavaBeans and custom tags?
   * Are you familiar with MVC?

   If so, no need for the book. I was expecting much more. It's less best practice, and more typical web app development. What disappointed me further was various comments in the text that displayed poor practices in areas outside of JSP web development, e.g. "the first step in developing a jsp web application is designing the user interface."

   My one-star rating can be summarized as follows:

   * Poor typesetting and book formatting: -1
   * Very few "best practices" -2
   * Below average writing, low content-to-price tag ratio -1




4. This book draws a clear picture on JSP web application development. If you are a JSP beginner, this book is a must read. It teaches you the right way to do things from the beginning.

   I really enjoyed its step by step approach that leads to the framework based application development, makes a lot of sense to me.




5. 
   
   This book will probably be most useful to someone who knows JSPs and servlets and has worked with them, and is looking for better or alternative ways of writing JSP applications.

   The first two chapters provide a review of JSPs and an overview of web deployment. They include a nice JSP/MySQL example, with
   instructions indicating how to build the MySQL database and incorporate into the JSP example using JDBC.

   Chapters 3 and 4 include discussions and examples of how to use JavaBeans and custom tags. The JavaBean example shows how to handle the display of a large amount of data retrieved from a database.

   The use of J2EE patterns is discussed in the next several chapters, as befitting a book with "best practices" in its title. The four patterns covered are the Decorating Filter, Front Controller, View Helper, and Dispatcher View.

   The remainder of the book covers some topics that are not directly connected to JSPs, but may be useful in a wide range of software applications. These include regression testing, and the use of JUnit and JMeter; deployment, and Ant and CVS, as well as precompiling JSP pages; and application frameworks, including an example.

   In short, the book includes a collection of topics not often found in a JSP book.

   I noticed some minor quibbles, such as use of single-character variables and older break tags (rather than
   ),
   but generally speaking I find the book to be quite informative and practical, especially in the discussions and use of open source software such as MySQL, JUnit, JMeter, and Ant, with JSPs.