No comments about Java Programming I and Ii Custom Edition.

1 comments about JSP: Practical Guide for Programmers (The Practical Guides).

1. This is a slim and easy to read book which covers JSP 2.0 in just about the right amount of detail to get a competent Java programmer up to speed quickly and effectively. As well as JSP there is a also a very brief and shallow introduction to a few other associated technologies: servlets, CSS etc.

   The writing style is polished and comfortable, but a worrying number of typos and other errata have slipped through the editing process, in particular in the first part of the book. I suggest it would be a good idea to check the associated web site before relying on the printed code and configuration examples. I'm also uneasy about the choice of example application used as a case study throughout the book. While everyone is likely to understand the idea of a bank, the examples given neither make a very convincing bank, nor make particularly good use of JSP technology.

   This book will be useful for anyone starting work on a web application project which makes use of JSP 2.0, but who doesn't want to wade through the specification documents. If your project still runs on an older version, this book will only be frustrating, but it might just tempt you to upgrade.

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 Applied Evolutionary Algorithms in Java.

1. Java being the choice language for enterprise no-bs concrete applications I was expecting a practical viewpoint and a hands-on approach in this book. It turns out this skimpy booklet is
   more of a an extended paper, something like a thesis with no practical value ( and hence no value at all). It won't teach you neither GA algorithms nor how to use Java to code them. The Java
   word was put in to fool buyers exploiting the Java marketing wave. The only java GA algorithm presented in this book is in appendix B.... can it get worse than this?



2. I only browsed the book but I perfectly agree with my friend from milano. Another one of those little useless trash marked with high price because they knew there would be few buyers. How can my favorite publisher Springer join this business? (John-Wiley seems to be the pioneer on this.)



3. I completely agree with the previous reviewers. In fact, I found their criticism rather light. On the back cover, the book is presented as an introductory book with pratical emphasis. Although the book is very easy to follow (reading it cover to cover takes about 2-3 hours), it's definitely not at an introductory level. It covers basic material on GA & GP without sufficient detail. Furthermore, the design of the book is terrible. The author has allocated 105 pages to bibliography and appendices (the book has 225 pages). Therefore, the core material occupies only 120 pages. Moreover, the 2 chapters about GA and GP are totally 30 pages long ! The remaining 90 pages are about some not-so-interesting applications and future directions in EC. The bibliography is not at the end of the book. This makes following the references rather frustrating.

   I've read/browsed at least 10 books on GA/EC. This is definitely the worst one. I recommend Eiben & Smith's "Introduction to Evolutionary Computing" and Michalewicz & Fogel's "How to Solve It: Modern Heuristics" to everyone interested in GA/EC.




4. I haven't read this book yet (hence the intermediate 3 stars rating), but I think people should know that, [...] See e.g. http://www.techbookreport.com/tbr0031.html



5. Actually I disagree to most of the comments submitted by other reviewers - In my opinion this book is really great, especially for people who are new to the areas of Evolutionary Algrorithms and Programming and particulary looking for ways on how to apply these technologies in practical terms. There are not many books out there which are (1) easy to understand, (2) provide sufficient and "what-you-should-know" type of information about the discussed technologies and (3) application-oriented and practical rather than theoretical. This, in my opinion is very important as it allows the reader also to understand how e.g. GA's can be implemented. Also the use of JAVA language for the practical demonstration and examples are very handy since it is currently one of the most widely used and popular programming language.
   I believe that this book is very suitable as a course material for students (like me) who are new to the areas of Evolutinary Algorithms. In addition, it provides a large survey of references and websites where evolutionary code is available.

5 comments about Essential Java Style: Patterns for Implementation.

1. When I first read this book it was hard to keep an open mind. The author constantly compares Java with Small Talk. Unfortunately in keeping an open mind I over looked the bad coding style. This could have been an excellent book for beginner programmers that wanted to write professional code. However, the author writes code in the style of C++ and Small Talk. The author's code should not be used as a template, which is what most beginner programmers will do. Another problem with this book is that the author has made assumptions that all the techniques he has learned from other languages will work the same way in Java. This is not the case. While this book does contain some valuable techniques, I believe that the poor coding style and the author's lack of understanding of Java will mislead beginner programmers. Therefore I can only rate this book 1 star.



2. I guess the author didn't think his book would sell without the word patterns in the title. This is not a patterns book. It is a book of very basic coding techniques that every junior programmer should be taught. However, I have to agree with a previous review that this is 'Not Java Style'! The author uses a non-standard style, at least not standard Java style. If you decide to read this book be prepared for the incessant comparisons to SmallTalk.



3. The "patterns" in the title of this book refers to a collection of coding principles for translating object-oriented designs into Java programs. This is not a design patterns book, but rather a book on Java style, usage, idioms, and best practices.

   Because the author comes from a Smalltalk background, the patterns are highly object-oriented. This may be disorienting to developers from a C++ or procedural background, but the longer I program in Java the more I'm convinced that purer OO code is better code. Developers who use UML or object modeling in the design phase will get the most mileage out of this book.

   One of the main uses of the book is for use during code reviews. The patterns are named so that you can say "this code should use the Default Value Constant pattern" rather than "I think rule #87 should be applied here". Some of the patterns will be obvious to experienced Java programmers, but are included because many teams have junior programmers who are new to Java. Unfortunately, the book is not organized so that you can quickly find the discussion of a particular pattern. The Pattern Summary does not include page numbers and the Index includes all page numbers where each pattern is mentioned, without bolding or italicizing the pages where the pattern is described.

   There are a number of idioms specific to Java that are not covered well in the book. The section on equals does not cover the important case of implementing equals in subclasses and doesn't mention that hashCode should be consistant with equals. There is no coverage of using clone to make copies of objects. In addition, there is a significant amount of outdated and incorrect information. I would recommend using this book in conjuction with another book on Java idioms, such as Effective Java or Practical Java.

   Much of the book is distracting because the author continually points out the "deficiencies" of Java. I do agree with many of his comments, but they serve no purpose in this book and quickly become irritating. The frequent comparisons to Smalltalk and C++ are also of little use. I did find that the brace and variable naming conventions did not adhere to Sun's coding conventions, but other than that the book uses standard Java programming style.

   Overall, the book is a good one, but I look forward to a new edition that is expanded, corrected, updated, and doesn't have so many useless comments.




4. I think this book is fantastic. I've used this book for coding standards and just to generally improve coding techniques. While it's not quite as good as Refactoring I think it's a good introductory level book with enough content for intermediate programmers.

   Being a code style book it's nice to see well laid out code. The explanations are thorough although sometimes confused. Of course, he dodges the curly brace question.




5. I wrote Essential Java Style six years ago. At that time, Java was still a new language, yet lots and lots of poorly written code already existed.
   
   Today, there is significantly more poorly written code, and unfortunately, only proportionately more well-written code. It seems like we haven't learned how to write maintainable systems in Java.
   
   I wouldn't change much of the core message in EJS were I to do a rewrite of it. But I would emphasize the three central "patterns" even more: Composed Method, Naming, and the Comment antipattern. Using only these three guidelines as a basis will immediately improve the maintainability of your system.
   
   A rewrite would certainly include more detail based on my experiences in Java. More dramatically, however, the core message would be tempered with the admonition to always write tests for your code. Through test-driven development (TDD) I've found that it's very easy to get into a good habit of keeping your code clean.
   
   To answer some of the review comments:
   - the book states the obvious only to those who know what good code is already. Unfortunately this is less than one in five developers.
   - I admit that it was intentionally subtitled with the word "patterns" to attract more attention. The material presented within *is* in pattern form.
   - a few readers complained about non-standard style. There were only two things that were supposedly non-standard: brace placement, and the use of underscores for fields. Honestly, there is no absolute standard for either of these.
   - the book takes a lot of ideas that work well in Smalltalk and applies them to Java. For the most part, this is a valid approach. I'll admit thought that the Smalltalk-like collections approach, unfortunately, isn't a great fit in Java; I no longer bother with them.
   - I counted the number of references that denigrate the Java language (mostly for being slow). There were 6. Chalk it up to a sense of humor and frustration at an immature language.
   
   Thanks if you purchased the book! I still see people's references to their dog-eared copy and their happiness with the extent to which they've taken the ideas to heart.

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 Professional JSP Tag Libraries.

1. Professional JSP Tag Libraries has great, effective content that Web programmers will appreciate.

   It would have received 5 stars, except for the fact that there are technical errors. Each one isn't major, but it does affect the text's consistency and fluidity. For example, the diagram on page 41 that reveals the Web Archive File Structure misspells a directory name where the tag library descriptors are placed.




2. Title: Professional JSP Tag Libraries
   Author: Simon Brown
   Publisher: WROX publisher Ltd.
   ISBN: 1 861006 217

   Reviewer Name: Ravi Mahalingam
   Review Date 23 Apr 2003.

   Overall Value of the book: 4
   Instructional value of the book: 4
   Reference value of the book: 5

   Like every WROX, this book covers different aspects of tag libraries
   of JSP (custom and regular) in a detailed fashion. The author Mr. Brown
   has done a good job to explain the concepts of tag libraries.

   the book has useful code snippets that can be used for real
   world problems. the book also provides screen prints of the
   actual output making it easier for the readers to find out the
   result of the code.

   THE author has explained how STRUTS work and has explained
   it in great detail.

   overall, this book is a good reference and will find a place in
   my office shelf. we are in the process of developing a jsp
   based user application which uses STRUTS.

4 comments about Java XML Programmer's Reference.

1. This book is an excellent reference for the Java XML API's. It is up to date on SAX 2 and DOM/DOM extensions. It also gives a good intro to many recent developments like SOAP and IBM WebServices Tools. An advantage of reading such a book is that it makes you familiar with many of the good features of API's - which otherwise I would have never bothered to look up. The chapter on JAXP is particularly well presented. I liked the case study in Chapters 12-15 which highlight techniques for configuring, querying , storing and transmitting XML - these can be put to use straight away. On the flip side, I would have liked to see more examples in each chapter on the usage of API's. I would have also liked some more focus on XSLT. Ant has been used extensively - and at first I found this a little disconcerting as I had not used Ant earlier.



2. I found it to be a very comprehensive and complete book on XML. One of the biggest problems with XML related books in general is that i have to refer to 2-3 books to solve a 'business problem' as the books seem to be focused on one or two aspects of XML. With this book though the authors seems to have taken the approach of solving real life business problems with XML going into just the right level of details and providing great examples, I really liked the business case study and the Apache chapter. In short, it was just what i was looking for as a person who is learning xml and most importantly trying to use it to solve real world problems.



3. Java and XML are intricately related to each other and its importance is growing in building J2EE solutions. For any professional developer who is aspiring to build Enterprise Applications, knowledge of XML is a must. But more important than that is to be able to use the Java API's for XML. In a period when information about these is scattered and difficult to gather, this book has all you require to get started with Java XML in one place. The layout is perfect, the material is flawless and uptodate. The API's have been supplemented by useful examples where required which show exactly what can be done. Its a must buy for anyone. I never repented owning a copy. And my recommendation is - Go get it!



4. Being a Java developer and wanting to learn how to use XML technologies with that language I had high hopes for this book coming in. I had read the editorial review, have a high opinion of Wrox books in general, and was looking for a book that covered the scope of topics this book claims to cover. I was disappointed.
   For the most part the text covering the various technologies, e.g. XML, SAX, DOM, JDOM, JAXP, etc., is a reformat and JavaDoc of the specifications. Almost every chapter opens with something like this from chapter two, 'This chapter contains the same information as the SAX 2.0 API specification...', and indeed it does. At least they're up front about it. The saving grace of each chapter are the small utility code bits, written in Java, that demonstrate the syntax of doing things but there is little elaboration.
   As a reference this book pulls together a lot of technology into one place and puts it at your fingertips. Of course, by the time you've learned a couple of these sections the rest of the technologies in the book will be out of date ;) so you might be better off just bookmarking the reference pages on the web.
   The Wrox motto is 'Programmer to Programmer'. They must mean mouth-to-mouth resuscitation after you've tried to plow your way through a few chapters of this book.

No comments about Beginning Java.

4 comments about .NET Development for Java Programmers.

1. Having concentrated on Java for several years, I procrastinated switching gears in order to come up to speed on .NET. It turns out to be simpler than I thought, at least when you have this book.

   The author calls out every major feature and system of Java, comparing and contrasting its analogue on the .NET platform. His explanations are concise and the examples are very clear--so clear, in fact, I found he even answered lingering Java questions for me. Paul Gibbons leverages the many patterns familiar to all Java programmers, making .NET very approachable (and much more concrete).

   This book seems to spring from the author's own practical experience, which makes it that much more valuable to a "working programmer." I highly recommend this book for anyone faced with learning .NET, but especially those who know Java. Their experience, combined with this book, will make the process a breeze.




2. The book provides an overview of .NET-programming using C# as the programming language. The author assumes that the reader is familiar with the Java language and J2EE. When introducing a .NET aspect, he explains the differences.

   The book starts with a 50-page description of the differences between C# and Java. The author touches on most aspects of C##, but his analysis is not comprehensive and I don't understand the rationale behind his selection of topics. He spends two pages and quite a lot of code to explain how override the true and false operators, but he barely touches topics such as creating and destroying objects or basic things like literals, operators, ... He is also struggling to explain the innovative aspects of C#. Understanding his explanation of the events and delegates is quite a challenge. And although he uses attributes in his chapters about XML and Web services, he doesn't explain the concept at all. I also feel that the author should have written something about streams (another concept he uses without explaining it), collections and regular expressions.

   After completing his C# introduction, the author starts to write about Winforms, ASP.NET and ADO.NET. IMHO, he wastes too much space with Visual studio screenshots and with descriptions how to click your way through Visual Studio. Visual Studio is not the only way to develop .NET applications. At least, there is the Mono project and Microsoft own freeware Webmatrix (for ASP.NET/ ADO.NET applications). In addition, Visual Studio does a good job to hide at least some aspects of the underlying technology: But the author obviously thinks that showing how to use Visual Studio is sufficient to expose the inner workings of a .NET aspect. In his description of ASP.NET, the author mentions some analogies to servlets and JSP, but fails to explain them. An example: "Server controls have more in common with JSP taglibs but are more complex to develop than user controls, as they support the roundtrip." That's all about the analogy, the author continues with some Visual Studio clicking. The more complex the concepts are, the more difficulties the author has to explain analogies between Java and .NET concepts.

   The description of the other topics (multithreading, networking, remoting, XML, COM+ components, message queueing, directory services, packaging of applications, Windows services, calling ummanaged code) is in a similar shape. There are some gems in a pile of difficult to digest explanations, code examples and screen shots.

   IMHO, this book isn't a good .NET introduction. And it needs more work to be a real timesaver for a developer moving from Java to .NET.




3. Was delighted to open the book up. The author does not treat you like a complete novice and assume certain level of automatic understanding from the readers. I was able to cover the quick introduction to the common features in the C# language. Rest of the chapters have a lot of example scenarios in it so helped me with getting my arms around day-to-day problems quickly.

   However, some of the areas I had hoped the book would help me:
   1. There is no treatment on file systems. In Java, there is a strong support for reading/writing file systems, but the book totally bypassed this.

   2. Delegates - This is new concept in .NET and I had hoped the autor would explain this topic in more detail in the early chapters, and especially since the Event management is heavily based on the delegates concept.

   Overall, a good and useful book for quick induction into .NET world.




4. Was delighted to open the book up. The author does not treat you like a complete novice and assume certain level of automatic understanding from the readers. I was able to cover the quick introduction to the common features in the C# language. Rest of the chapters have a lot of example scenarios in it so helped me with getting my arms around day-to-day problems quickly.

   However, some of the areas I had hoped the book would help me:
   1. There is no treatment on file systems. In Java, there is a strong support for reading/writing file systems, but the book totally bypassed this.

   2. Delegates - This is new concept in .NET and I had hoped the autor would explain this topic in more detail in the early chapters, and especially since the Event management is heavily based on the delegates concept.

   Overall, a good and useful book for quick induction into .NET world.