No comments about JDK 1.4 Tutorial, eDoc 3 : Creating Web-borne Applications with Java Web Start.

5 comments about Netscape One Developer's Guide (Sams Developer's Guides).

1. This book is supposed to be a reference but since it suffers of many errors and tend to be overall confusing - for example it is trully unbelievable how the authors, writing such an exhaustive treatise, could not figure out better way to match source codes and topics. Some examples really make no practical sense at all, other are unclear or unprecise, the reference is incomplete or mistaken and in general it is hard to count on the book as a guide. I believe the second edition is badly needed to improve the style and clarity of the first.



2. This book fails to meet some standards for a reference it assumes to be. The source codes and examples are not in accordance, the book is full of useless examples and errors are abundant. Of course it is superior to "Dummies...", "Idiots ..." and similar books but I expected more.



3. I found the book to be packed with useful examples. With so many useful examples I don't believe the previous reviewer even read this book! The book covers a lot of ground and is a book for developers.



4. This book covers a lot of ground, but is out of date with the newest Netscape servers (just try and use SiteManager). I'd like to see a 2nd edition with less intro on Javascript and Java (I think there are over 200 other books that cover the same introductory material) and more in depth coverage of advanced Java, JavaScript, and server-side programming.



5. My 3 stars might be a little low for a review of this book - Its a good reference for everything Netscape. Having bought the book for Javascripting help, I was a bit dissappointed with its handling of syntax. The Javascript object model provides a logical way to access most any element within an HTML page but the Netscape ONE book failes to specifically cover the object hierarchy syntax. Events and Methods are listed but very few of them are fully described with examples. Also, although some thought was given to cross-platform compatibility, there are some glaring problems that don't seem have solutions. One such problem involves Netscape's method for checking if windows are open and giving them the focus if they are instead of attempting to open a new window. While this works in Netscape, it does not in Internet Explorer - a fact not touched on

No comments about Java Programming: From Problem Analysis to Program Design.

3 comments about Advanced Programming for the Java 2 Platform.

1. This book does a good job to show how different technologies are used in the auction application. I would advise the readers to go through a little bit of JDBC and EJB on the web at the sun website and also this book is available on the web. The site also has pointers to RMI-IIOP etc.



2. There are lots of books on enterprise applications but this book has lots of information that I haven't found in any others.

   The chapters on CORBA, printing, security and debugging are excellent and I like the way it covers one application throughout the book.




3. I like the content on Chapter 2 and 3 with good examples on EJBs, especially on CMP and BMP EntityBeans. It also has good coverage on the use of transaction management in both CMP and BMP environment. If you have fundamental JDBC/EJBs knowledge, you will enjoy reading this book.

   Chapter 4 has good introduction on distributed computing regarding RMI/IIOP/Corba plus the JNDI object lookup and the sub-system data marshaling mechanism.

   Finally, Chapter 7 and 8 provides some insight with regard to debugging and performance tuning that is quite helpful in Java programming.

4 comments about Thinking Recursively with Java.

1. This little book is a minor classic. First published 20 years ago, it gave an extended explanation of recursion, which is a vital concept in computer science. Of course, Java did not exist back then, so that edition used Pascal for the example code. But Pascal has undergone a severe downturn. Hence this second edition has code in Java.
   
   Classic pedagogic examples like the Towers of Hanoi are shown to yield to a recursive assult. The code examples are concise. Not atypical of recursive methods. If you find the entire idea of recursion to be a little weird, you can focus on the text's examples. Unlike code for, say, GUI building, which is often voluminous, recursion is subtler. And far more elegant, if you appreciate this type of abstraction.
   
   Roberts also brings up fractals. Another trendy topic. He shows that recursion and fractals are a very natural fit. The concept of self-similarity that underpins fractals is so easy to express in a recursive routine. If you understand recursion by this point in the text, a bonus may be the nice insight this gives into fractals.
   
   The only minor dissenting point is that there seems to be no discussion about when you should not code a recursive solution, even if such a method is possible. If you have a large data set, that triggers a stack or heap overflow, due to repeated, recursive method calls, where each call pushes return address information for that method onto a stack. I have had to rewrite sections of my own code, that were originally recursive, due to this.



2. In mathematics and computer science, recursion specifies a class of objects or methods by defining a few very simple base cases or methods, and then defining rules to break down complex cases into simpler cases. Of the books out there on recursion, this really is a very good one. This is the 20th anniversary edition of the author's classic book "Thinking Recursively", which was published in 1986, with all code illustrations now done in the Java programming language. In fact, this book has the exact same number of chapters with the exact same names as the original edition with improved and expanded material.
   
   The author does a good job of comparing the procedural approach to the recursive approach while showing an example of a producing a "context-free grammar" in which the procedural approach fails. This is not only a good discussion of the shortcomings of the procedural approach, it has some concrete examples that explain the concept of the context-free grammar better than programming language textbooks that are dedicated to the cause. Next the book offers up the recursive solution for the familiar and classic Tower of Hanoi problem. This section uses index cards to illustrate the solution. Necessary tasks for each subgoal are listed on the index card and are gradually marked out to indicate progress in moving the disks from one tower to the other. There are also discussions on permutations and sorting that are best solved by recursion. Of course, you can find this information in most good algorithm textbooks, but you can't usually find in those textbooks the code examples that show the complete solution to the problem that you find in this book.
   
   Where the book is particularly excellent and unique is in later chapters when it includes recursive solutions to graphical applications and even introduces the GPen class, which is defined in the acm.graphics package developed by the Association of Computing Machinery (ACM), for this purpose. Drawings of fractals are used as an application to show how one carries out this recursive drawing. It is also explained that Java's graphical classes, though extensive, are not suited to recursive drawing.
   
   This book contains quite a bit of mathematics as well as Java code, so the reader should already be proficient in Java programming as well as discrete mathematics. This book could serve as a textbook since besides its many examples it includes exercises with solutions.



3. Many pages spent in academic formulas make this book good for students only.



4. I don't program in Java, mainly c++. If you program in any c-style language you will find this book insightful in Thinking about recursion. The examples are great and the book is written in a very nice style. I came upon this book by chance. I owned a second hand copy of the original with included examples in Pascal. I much prefer this edition. To get the most out of this book, I'd recommend you attempt and think about the questions at the end of each of the chapters. The mathematical induction related chapter was eye opening and very enjoyable. I'd recommend any text that Eric Roberts has written, he is obviously gifted in his ability to educate and make it so rewarding in the process.
   
   Thank you
   Gary

5 comments about Java Cryptography (Java Series).

1. There's no better first book on cryptography for a programmer to buy. You get a great deal of exposure to an important facet of network security through this little gem. It's friendly and to the point.

   The Java API is excellent--but the idea of cryptography is little odd to the everyday web or network application programmer. Having someone to kindly bridge the crypto-what-ja-ma-call-its to a world of how-do-i-wrap-it-around-my-web-or-mail-service is simply priceless. There's NO silly cryptomath (because only those cryptoexperts get the math anyway) but instead it's filled with no-nonsense coverage of how each and every common crypto engine and crypto-"protocol" takes your stream of data and converts them to cryptograms. If you always like to learn as MUCH as you could about a particular computational wonder tool before tackling a project without turning your brain to mush with research mathematics--you'll like this book.

   It's just one of those books I wished I read a lot earlier so I won't have an excuse to avoid APIs that exposes applied cryptography to network applications all these years. I highly recommend this book before you head on to the math of it.

   It's too bad the SSL/TLS API for Java never made it into this first edition (it did make it into O'Reilly's latest Java network programming book though).

   Any one know of a book just like this one but for another language like C or Perl? With a book like this you don't need to explain it all over again--but illustration and snippets of code showing how to use the various APIs in other languages would be useful. I think if the author is willing to dabble into all of these issues and give away his findings on a book website it will be just AWESOME! A second edition of said book with all of these issues covered would be just grand too :-)

   P.S. When I started learning Perl I first bought Mastering Regular Expression. Because I felt that with Perl--it really simplifies one's ability to play with streams of text. And what better way to learn the language (especially if you know some basics about it) than to learn what it is brilliant at right away?! That's how I felt about Java Cryptography. The way Java makes network programming not only easy.. but also fun to add in complexities like security and cryptography makes it a very enjoyable programming language to work with as a student or as a programmer. This is the sort of book you'll want to read ASAP once you get the basics of Java the language down! :-)




2. Are you concerned about someone outside your company intercepting a password between your applet and your server? Are you worried about someone inside your company using a packet sniffer to capture the credit card numbers of your customers? No? Well, perhaps you should be! As a first step towards closing your security holes you should pick up a copy of "Java Cryptography". This book is written for the experienced Java developer with no cryptography background who needs to build cryptography into their application. The book starts off with a brief description of secure systems and demonstrates a "Hello zoT1WY1NJA0=!" program. It then gives a fairly detailed description of cryptographic concepts and the Java Cryptography Architecture (JCA). Subsequent chapters discuss how to use the Java Cryptography Extension (JCE). Chapter 5 covers generating and managing symmetric and asymmetric keys with an explanation of the difference. Chapter 6 discusses authenticating users and messages. Signatures and certificates are covered. Chapter 7 covers encryption techniques using different types of ciphers. Chapter 8 covers signing applets. The last chapters include sample encrypted chat and e-mail programs. The end result is a book that provides excellent coverage of cryptography in Java. The only defect in the book is that it is three years old (Java 2 was in beta). Fortunately, the book was written recently enough to include the new utilities used in Java 2. Even though a new edition is desirable, "Java Cryptography" still stands alone as the best book available on this topic.



3. Do not waste your money or time. This is a very poor book and is very much out of date.



4. The reviewer who mentioned this book is out of date is absolutely correct. Worse than that, this book on cryptography is written by someone who doesn't actually understand cryptography very well. Lots of bad practices are recommended, and there are several examples in the book that are insecure as written.

   I would also give this book zero stars if it were possible.




5. Good introduction and explanation of cryptography, great for begineers, great view of Java. Specially chapters from 1, 2, 3, 4, 6, 7, 9. The rest is sometimes poor, sometimes obsolete. It's a good job, but since 1998 a lot of things came to this area. Maybe a second edition will be a good idea. For provider architecture I prefer Scott Oaks' Java Security. I miss some explanation of cryptography. But the explanations included are very clear. I agree the average from the rest of the reviews and I think 3 stars is the deserved rate for this book.

5 comments about MIDP 2.0 Style Guide for the Java 2 Platform, Micro Edition.

1. If you are designing Java programs to run on cell phones or PDAs then you will want to keep this style guide nearby. This will not teach you how to code but it will teach you how to design your MIDlets so that they will be usable. The book will show you what works and what doesn't work on small devices. You won't find a single line of code in this book because that is not what this book is about. What you will find are lots of samples of good design and bad design plus plenty of recommendations to help you to write usable MIDlets.

   The target audience for the book is made up of two groups, those who are porting the Java environment to a new device (implementors) and those who are writing MIDlets to run on those devices (application developers). The book is well structured to show what is the responsibility of each group. For example, the style guide tells the application developer not to worry about text that is too long to fit in a field because it is the responsibility of the implementor to determine if text should be clipped or wrapped.

   The book starts with some basic guidelines (make your code simple, predictable, and efficient) and a description of the minimum MIDP hardware (tiny screen, limited input, two colors, and little memory). The authors then get into the main focus of the book, designing MIDlets. Starting with screen layouts, they take us through the different items you can place on a screen such as lists, text fields, forms, commands, etc. The focus is not on how to code but on how to make these items usable. The book also covers issues such as push, security, and touch input from the usability point of view.

   There is no doubt that this book will be the standard for designing programs for MIDP devices. This book can help you avoid a lot of simple (and not so simple) mistakes that you may not notice until you get to usability testing. You could write your MIDlets without this book but why not save yourself some headaches.




2. First, a very important note: *this is not a technical book*. If you are already familiar with older versions of MIDP, this book is an overkill and might be a bit boring from time to time. Having said that, the book really does a good job introducing the MIDP GUI concepts and much more. It's a very readable book and contains plenty of clear examples.

   In the first four introductory chapters (Introduction, MIDP Characteristics, Designing Applications for MIDP and Screen Layout) the authors briefly go over the most important features of MIDP. A special emphasis is given to the new fearures introduced by the latest MIDP 2.0.

   Then they move to the most important MIDP GUI elements. Each element is introduced and its usage is suggested and the next six chapters explain design patterns and rules to be used with the most common GUI elements (Lists, Text, Forms & Form Items, Alerts and Canvas Screens).

   The 11th chapter was the most interesting chapter for me - it explains the recommended usage of GUI elements related to game programming. The game package is brand new and introduced in MIDP 2.0. Here the elements such as offscreen buffer, layers and sprites are described. There is even a small subchapter about game performance and resource usage and, at the very end of the chapter, the authors give some general advices related to game creation and programming concluding with a crucial remark: "Always test your games on actual devices".

   Chapter 12 explains Abstract Commands and the next three chapters introduce the features that really distinguish MIDP development from other Java applications. These features are, of course, strongly related to mobile devices properties and include Application Discovery, Installation and Mangement, Push Functionality and (many times neglected) Security.

   The last chapter (16) goes briefly into some of more advanced topics of MIDP 2.0 (touch input, overall application preformance and multithreading). This chapter is very basic and contains some obvious hints, but, as I said, this is not a technical book and the chapter does a good job presenting the features that might help GUI designers.

   The book is intended for beginners in the MIDP application development and, as the name of the book says, is mostly *a style guide* providing plenty of hints and advices. These advices are nicely separated in two classes: "For Developers" and "For MIDP Implementators". Authors use "Recommend", "Strongly Recommend" and "Consider" to mark the importance of these hints.

   The book is coming from Sun and takes its place in the fameous "from the source" series which implies a certain level of quality. I can recommend this book for all beginners in MIDP area and, especially, to GUI designers and product managers wanting to became more familiar with the MIDP application look & feel.




3. This is one of a class of books that every application developer should
   read, and that not enough do. It provides cheap access to knowledge that is
   expensive to obtain. The title is almost a misnomer; Call it a Usability
   Guide and give a better idea of it's usefulness.

   MIDP 2.0 is the latest version of the most common J2ME Profile. It's a
   fairly new specification. Nokia, for example, have only announced support for
   this on their Series 60 devices in the last couple of months and I'm not aware
   of software or firmware upgrades for legacy devices yet. A lot of the content
   in this book can be usefully applied to MIDP 1.0 devices though.

   The MIDP 2.0 Style Guide for the Java 2 Platform Micro Edition is a widget
   by widget guide to best practice programming with the MIDP 2.0 API. The
   information contained within comes from established design principles, J2ME
   programming and implementation experience, and usability studies. The latter
   particularly doesn't come cheap, and is out of the reach of most individual
   programmers and small companies. So there is real value for money here.

   The layout is very browseable, with most chapters being a set of
   recommendations for a specific for specific widget such as a text box or a
   gauge. For the most part each chapter follows a standard format, that is
   defined in the introduction.

   There are two target audiences here; J2ME developers and MIPDP 2.0
   implementors. For the former it's an excellent resource. For the latter I
   would say it was pretty much required reading. This is because it ends up
   defining what amounts to a contract between MIDP implementors and application
   developers.

   For instance, from two successive recommendations on text boxes,

   Application Developers<
   "Use [The NON_PREDICTIVE] modifier in a textbox that has a URL, EMAIL,
   NUMERIC, or DECIMAL constraint. Email addresses and domain names are not
   typical words, so turning off predictive text input ..."

   And in the next paragraph,

   MIDP Implementors
   "If the application specifies the NON_PREDICTIVE modifier, allow users to
   enter one character at a time without any predictive input facilities."

   Clearly the first recommendation is only meaningful if the second has been
   followed already. There are lot of these sort of co-dependent recommendations.

   There is still a lot of slop in the MIDP 2.0 specification. Large chunks of
   it are optional, or can be implemented in more than one way. This is only to
   be expected in such a young technology, but it means that books such as this
   may help to define the standard if people use what they give.
   
   I would expect many of the recommendations in here to become part of future
   versions of the MIDP specification.




4. As a MIDP 1.0 developer and member of the MIDP 2.0 Expert Group I was very concerned about how many of the complex aspects of MIDP 2.0 would be communicated to developers new to the platform. I was delighted to find that the MIDP 2.0 Style Guide does a fantastic job of covering both the technical (implementation) aspects of MIDP 2.0 as well as the super important usability aspects of small devices.

   This is not a book for learning how to use the MIDP API's from Java, for that I suggest looking at "Programming Wireless Devices with the Java2 Platform, Riggs et al" or similar. This is a brilliant companion book on how to design your applications and as a result should be viewed in that light, rather than as an alternative to a technical book.

   The book has a well structured layout, both at a high level and at an individual chapter level. The book starts with an introduction to the MIDP specification, the changes from MIDP 1.0 and a general guide to designing applications for the sorts of devices that MIDP operates on. The book then covers each of the major user interface components (from High-level API to the new Games API) as well as the likely interfaces that users will work with for installing and removing applications.

   However, where this book really excels is the fantastic linking of the application developer concepts with the MIDP implementors concepts. The success of MIDP 2.0 will be how "standard" the implementations are, and how well application developers can leverage the commonality and standardisation of the platform. Each section has paragraphs grouped for "Application Developers" and "MIDP Implementors" which provides advice such as "Recommended: Use the SENSITIVE modifier for text boxes and text fields....." and "Strongly Recommended: Never store the contents of the text box....".

   This additional clarification covers areas that specifications cannot easily cover, the intentions behind the specifications and how the MIDP API implementation can impact on the application developer. This can provide great value to a developer when identifying potential risky implementation options and areas where different MIDP implementations may cause problems.

   A great reference for all MIDP developers; hopefully MIDP implementors will do everybody a favour and take on the recommendations provided in this book as this would be of value to the entire MIDP community.




5. The move from the full screen of the desktop to the significantly reduced screen of a handheld is similar to the re-formatting of a movie made to be viewed in a theater to one presented on a television. However, beyond the problems of reducing the size, there are vast differences. Movie and television screens engage in one way interaction with the viewer, and the effective use of handheld devices necessitates that the viewer be able to discern every detail and interact with the screen.
   The problems of compressing a fourteen inch square image into one two inches square are extensive, what is minor on the large screen often becomes significant on the smaller one. This book lists a series of style guides for the small screen presentation, placing them in three categories: strongly recommend, recommend and consider. A guideline is listed as strongly recommend if not following it could render the application unusable. If it is placed in the recommend category, then not following it will lead to an application of reduced usability, although it will still perform as expected, but nowhere near optimal. Being placed in the consider group means that following it will lead to a somewhat improved application.
   The guidelines listed in the book can be placed into two general categories, those that apply to all screens and those that are specific to the very small screen. Examples of those that apply to all would be the rules that all error messages should describe the problem and the selected item should always be clearly highlighted. Organizational rules for forms, lists and other structured presentations of data are quite different when the available screen real estate is so limited. It is of course these rules that should receive the bulk of your attention, because for most of us, they are new.
   When developing for the handheld, it is necessary to adopt a different mindset, and this book is an excellent primer pushing you into that mode. It shows you a very large number of the critical rights and wrongs, and it should be read by everyone who is shifting to that type of development. There are many things acceptable in the desktop that are unacceptable in the handheld and it is necessary that you learn them before you begin.
   The improving combination of better batteries, more electronic power in a smaller space, higher quality wireless signals and improved content means that developing for the handheld is an expanding market. From this book, you can learn the fundamentals of presentation, a necessary first step in creating the applications that will continue to feed the expansion.

No comments about Enterprise Ajax (Video Training): Building Robust Ajax Applications (LiveLessons).

5 comments about Professional JSP 2nd Edition.

1. This book is awesome. The one thing I truly love about this book is the layout. I had zero experience in JAVA/J2EE and after the first chapter it all made sense. I Actually make time to read this book.

   The one thing this book does that no other I have read is tech the low level nuts and bolts along with top level syntax and make it make sense. For instance, the chapter on Servlets rocks. It teaches Servlets on both "Here are Servlets" and "How to use them".

   I highly recommend this book for anyone wanting to learn JSP/Servlet environment. It is a great book to learn the big picture and be able to use all know features in the technology.




2. Wrox Press continues their time-honored tradional of piling as many authors into one 1200 page volume that they can in the hopes that they will end up with a definitive treatment of the subject. The authors range from seasoned professionals with real-world experience to people with nothing but a year or two of college computer science courses behind them. I must confess that I am not sure what I was expecting in these chapters but since JSP Tag Libraries seemed to be one of the more challenging and interesting areas of JSPs I was hoping for some more meaningful, 'meaty' content.

   The assembly of these 18 (yes, 18!) authors wind up generating a book that essentially could have been put together with more precision and continuity if it had 15 fewer authors. It very much comes off as a rushed effort, without any tightness whatsoever. The writing style of this second edition can only be described as amateurish. This, fortunately, can be a little easier to swallow if you accept the spirit of the book (in Wrox's words 'Programmer to Programmer'). Take the text as quickly put-together material from programmers that have been through it (even if it was brief or only in school) and you should be fine.

   Many unnecessary forward references exist throughout the text and, because of the unusually large number of authors, there is a large amount of repetition in the body of most chapters. The book's page count could also have been greatly reduced had the authors not consistently given condensed introduction to material that ends up being the subject matter for entire chapters later in the book. For example, two early chapters describe the basics of Tag Libraries, only to have them surface as the primary topic of chapters 8 - 11.

   The code included throughout the book is variable in quality, as you might expect. The book doesn't pretend to be an academic tome of best practices or a showcase for some top-flight, brilliant programming but you end up thinking that many of the examples could have been made much more effective with more thought put into them. As with many other programming books out there, this one is definitely not without its errors. You'd hope, however, that with the 21 technical reviewers and 3 editors that worked on this book that it would have fared better than most.

   In summary, if you take the text for what it is and skip over the segments of fluff and numerous poor code examples I think that most professional programmers new to this technology will find enough material to make the hefty price tag almost worth it (especially if you share it with others on your team!).




3. I have never read such an excellent book before. No wonder the JavaRanch community rates this book 10 horseshoes!



4. Explains one aproach then rejects it in favor of another then yet another. By the end you discover that you should have bought a book on Jakarta Struts if you want to develop real JSP sites because someone has already done lots of work for you.



5. I thought to learn JSP just by reading this book. I read several review comments on this book and other books. Fairly thougt to buy this one on hope of better explanation.
   Though I am new to JSP, but working on programming for 13 years.
   1. I did not get a streamline explanation to start the first program. Someplaces exaplanation is too much, I was lost.
   2. Explanation on Tomcat installation won't be helpful because of older versions.
   
   Those have already known JSP TAG, Bean etc. it may be helpful for them. But purely it is not for beginners.

No comments about Implementing Simple to Advanced Computer Science Concepts in Java.