3 comments about Sun Java(TM) Studio Creator Development Pack: Field Guide and Creator Software Package.

1. I just received my copy of this package, so I haven't had time to thoroughly review the book (but what I have seen is very good). I wanted to point out something for Mac OS X users... the CD that comes in this package does NOT have the Mac OS X version of Creator on it. It has the Windows, Solaris and Red Hat Linux versions. This might confuse some people, since Sun's web site says that this release (2004Q2) is available for Mac OS X and Solaris x86.
   
   
   
   Even worse, there's nothing in the FAQ about this, and the updating instructions for this product assume you already have it installed. However, since the installer is a binary program, you can't install the Mac OS X version because you don't have it on the CD, so you can't update it.
   
   
   
   It turns out that the serial number you are given when you purchase this package will work on the "trial" version from the Sun web site. Just download the Mac OS X trial version and, when asked for the serial number, use the one that comes with your package. The trial copy will become a fully purchased retail copy. As far as I can tell, this is perfectly legitimate since you are given installers for other OSs and Mac OS X is supported by this release.
   
   I'm giving this 5 stars for two reasons. 1) Kudos to Sun for supporting the Mac, and 2) Kudos to Sun for producing such a cool tool!



2. This package is a lot like that ice cream you get at the super market that looks great in the case and then you eat like half the carton before you realize you are being tantalized by something that has been ruthlessly pumped full of air. There are many things in this book that offensively wrong (like encouraging people to use System.out.println). On the whole, this is aimed squarely at the santa's elves market of would-be Java VBers.



3. This is a good deal considering that you get 1 year subscription on SDN which is already $99 from Sun. The book is good for beginners with detailed description on how to drag and drop using SJSC. It has covered UI design/creation to DB connection and access. However, the examples in the are pretty simple.

5 comments about Struts Kick Start.

1. When I am writing this review, the price of a used copy starts from 56 cents. You can imagine what quality you can expect from a book whose owner is so eagerly willing to part with it.
   
   I did read this book and here is what I have to say. In short, do not buy this book or even read it. It's a waste of time.
   
   I can't believe Craig McClanahan recommended this book. How much did Sams pay him to say that?



2. Problems started from chapter 6, beginning was simple, easy, as beginning of any other JSP book. Author decided to make a nice example of struts application, the "stock tracker" application. I was so happy to see a good example, since other books lack complex examples. This example was realistic every-day type of applications we see on the web (banking or paying bills, rental). It also deals with retrieving XML data from the disk, and I find this also an often case in the real world applications. So the example had all chances to be good, and therefore book seemed to be oriented to people who really want to do some progress in JSP (and struts) development and to do some serious applications, not hello world in 21 ways ("hello from jsp", "hello from DB", "hello from servlet", "hello from preprocessor", "hello form plug-in"). So his example was promising to provide some logic, state machines, db access and synchronization, that "hello in 21 ways" approach lacks.
   
   Also some use cases were mentioned and at that moment the book had all chances to be really serious one. Real life example, use cases, db, xml, regular expressions. In only he touched xalan and xerces it would be state of art idea for the book. Wow!
   
   However, all fails down, since author just mentions these technologies, but never goes down to the details, possible problems, drawbacks and finally leaving you on your own to learn them.
   
   Use cases without UML diagrams. He does not mention any other UML diagram. If the decided to go into use cases, the he should have done it as it is done in real life, use a tool to draw them and go thru activity diagram, state diagram, class diagrams, component and deployment diagram, etc. I got impression like he tells a reader: "Hey, there is something called Use cases, learn them alone".
   
   Again, he needed a db backend, he used MySQL and provides SQL schema which is good enough to copy paste to my SQL command editor and to get tables ready. To access db from servlets he used Torque tool to generate java source code for accessing/updating records for tables he designed. But again same mistake follows - doesn't go any further than saying "It's worth taking a moment to see how Torque works" - and that's all he says about Torque! Ant is needed to run Torque. No even a sentence about how to launch Ant on Torque to generate java code for your own tables of your own application, which I believe, it is to expect from a reader to do. Well, perhaps he thought you will use provided java source on the CD and not build your own code. But what if a reader wants to do his table?
   
   So now I got nothing out of that nice example. After several days trying to rearrange sources and put them into a project for JBuilder, WebSphere, Eclipse, somehow I got that code compiling and working, and then run into various problems regarding exceptions about locating property files, unable to connect Torque classes to MySQL, etc. I think that author should have provided several project files for several tools to help a reader to launch and start any of the provided examples, or at least, to provide Ant build files for some free application server.
   
   Finally, the general problem in the book is that author does not go into the depths of any technology that he uses, leaving a reader in troubleshooting alone. He has no serious attitude nor is willing to take a reader by hand and show him/here nuts and bolts, problems and highlights of Struts. Everything is kept on an introduction and shallow level. Book was meant to impress with its example, which is left in "wireframes", unknown UML term for me. My favourite sentence from the book: "The Action can be very simple or very complicated."
   
   I give 2 stars because I liked the example. For someone of my experience (6 years in java) I would recommend some cookbook rather than this one, my greetings goes to Struts books: Struts Survival Guide, Struts in Action, Professional Jakarta Struts, in exact order. There are nice tutorials by Borland and IBM about struts and JSPs.



3. I've been needing to learn Struts for a project at work and picked this up at the local used bookstore after thumbing through it. I took it home and started working through the demo application in Chapter 3, Hello World.
   
   Of course they don't give you any information on how to install it or set it up for Tomcat. There's a companion CDROM that has all the source on it, but it is also poorly documented. I can't figure it out.
   
   I went to the web site for the book and it's horribly out of date. There's a link to a new version of the HelloWorld application, but the link now points to a squatter's domain.
   
   I'm sorry I spent any money on this book, but I guess I should be glad that I didn't pay full price for a brand new copy.



4. Completely useless as a reference book. Very disorganized. OK as a basic introduction - then you can basically throw it away - or sell for 92c which is the going price for a used copy and it's no wonder.



5. I needed a book on struts as I was beginning a new position. With limited time, I had to rely on the local book store. Not a good idea since this book was the only available book. I should have ordered online and waited.
   
   The lack of detail is truly amazing. Use this tool, but don't describe the steps needed to compile the java created by the tool. Use this tool to create the JSP, but what if you don't have that tool and are limited to the tools you can use?
   
   Since the tool generated code is required before compiling the included source code - that is a glaring omission. While the use of ant may be expected of many java programmers - setting up ant to complete the examples is not, especially given the complexity of the resulting xml file.
   
   Disappointed would be a polite way of describing my reaction

3 comments about Java 2 Platform, Enterprise Edition: Platform and Component Specifications.

1. The book explains all the components of the J2EE specification and also talks about how they work with each other. The sections on EJBs and Servlets are quite comprehensive and definitely clarify a lot of misconceptions.

   Overall a good book for any Enterprise developer.




2. This book is 'just' a paper version of what you can download for free from java.sun.com. It includes the specifications for: J2EE, Servlets, JSP and EJB - including FAQs and a Glossary (everything available for free on Suns site). The specifications are the definite reference - and proves a good supplement to other books. Worth reading.



3. I ordered about a half-dozen books on Java Enterprise Edition, and found this (series) to be the best organized material.

   The authors presented features in the context of the overall vision, helping me to better understand not only what is in J2EE, but what the thinking is on its future.

   As an overview to J2EE, I found this very helpful.

   This did not, however, have any compare and contrast materials with Windows DNA/COM+, nor did it have the kinds of detail you would expect in a programmer reference.

5 comments about Java GUI Programmers' Primer, A.

1. My problem with the book is the author approaches the gui examples without using or discussing established gui idioms such as lightweight components and anonymous inner classes. His failure to tie his work solidly back to important java features makes it hard to integrate his ideas with recommended usage and style. Finally, the format of the book's presentation makes it somewhat difficult to follow the examples and the different font styles, sizes, etc. are annoying.



2. Although this primer includes more than I would have expected in the way of design strategies, the presentation makes following the code more work than necessary. Verbose naming schemes and extensive 4 digit line-number references takes away what I usually look for in a primer (quick and to the point) and forces me into the mental acrobatics usually needed for much more technical material (such as assembly for the 68000).



3. As a professional HCI and Java developer I found this book extremely valuable, not for what it said explicitly but what it teaches you implicity.

   Usability and HCI strategies are incorporated into every stage of the engineering cycle and reveal why Java is a usability-friendly language.

   The programs and exercises cover most topics you would expect from a language book but the key to the books usefulness is not in the traditional 'let's start coding straight away' approach to programming books.

   The use of solid HCI/usability techniques throughout the development stages and how to get from paper to products with usability standards and the demonstration of Java as a language that has been developed with consideration of usability issues id invaluable.

   It is important to note that Dr. Culwin sees the usability engineering methods as part of the sotfware engineering lifecycle, NOT a separate procedure.

   Also, this book is as much about integrated good software and usability engineering as it is about Java ability to accommodate usability engineering.

   The programs and tasks give thorough examples to develop various types of interfaces and explains the architectures/design of Java artefacts and provides a hands-on introduction to UML and STD notation.




4. OK...you know java, or you think you know java, and now you want to develop and deliver serious java applications. How should you approach the task of segregating the application part of your code from the user interface? What sort of user interface is appropriate for your application? What issues should you consider before writing one line of code? "A Java GUI" provides answers to these and other java user interface development questions.

   A word of warning: This book is not for beginners. Readers who have a solid foundation in java fundamentals and object-oriented design in general will gain the most from the book. You will learn many useful design techniques. It will be up to you to decide which one is appropriate for your particular project.

   If you are a novice I recommend buying the book for your reference library so that when you're ready to move to an advanced level of java coding you'll have it handy.

   No one book on Java programming, regardless of focus, can hope to cover every feature or nuance within its scope. Fintan's work is no exception, however, he does an excellent job in focusing the material on those issues which contribute directly to good, solid java user interface design practice. He doesn't repeat a lot of the same crap you find in most java books...but he does cover background material, (his coverage of the core java AWT features is the best I've seen anywhere), where it aids in the reader's understanding of what he's about to say.

   If you've really read any programming texts, and understand what you're reading, you soon discover than many are plagued with typos or outright lies. Fintan's book contains far fewer errors or omissions than most. However, these are easily spotted and it's refreshing to actually be able to compile an author's source code and have it work as advertized.

   Overall, I rate "A Java GUI" a five star book. If you're looking for a text that cuts to the chase and simply makes you a better java developer, this is the book you're looking for.




5. Starts out bashing everything that came before java and believes that only trained programmers should be able to write GUI apps. Give me a break. Good GUI's should be language neutral. If you dont mind java-evangalist nonsense the go ahead and buy this. Otherwise - keep looking.

5 comments about Asunder: An Unauthorized History of the Origins of Java Programming Language.

1. I was surfing the internet looking for new books about T.E. Lawrence and found this one about the saving of the Java programming language. I thought, what could Lawrence of Arabia have to do with Java? So I bought the book and found it fascinating and stunning to think that the authors used Lawrence's strategy, metaphorically, to influence the saving of Java. Obviously this is a little known story (and if I have read some of the other reviews correctly, little believed). However, I believe both the story and the authenticity of the authors. At first no one believed Lawrence either. It goes with the territory.

   I wonder if Microsoft (now on the verge of being split) understands that one of the seeds of their impending division, had to do with Rich and Joss and their decision to save an obscure technology from cancellation. Of course short sighted people will hate this book. That's why they are short sighted.




2. This is one book I could not put down. It was very interesting and quite readable. I made the mistake of picking it up to try get sleepy again when I awoke in the middle of the night. Most any other book would have made me drowsy in no time, but "Assunder" I had to read through. Not only did I learn about the gestation of a new technology even more compelling than that described in "The Soul of a New Machine", but I was fasinated to learn so much about T. E. Lawrence and how his methods could be applied to a modern situation.

   This appears to be a book that either you believe it and love it, or you disbelieve and hate it. I believe it. I too have known managers of the type Richard describes and have witnessed corporate antibodies reject breakthrough ideas. Like the Java development, the development of a new computer being described in "The Soul of a New Machine" required an unauthorized, underground movement by dedicated engineers to avoid rejection by the official coporate antibodies. The unorthodox method that Richard used to overcome these problems and save Java was fasinating, but not likely to be widely adopted. It requires too much self effacement for almost anyone capable and self confident enough to carry it off, and in the end the powers that be do not know your role in the success. Thus, there is no profit nor reward in it except self satisfaction. This is definitely not a primer for ambitious coporate ladder climbers.




3. I loved this book. One of the few that had me taking notes. I particularly enjoyed the application of the principles of Lawrence to the problem at hand. I may be biased as I know both Rich and Jos, as well as several others. As an observer at the time, I can say that Rich definitely had a hand in how Java landed after it found itself tossed into the air.



4. Rich Stiller and Jos Marlowe were there at Sun Microsystems when James Gosling invented "Oak" and turned it into Java in 1993-95. This is a fascinating look at how Java nearly died when a software incubator set up to foster creative genius runs headlong into the realities of corporate life and organizational dynamics. Anyone working in today's "web time" environments and trying to pick up the pieces of the dot com "bust" of 2000 needs to read this book. It provides insights that can only be acquired from firsthand experience. Stiller and Marlowe were there, with Gosling, Bill Joy, Patrick Naughton, Wayne Rosing, and the other people who launched what has come to be a programming revolution. I found this book a compact gem and highly recommend it to anyone else who wants to crawl out of a foxhole and see a bit more of the world than the earth of a dusty today.



5. As another person who was around when Oak and Green
   were turning into Java, it would sure be nice if this
   book reflected reality. But it doesn't. As others have
   pointed out, the authors were nowhere near the coalface
   when this gem was being mined.

5 comments about C# Programming with the Public Beta.

1. This book covers a nice introductory overview of much of the syntax, environment, and usage of the C# language, the .NET structure and base classes, the VS.NET development environment, its use in ASP.NET, a bit on COM and COM+ interoperability, etc. -- most of the general aspects of the new C# programming language and its use. This book is NOT a serious programming course that will have you up and running in C# by itself; a somewhat thicker tome will likely be required for such ambition. It does make for a good survey intro for developers who want a lighter introduction or who perhaps haven't decided yet to go for the full C# deal, and can be followed up with a more in-depth text for the serious soon-to-be-C#ers.

   Particularly interesting to C++ and Java developers will be the sporadically inserted C++ Notes and Java Notes: specific notes for people coming from C++ and Java about how a certain feature of C# relates to and/or differs from a similar feature in either or both of these languages. (Even as one not coming from either of these languages, I found these notes interesting and useful.)

   The one significant drawback issue I had with this book is the few scattered barrages of odd or broken grammar, and the occasional seemingly contradictory statement. These weren't enough to detract heavily from the value of the book (IMO), but they were quite distracting in places, and should be addressed more seriously in any future editions of the book.

   Overall, I'm satisfied with this book, and am looking forward to following it up with that more in-depth text....




2. Do NOT get this book. It is a sham. It is unfortunate that I have to say that because I LOVE Wrox books. I have to say this is the first Wrox book I have ever been dissapointed with. There is nothing of use in this book. The examples are useless, too short and not explained at all. You want to learn C#? Just get the free Beta and go through the tutorials included in the MSDN package - they're really good.



3. This book is very essential to get confidence with c#. you can begin to understand .net platform and how to build web services very fast.



4. Do not buy this book for the sole reason that it is obsolete. It was written using the Beta 1 so none of the code works anymore. If you don't believe me download the sample code from Wrox and try to complile it. Try the chapter 7 code for files and directories. You'll notice they use "System.WinForms" which doesn't exist, plus they try to do things like "File f1 = new File("c:\\blah\\blah.cs");" Which doesn't work either!



5. This book will probably be a hit or miss for you, with no in-between ground. You can see by the reviews people either loved it or hated it.

   I believe some people like to make assumptions about the basics of a language as they learn the more complex subjects. Others like to see the basics spelled out, then take off like rockets.

   If you fall into the second group, as I do, then I think you will enjoy this book. I probably won't refer to it again, but reading this book will help me absorb the more complicated aspects of using C# and .NET all the faster.

   I like to separate learning _what_ all the new C# and .NET features are, from _how_ I should use them. This simple book focuses on the _what_. With a solid understanding of the pieces of C# and .NET, I can now focus exclusively on learning _how_ to best use these new features, via other books.

5 comments about Data Structures and the Java Collections Framework.

1. This is a rather dense book and spents more time on Linked Lists than any other Data Structures in Java books I have seen on the market.



2. As an undergraduate in computer science, I absolutely hate this book. It places way too much emphasis on object-oriented programming (OOP), instead of concentrating on its main topic, data structures. It makes an artificial distinction between what it calls the "user" of a class and the "developer" of the class, and tries to introduce pre-programmed data structures first from the "user's" point-of-view, and only later mentioning the real implementation of the data structures. The author apparently fails to grasp that students cannot truly understand data structures until they have programmed their own data structures from scratch. The book also makes excessive and superfluous use of things such as preconditions and postconditions. For example, how truly enlightening is the following postcondition for the IsEmpty() method of the ArrayList class?

   // Postcondition: true has been returned if this ArrayList object has no elements. Otherwise, false has been returned.

   If you want a good introduction to Data Structures, then you should look for a different book, preferably one that uses a better language than Java. Okay, I admit that C/C++ pointers are difficult to learn at first, but after you've used them for a while, it's fairly intuitive. Java's "references", on the other hand, are easy to use at first, but when you try to implement linked data structures, they become confusing and non-intuitive.




3. The intro chapters (including a preview of the new edition) are amongst the worst intro to java. Typos, use of deprecated methods abound and several key areas (complexity analysis) are awkward at best.



4. Almost three years ago I read a data structures book which used Java for implementation of the topics covered. Perhaps I did not have a solid grasp of the Java language back then, but the book was one of the worst I have come across - I don't even remember the name. "Data Structures and the Java Collections Framework" on the other hand is one of the most up-to-date books available and certainly one that I will remember for quite some time.
   
   Not only does it cover the theory behind many of the fundamental data structures such as arrays, stacks, queues, trees, graphs, maps, etc. but it also illustrates common algorithms required by those data structures. For a book covering this kind of material that would have been enough, but this book excels in showing implementations with the latest version of Java.
   
   Furthermore, this book's purpose is not to teach Object Oriented programming with Java, or the latest features of version 1.5 (Generics, foreach loop, boxing, vararg). The author assumes those were taught in an introductory Java course. Thus, the book does accomplish its goal to teach data structures using Java, and taking advantage of OO design and the latest features of the language. And for those who need a quick refresher two review chapters are included that quickly cover the most commonly used features of Java, as well as javadoc and packages.
   
   As many other technical books, this one contains its share of typos and errors - nothing major though. Later in the book, only parts of the entire implementation of certain data structures are presented, but yet there is no mention that the book's website contains that and more. Also, an introduction to JUnit could have made this book better.
   
   The part that readers will find most useful about Mr. Collins' book is the future applicability of the Java Collections Framework. There are many poorly written books that deal with data structures and books about the Collections Framework. And yet this book does an outstanding job with the two subjects. A great book to learn data structures from - Highly recommended.



5. I found this book to be very helpful in learning data structures. I read it on my own, without help from a teacher and was able to understand everything thanks to the thorough and step-wise coverage of the material. The only exception was the chapter on algorithm analysis, which I agree is not easy to grasp. But I was more interested in the structures themselves and what each one was efficient at, so the math analysis wasn't that important to me. The math isn't as important as understanding what makes one function faster than another.
   
   One of the previous reviewers complained that this book focused too much on object-oriented programming and the Java language. Hello? Did you read the title? This is a book about Java. I really like his approach of covering the Collections framework while discussing data structures because a lot of introductory programming courses in Java don't cover Collections very well, or at all. He introduces the framework at the beginning of the book and as he goes through each kind of data structure he creates his own simple implementation that the student can follow along with. Once that it is understood he describes the way that the Collections framework officially implements it and points out how the differences will affect programmers who use it.
   
   That step-wise approach to each topic is very effective. I recommend this book. Just skip chapter 3.

5 comments about Apache Jakarta-Tomcat.

1. This is quite possibly the worst book ever written. It is certainly the worst book I have ever read. It has absolutely no useful information at all.

   It's hard to imagine that someone would write a book on a J2EE server and provide ABSOLUTELY NO INFORMATION on how to configue a JDBC datasource. Although it does tell you how to use mySQL for Tomcat user info instead of using the default xml file. Thanks for that completely useless piece of information.

   It provides no information on what parts of JSP/Servlet dev. are specific to Tomcat and which are part of the standard. I could write several pages citing hundereds of other reasons why this book ..., but I think I have wasted enough of my time. Don't trust any reviews on here. If someone has given this book more stars than the minimum allowed they are probaly working for the publisher. I only wish amazon.com had negative ratings so I could give this product an accurate review.

   If you are looking to get into JSP/Servlets avoid this text. Pick up the Sun "core" book and read the documentation for Tomcat. And, if you happen to see the author of this book, kick him square in the nuts. Several hundred times.




2. This was the only Tomcat book available at the time I was looking, so I decided to pick it up to enhance my knowledge. However, almost all the information I found in it was available, sometimes verbatim, online.



3. I like this book a whole lot, its great for starting out. It cuts out the fluff and gives real world shortcuts on how to configure Tomcat. I would say it is a must have first book on Tomcat.



4. This book is very, very superficial. Only a small part of the configuration of Tomcat is covered. Plus, it is certainly outdated today.



5. I bought this book when it was first printed hoping for some insight into how Tomcat worked, design decisions, architecture etc. etc.
   
   What I got was nothing more than a rehash of the online documentation.
   
   A complete waste of money then and utterly worthless now. If you have a copy hang it on a nail.

1 comments about Practical Object-Oriented Development with UML and Java (Alan R Apt Book).

1. Only disappoint, no more.

No comments about 250 Multiple-Choice Computer Science Questions in Java.