2 comments about Codenotes for Java: Intermediate and Advanced Language Features.

1. If you are looking for a comprehensive guide, this is not it. However if you are looking for quick concise answers on such topics as reflection, interfaces, inner classes, localization, you might be happy to learn that this book won't leave you high and dry. It depicts each topic with just enough theory and examples to get you on your way. The section on localization is very good if you wish to get a quick intro to localization. Reflection is also very nicely highlighted in this book. I wish I had used this book before I used reflection like maniac throughout my projects.
   Another cool thing about this book is the price. Under [priced]for a good Java book is something I really like given the fact that I buy books at an astronomical rate.
   Enjoy,
   Will



2. Similar to "Cliff Notes" for literature, but addresses basic Java language topics. Does a greate job pointing out "gotchas" that don't show up until you get deeper into programming. Thus, by reading this book you get some good coding wisdom early, rather than learning it the hard way at your own desk. The book is also quite terse, and gets to the point quickly. Complaint: Exceptions are fundamental, yet this book barely mentions them. A major omission.

No comments about SAS Graphics for Java: Examples Using SAS AppDev Studio and the Output Delivery System (SAS Press) (SAS Press).

3 comments about 4x4 Generative Design (with Auto-Illustrator, Java, DBN, Lingo): Life/Oblivion.

1. I think this book is a great idea, so three stars. ... Here we have yet another collection of chapters by designers who haven't communicated with each other, and apparently don't have a strong editor with an overall vision, so the book doesn't develop an idea throughout. That's fine if you like the rockstar approach, but why not just look at these guys' websites instead?

   The problem with this is that there's just nothing new here. Everything here, and I mean everything, is available on the web, especially if you make contact with people and learn from work they've done.

   Still, it's nice to see a somewhat unusual topic get a whole book, and Golan Levin is a genius, full stop, so I'm glad he's getting noticed.




2. An excellent and original book with interesting subject matter. A great source of innovative approaches to experimental image making and design. I found all of the tutorials to be easy to follow and enlightening, especially Lias work with Director. Being able to go "behind the scenes" with one of the creators of Turux.org and see how some of those amazing Shockwave pieces were made is invaluable. The personal essays were all very inspirational and interesting to read as well. This book is highly recommended for those who want to take their artwork into interesting new directions. I hope Friends of Ed makes more art/essay/tutorial books like this in the future because the format is great!



3. In one word : EXCELLENT! In a litlle more words : this book is a perfect realisation of a designer's dream. Each chapter, written by a different author, gives you all the insights and reflexions of the artist upon its work, and the way he/she uses inspiration, and , on the same time, they introduce you to a programming tool in a very clear way by giving a documented example of code.
   Lia's introduction to Director/Lingo is amazingly direct, simple and clear and gives a very nice resulting piece of work.
   Golan Levin's chapter in very inspirational, he somehow takes the intuitive approach of his former professor John Maeda from MIT, but goes further in explanations. He takes the step between idea and code, giving you a "double-scaled" example : a simpler code in DBN (Deisgn By Numbers), and a more complex and powerfull one in Java. The resulting piece is again brilliant, as is G. Levin.
   I do think that there is a strong editorial approach in this book : it's to give each artist the space to express him/herself without the necessity of a global view. In fact, I think this is one of the best aspects : it shows you that there is no "global approach" to generative design. Instead, everyone is playing with their favorite tool, or constructing new tools in order to escape the uniformisation process of digital design.
   It is true that some parts may be found on the web, but not everyone can be in direct contact with those artists, so I found their explanations of their own work very inspirational and i think it was a great idea to ask the artists to remix each other's works and to comment on them. (Btw, the reader is also invited to do so, and all code is availlable on the web).

   Conclusion : a BRILLIANT and ORIGINAL approach to digital design, and probably one of the most usefull book on this particular matter.

5 comments about Pro Jakarta Struts, Second Edition.

1. Bought this after seeing so many good reviews.
   This is a okay book. May be 3 stars.
   Lots of room for improvement.
   Every rating with a 5 star - Sure sounds fishy to me



2. Pro Jakarta Struts, Second Edition by John Carnell with Rob Harrop is the best book on developing Struts-based web applications I've read. (I've read at least five or six others.)
   
   The title of the book is a bit of a misnomer, as it covers much more than just Struts 1.1 fundamentals. This book aims higher, including chapters on web application Patterns and Antipatterns, XDoclet, Velocity and ObjectRelationalBridge, along with the good explanations of various Struts-specific topics.
   
   Pro Jakarta Struts, Second Edition is a pretty thick book at 578 pages. I didn't notice a single page wasted to printing some API. It isn't really a technical cookbook to be placed on a nearby shelf for quick reference during development to look up the basics of using some technology. Instead, the authors focused on good practices used when developing web applications, including explanations of why a technology should be used and how to use it, recurring problems that others have experienced (Antipatterns) and what to do instead (Patterns), and other pieces of advice designed to get the reader's brain thinking in web applications.
   
   If you're in the market for a book on Struts-based web applications, get this one. It covers Struts 1.1 well, but it doesn't stop where Struts leaves off.



3. This book offers too much discussion of general software engineering. I suppose an enty-level developer might find that useful. I just wanted a book that teaches Struts, from "Hello, world" to the dirty details. If you already know the benefits of n-tier applications, much of the text is a waste. If you already know the value of design patterns, and how to apply some, then much of the text is a waste.
   
   I found the Wrox book, Professional Jakarta Struts, to be much more focused and useful. That book sticks to the topic, and provides very good reference information on the configuration file and tag libraries.
   
   Having said that, I did find the chapter on XDoclet to be useful.



4. I believe this book is full of good Struts information however the idea that you will learn it by building a sample application is just not true. After setting up a development structure in chapter two the author leaves you on your own to figure out where to put the files your creating or modifying. Although you can figure this all out on your own it detracts and distracts you from focusing on the real details he is trying to teach you. Also there is no readme.txt in the downloads from the apress site as is written in chapter two. All in all this is only an average text for learning struts due to the lack of direction with the examples.



5. The book provides a good introduction to Struts and a starting point for more advanced topics & design patterns which may be found on-line. It does cover simple scenarios for extending the stuts framework. May be usefull for those who are not familiar with related technologies such as
   xdoclet, commons logging, and OR mapping. Overall it is not an advanced book.

2 comments about Software Engineering With Java.

1. This book examines the issues associated with good software engineering practices in a detailed and comprehensive fashion. The author examines every aspect of constructing software including life cycles, OOD, testing, and proposes hierarchies for software development groups. His observations are detailed and his language is clear and precise.

   Not only does he examine the use of Java in adhering to good software engineering principles, but he examines the Java language itself as an example of good software engineering techniques. A detailed, real world product design is included in the book to illustrate its concepts.

   This book is not just about the Java programming language. It is about the construction of meaningful software without all of the flaws which have become so standard in the industry. For the aspiring software ENGINEER, this book is highly recommended.




2. I Think all related with the Software Engineering is very importan in these confused days with a lot of thecniques, roles, "gurus", etc. The software developement must be realized with Software Enginnery Thecnics if we like to get a quiality product. To find a book what help with this topic, and plus related with JAVA, is a great think ! Thanks for let to know about this interesting relation !

No comments about Beginning Java.

4 comments about A Java Library of Graph Algorithms and Optimization (Discrete Mathematics and Its Applications).

1. There are so many problems with this book, it's hard to know where to begin. So I don't come across as all and only negative, I will first give it credit for gathering together, at least in name a large number of graph processing algorithms.
   
   That said, here are the problems:
   
   The book is just a catalog of graph algorithms with poorly done documentation and even worse actual code. To wit:
   
   
   *Each algorithm is preceded by a very brief explanation of what it does and some of the issues involved. Suffice it to say that it's the sparsest and most minimal explanation imaginable; if you don't already understand the issues involved, you probably won't after reading the short paragraph or two that precedes each algorithm / method.
   
   *There is but ONE class and every bit of functionality is contained in its own individual, single static method. This "design" causes not a few of the methods to literally run to a thousand and more lines and contain dozens and dozens of (cryptically named) member variables.
   
   
   So for instance, if you are interested in planarity testing, there's a "method" called planarityTesting that takes four parameters and returns true or false.
   
   All well and good until you actually look at that method and see declared 51 , that's fifty-one, member variables. Each of these variables has poorly chosen names like, "wkpathfind2" and "store2" and "store3" and of course "store4" and "sortptr1" and "sortptr2". I thought this tactic of vowel-conserving naming of variables went out with the 8 + 3 DOS naming convention. At any rate, the cryptic naming scheme combined with the lack of javadoc combine to render each variable's purpose completely opaque. This makes it all but impossible to relate the code to the underlying graph theory.
   
   Then comes the code.
   
   Imagine a thousand and more lines, literally page after page after page of streaming code, all one single method, manipulating these cryptic variables in virtually uncommented ways.
   
   That is pretty much what you get with this book. One algorithm after another after another.
   
   I would say the following:
   1) the author codes as if from another time. There is NO object-oriented design to this code whatsoever. None. Zero. Zip.
   
   2)The methods are hundreds or thousands of lines of what amounts to undocumented symbol manipulation. There is small chance to learn anything from this book with respect to relating the code to graph theory.
   
   3) I can say that, having implemented many of the algorithms in this book myself prior to buying this book, the book has contributed nothing to my understanding and further, that already understanding the issues surrounding many of these methods, that is being a qualified reader, is NOT sufficient to allow the reader to follow and understand the algorithms.
   
   4) If you only want to use the (static) methods to return a value or ascertain some property of a graph and you don't care to understand how it works or why it works, then perhaps you'll be happy with this book, but then , why not release the object code as blackbox library? If the code was never meant to be read, and there is no attempt at explaining graph theory as it relates to the code, then what of value is left for the reader?
   
   
   
   5) Finally, if the purpose of the book is deliver a good "black-box" library, readers should know that the actual implementation of the graph "object" chosen in this book makes will make that problematic. The book uses an adjacency matrix to represent the graph, a well known data structure in graph theory. Unfortunately, this data structure has the following well-known problem: it is only suitable for the rare instance of dense graphs. The runtime performance and memory demands of this data structure make it unsuitable to any but very very small graphs. Most graphs are neither very very small nor very very dense, (as dense is defined in graph theory), and for that reason almost all graph drawing packages opt for a linked-list data structure to represent the graph.
   
   This is solidly the worst book on this subject I have yet encountered. Amazon offers a number of alternative books, including the fine Graph Algorithms, Third Edition by Robert Sedgewick and Michael Schidlowsky, a book I have no connection with whatsoever and two authors who are otherwise unknown to me. Bundle of Algorithms in Java, Third Edition (Parts 1-5): Fundamentals, Data Structures, Sorting, Searching, and Graph Algorithms, Third Edition



2. This library of ready-to-use programs is extremely useful. I have used the programs with very minimal effort in obtaining solutions to some graph optimization problems. Unfortunately the programs are not well documented; it would be a challenge to make modifications to the code. However, the library serves as an ideal black box tool in solving most of the pedagogical graph theory and optimization problems, especially well suited for users who are not of much concern for the underlying methodology and implementation.



3. This is my third review; my two previous reviews have been removed. I have already notified Amazon about this fact
   
   As I have stated, book is just a printout of Java program, without any explanation how program is doing what is doing, what are program limitations in terms of memory, time and complexity. Programming style is mostly Fortran IV like. Programs are without single line of comment and with non-intuitive variable names, what makes modificatios difficult or impossible. Book can be useful for somebody who needs "black box" library, doesn't need to understand programs and trusts the author that programs fave no flaws



4. There are many well-written textbooks that cover the theory
   and algorithms on graphs and combinatorial optimization.
   Very few provide the computer code for the methods. This
   book offers an extensive collection of Java programs in
   this area. Each program is self-contained and can be used
   independently through parameter passing. The drawback of
   the book is that the coding style is not object oriented,
   and the programs would be difficult to maintain. The
   description of the methods and their implementations is
   terse. Hence the book is not intended as a learning text.
   But the library of programs is a very convenient handy
   device for students and researchers in locating solutions
   to classroom didactic problems in graphs and optimization,
   which apparently is the main objective of the book.

5 comments about Program Generators with XML and Java.

1. Agreed that XML may not be the best language to capture domain
   specification expressiveness. But use of XML/XSLT to do
   custom code generation has the benifit of rapid application
   prototyping and development. The crucial fact is that the
   domain specification is captured in XML only relatively few times
   and project software developers mainly use the generated code.
   The question is how many people in the project is exposed
   to 'ugliness' of XML and how many times. The advantages
   of 'neat' code generation far outweigh the disadvantages
   of 'ugliness' of domain specification in XML.

   In a real Network Management Software development I achieved
   60% of generated code (EJB, SNMP, Java utilities) by using
   custom code generation by XML/XSLT. Only myself dealt with
   XML other software developers happily used generated code. You
   can imagine the lead the project had and continues to have
   because of use of XML/XSLT in project specific custom code
   generation. The code generation system is stable now -- any new
   addition in EJB, SNMP model results in thousands of lines of
   Java/SQL/XML/SVG code without any additional effort.

   I would, therefore, continue to recommend the book as worth
   exploring. This book really contributed new techniques in
   software development. More specically with XML/XSLT you have
   freely available tools to implement "model driven programming"
   in your software project.




2. This book is definitely interesting in understanding how code generation works and how to utilize some of the newer technologies like XML and XSL to generate software. I am very impressed with some of the new, advanced code generators like CodeCharge, which utilize XML and XSL but do not give us insight to the internals of how it works. While those tools prove that XML and XSL are great for generatng code, this book explains how it is done.



3. The ideal reader for this book would know Java, but would know nothing about program generators (or compilers) and nothing about XML. They'd want to take things slowly, and wouldn't mind if they didn't get very far. In return, they'd get a surprisingly long introduction to "domain analysis", a decent medium-length introduction to XML and XSL, a quick look at using the Java DOM parser for XML, and some examples.

   I was disappointed with the lack of discussion of program generator basics, most fundamentally when to write a program generator versus when to write an interpreter, a parametric program, or as is more typically required, some mix of these approaches. And what about wizards, the most transparent modern incarnation of program generators? And how does this all interact with frequency of program generation and version control? There was no discussion of programming language basics like semantic versus syntactic well-formedness and error reporting, which have their peculiarities in XML and Java.

   A primary concern with the whole XML (not to mention Java) enterprise is scalability. There was no discussion of writing efficient program generators; SAX is only mentioned in passing! Even more surprisingly, there is no discussion of generating efficient code, the latter being a primary motivator for many program generation efforts.

   Despite the daunting number of pages, this book can be read in one sitting due to the huge font and wide margins.




4. Cleaveland hits just the right balance in his unique
   book on program generators. Just look at the negative reviews.
   The review by Carpenter whines about not getting enough XML
   in his book. Thank God, Cleaveland doesn't waste
   our time and money on just learning XML. There are
   plenty of other books that do that. Cleaveland
   rightly focuses on how to apply XML to Program
   Generators. The other negative review, "Soso", whines
   about the exact opposite; that there is too much XML.

   Again, thank God, Cleaveland doesn't do that either,
   but rather shows the proper role of XML in the
   design of Program Generators, namely that XML is
   an abstraction interface for the separation of concerns
   between expressing specifications
   and transforming specifications. Kudos to
   Cleaveland for getting it just right!




5. I can only assume that Mr. Cleaveland was attempting to woo the legions of Web site developers into writing program generators (PG) with this book. The book centers around a pointless example of how to generate pop-up web pages which call each other when their respective buttons are pressed.
   Out of the 13 chapters, 3 are worth mentioning. Chapters 4, 6, and 7 deal with what to consider when writing a PG and how to make it flexible and Mr. Cleveland does bring some worthwhile points to the table. Throughout the other chapters, trivial code snippets are given of how to write the code (in Java, DOM, and XSLT) to generate the pages, however, because the examples are so simplistic any one who knows these languages would know how to write them anyway.
   In the future, I would strongly recommend the following:
   1. Give examples that people will actually want to use
   2. Give examples that highlight your points
   3. Get rid of chapters 2 and 3 (domain analysis), they are useless.

5 comments about Sams Teach Yourself JavaServer Pages in 24 Hours (Sams Teach Yourself in 24 Hours).

1. I am prejudiced against books that have 24-hours or 21-days in their title. They usually are like a sloppy sandwitch that your 2-year-old will put together in 2 min!

   This book is different.

   I have to agree with previous reviews - setting up Tomcat is never trivial. it took me a long time to get used to the vagaries of Tomcat. No book can document the Tomcat fully since by the time the book is out in the market, the Tomcat version has changed beyond recognition!! I have long since given up trying to look for a book to tell me how to set up Tomcat. Use of the web resources instead is very effective for this purpose.

   Beyond that, this book packs the most effective set of JSP programming tutorial. The topic is huge - please check out some of the Wrox Publ books! But the author does a good job of presenting 60-70% of all that info in not-so-confusing easy-to-work-with examples. There are some code snafus but these are trivial; hey, I am yet to buy a book without code mistakes.

   If you really are serious about getting a good jump start on Java Server Pages, this book is a great springboard. You do need to graduate to a "Professional JSP" book right after that for some production level work.

   I still consult this book when I need to brush up on some basics. Neglect the "24 hour" phrase, and you have yourself a decent JSP book.




2. I would not buy this book again. There are a number of problems with this book. As other reviews have noted, it doesn't give much, if any, help in setting up either Tomcat or BEA's WebLogic server, which comes on the CD. Tomcat isn't surprising, as both of the authors work for BEA, but the lack of information about WLS is.

   The book is badly organized. First of all, it's full of forward references, presenting topics in small bits without much explanation, then saying "We'll cover that later". It also has multiple dislocations; for example they cover "Arrays and Collections" in Chapter 7, then have a sidebar on "Arrays" in Chapter 9. The book is also badly edited, with numerous errors, particularly in the code examples, which make them hard to work out. The index is severely lacking; for example Listing 8.3 uses a "page import" command which was briefly covered in Chapter 6, but there is no reference for this in the index. Finally, all of the examples in Chapter 8 do not work correctly as listed; they require special setup of the server and no explanation is given on how to do this.

   Overall you will be happier with some other book. I dumped this and went to the O'Reilly "JavaServer Pages" book which so far is much superior.




3. I do not have enough bad things to say about this book. The part that is most ambiguous is in trying to set up WebLogic. The two authors, being from BEA, should have been a little more detailed in their explanations. If you are new to Tomcat and WLS, DO NOT BUY THIS BOOK!



4. In the arena of dynamic web content generated on a server, the world seems to be moving towards the two technologies of active server pages (ASPs) and Java Server Pages (JSPs). I have recently seen an increase in the interest in JSPs, so I began developing a course. I started that process by reading this book and performing most of the exercises. I found the sections on using JSPs to be very straightforward, the examples were easy to understand and implement. After completion of the book, I was able to move on and write my own material for the course.
   One problem that I had at the start was when I tried to use this book as my resource to get the Tomcat server running on my machine. The amount of information in the book is inadequate for that task, although I was able to get Tomcat running after examining the Tomcat documentation. A second criticism is more serious. While it is a slow transition, the world is moving towards the use of XHTML. Therefore, in my opinion it is time that technical books start using it rather than the old sloppy HTML. There really should be no place for doing things like not having a closing paragraph tag associated with all opening paragraph tags.
   The book is an adequate to good introduction to JSPs and if you are a beginner, it will get you started in an easy manner. Advanced users should look elsewhere.



5. This book amazed when I first sat down to read it.
   After encountering the first few errors, I decided to write them all down.
   - After reaching the 15th error after about 40 pages, it was
   just too much!
   - The authors don't even provide you with code samples that work!
   - They don't go into any level of depth when explaining
   something (I know this is a beginners book, but at least don't
   write something that is not true, just because you assume your
   reader are not JSP/Java experts).
   - I wouldn't dare charge more than $10 for such a low-quality
   work.

No comments about IBM Technology for Java Virtual Machine in IBM i5/OS.