This book is one of the worst I have ever encountered in my seven-year CompE & CS academic history or in my six-year "real world" experience.

Most importantly, its first copyright date is 1990, and I don't think it had modern ideas then. Yet, in the fast-moving world of computers, he has neglected much networking, any mention of open source software, any mention of bazaar-style development, any depth of databases, thoughts of providing services, recognition of abstraction layers beyond machine code--source code--operating-system, any development of design patterns, and much UML and Java.

The code samples and anecdotes provide little insight to issues that modern computer engineers need to deal with. The writing is wordy without being precise or complete. The references are antiquated and unimportant. The questions demand only regurgitation, neither thinking nor reflection.

The original version of the book was written in 1990 and despite the updated title and the notation 4th edition, there is much in this book that hasn't been updated. The UML aspect of the book is very weak and Java is given only a cursory treatment.

The (obviously) older material is well presented and well referenced as chapter end notes but newer topics such as Extreme Programming (Beck), Refactoring (Fowler), etc. are absent from discussion completely.

If you're looking for a good UML book try "UML Distilled" (Fowler) which provides a succint overview of the topic in considerably fewer pages. If you're looking for a book on Software Engineering there are several offerings which provide a solid, more current overview. This book attempts to do both and ends up doing neither.

I have been in the SE Industry for several years and have dealt with a wide variety of businesses and corporations. This book not only gives computer professionals a very solid foundation on the proper methodologies and processes but it is also an excellent tool for helping lay-persons understand how important these processes and methodologies are to the software life cycle. This book has become my most valued resource in my professional work.

saf sads kadduss adfd powerbuilder sai ni domb sybase daf sad

Very helpful, huh ?

Yes this was a good book. I really liked the authors of writing style, and I did not put the book down until I had almost read 4 chapters. Nicely layed out and well explained. I learned about the basics of distributed computing, then powerbuilder, and then using powerbuilder with easerver. I LOVED the java part since I am quite new to java. The author walked me through learning java and then gave me a very good comparison. Excellent read specially for the powerbuilder folks trying to convert to java... Well Done.

I am quite new to PowerBuilder, Jaguar, and most important of all, JAVA. This book gave me a very good tutorial on JAVA and started my off on my way to using Jaguar. I recommend this book to all.

The book was published in January 1998 so it only reflects pre-beta changes. Unfortunately, this can be spotted in both the quality of the text and its reflecting advanced Java 2 things (no mention of Collections etc). It wouldn't alone make a book bad - after all, you should buy for example Thinking in Java that has a wonderful chapter on Collections -, but the 1.0 / 1.1-specific stuff is also badly explained. Very important C/C++-related subjects are not mentioned: the inherent differences between C/C++'s and Java's static is not even mentioned. Comparing the C++ and Java exception libraries is also painfully missing from the book. And there are a lot of C++ listings in the book without much help - the authors seem to forget sometimes that they're working on a book on Java and not on C++.

Core Java has no C++ in its title, but I still found it at least as useful as this book when it comes to emphasizing the differences and similarities between the two languages. Having lost its greatest advantage over Core Java, the book has nothing to offer for the seasoned programmer. It's weak as a reference, it's even weaker at actually teaching Java in a comprehensible way. C programmers should not try to learn the Java from this book - especially not OOP. The book's sections targeted at C programmers don't actually teach how an OOP structure can be translated into plain C. C++ programmers may find the book relatively easy to understand. Books like Thinking in Java or Core Java are still far more comprehensible - I don't really think you should present your beginner readers complete applications that utilize streams right at the beginning. Let's agree to differ - some readers may find it cool to get complete, non-toy (?) applications - I didn't. Some chapters only have one or two big examples (there are - later - chapters that don't have any!) - a lot of small code snippets teach the language far more efficiently than a big one, no matter how complicated and advanced it is.

The comparisons to C and C++ in the first five chapters are overwhelming (still, as was already mentioned, some key differences haven't been mentioned); later chapters don't compare Java to C(++) any more - they may have been written by different authors.

The book doesn't explain name conventions. Doesn't use them either. Most classnames begin with lowercase letters - very annoying! Another common mistake is importing the classes used in the same package - especially in the first chapter. As with most Wiley titles, there is no code highlighting in the book, and the editing is, in general, quite sloppy (quite a few typos, duplicated words etc).

Chapter 1: Introduction to Java: compares almost everything to C/C++. The rest of the chapter describes how JDK should be installed and used.

p. 16: "...which is why the main function of Source 1.7 only contains the constructor for the bookWindow()"; "once we have added all the components, we can... size the window using either width or height or the pack() methods". The book being written in late 1997, it still refers to classes.zip and CLASSPATH.

Chapter 2: Comparing Java to ANSI C: explains packages, import (also emphasizes the difference between import and #include). Compares keywords, literals, expressions, identifiers etc. between the two languages (allowed characters, length etc, but no name conventions). Compares arrays (also mentions reference arrays and their dangerous behavior) and strings. Even uses PixelGrabber in the examples - very hard to follow for a beginner. Quite interesting examples (Base16 coders etc). A section about the features removed from C: keywords, global variables, pointers, preprocessor directives, variable arguments (recommends using Vectors instead). The chapter is packed with C examples - sometimes you can feel it's a C tutorial. Lists the header files of the entire C standard library and shows their Java equivalents: assert -> nothing, ctype -> Character's methods, errno -> Exceptions, float, limits, locale -> i18n, math -> Math's methods; setjmp -> Exception, (p. 92: "since Java provides both exceptions and threads, there is need for setjmp and longjmp in Java" (that is, no need); signal -> Exception, stdarg -> Vector, stddef, stdio, stdlib, string, time.

The chapter doesn't try to teach any OOP-related subject.

Chapter 3: Comparing Java to C++: teaches some OOP (why not in the previous chapter, for the C programmers, who really need this introductory stuff?!) - the explanation is quite abstract and almost useless for a newbie to OOP (lacks almost everything that makes a good OOP text great). The book uses 'class methods' when referring to instance methods and static class methods when referring to static methods - very annoying for people that are used to the right terminology. Mentioned the difference between C++ and Java when it comes to initializing static class members.

The explicit super() explanation is OK, but the book never mentions the difference between Java and C++ in the usage of this() in the constructor (shows it in Java but doesn't mention it doesn't exist in C++).

Compares Java's clone() to C++'s copy constructor - just so as a decent Java book should introduce the subject. I find Core Java's or Thinking in Java's discussion much better, though. And most beginner C++ books do much better work at explaining why explicit copy constructors are needed.

Shows the syntactic difference between C++ and Java inheritance (while making a mistake in the table: a superfluous colon). Also shows abstract (pure virtual) methods: source 3.13, which comes right after this, has the main class drawShapes (yes, wrong capitalization) using AWT and the drawing methods of Graphics. As a lot of C++ books are showing examples of just this Shape <- Square / Triangle / Hexagon relationship with an abstract calculatePoints() in the superclass to make readers understand how overriding and dynamic method dispatch works, I expected this book the same: an example that has an array of type Shape containing elements of the above-mentioned subclasses, getting these elements out the array and calling calculatePoints() on them to see whether dynamic dispatch really works. Unfortunately, the authors have missed this chance to really show the readers how runtime binding works - you have to choose from the menu which shape to draw and voila - it gets drawn. No reference arrays of type superclass, nothing. The very next example does just this with a much less interesting example (actually, it's just another toy example).

Touches on exceptions, shows the difference between C++'s catchall - that is, catch (...) - and Java's catch (Exception). The C++ example here is again a very bulky one, it is only included here to show that in C++ you don't have to declare what kind of exceptions will be thrown out of any methods. Doesn't draw a line between unchecked and checked exceptions - it only happens later. Some severe errors are made:

"classes derived from the Exception class fall into the category of errors that can be recovered from, whereas classes derived from the RuntimeException generally cannot be recovered from" - this is not the only point where the readers show they confuse the subclasses of Error for the children of RuntimeException. It is a very severe error.

The chapter also discusses inner classes - quite brightly. I still miss the explanation of static member classes - the authors only devoted one sentence to them.

Also presents the C++ Standard Library (the comparison takes some 3 pages).

Chapter 4: Language features not in C or C++: discusses packages, interfaces (doesn't show how they can be used as types / for callback), dynamic type inquiries (Class.forName() etc. - this sub-chapter should have been put in Chapter 6 entirely) and threads.

This sub-chapter is quite weak: there is no wait/notify (not in the entire book, actually); doesn't try to explain what the difference between implementing Runnable and extending Thread is; doesn't try to explain why some methods got deprecated and has errors like the following: p.195: "the Runnable interface is simply implementing the run method".

Chapter 5: JNI; 17 pages;

Chapter 6: The Java Language Classes and Reflection: there is a severe error in the title, as it refers to java.lang and definitely not all classes of the language. Discusses wrapper classes (doesn't mention they're immutable; doesn't show which of them were introduced only in 1.1; and suggests only Integer and Long have parse methods), standard input/output/error (no info on actually redirecting them - another 1.1 issue), the Thread class (absolutely useless, as it doesn't have any new information - the toy example only creates a thread and doesn't do any sophisticated work); it lists the most important Error, Exception (and RuntimeException) classes - I found this quite useless. Again, it confuses the subclasses of Error for the children of RuntimeException: p. 258: " RuntimeException: ... these exceptions can be common (like running out of memory)...

I found the Java material quite useful and informative, however, I bought this book in March of 1998, when JDK 1.2 was not even released!!! So this mystery vexes me a lot! It seems the authors are trying to jump on the publication frenzy and bandwagon. The Java stuff in there is good, I just question the accuracy of it all.

This is really good book for people who already have been programming in C/C++ and want to switch to Java. It covers the differences between java and C/C++ in a very succinct manner and helped really get good command on Java.

Java Data Objects by Robin M. Roos is one of the first books
available on the subject of JDO. The author does a good job of
explaining the impetus for the creation of JDO and the concept
of transparent persistence. The first 200 pages of the book are
effective at presenting the meat of what JDO is about in a way
that is more readable than the JDO specification of about equal
length. If you like reading specifications, then you probably
wouldn't buy this book anyway. For Java architects, designers,
and programmers looking to understand JDO, this book is a good
start. It is assumed that the reader has a background with Java
development, but not necessarily persistence methods. Of course,
Chapter 11's discussion of JDO and J2EE will make more sense if
you are familiar with the J2EE.

The book has a good flow and an easy to read style (I love the
occasional use of "whilst", but maybe that's just me). Java Data
Objects succeeds for the most part in not relying on any forward
references. The only one I remember was the concept of "fetch
groups", which isn't defined until pg. 156. It also does a good
job of staying vendor neutral and presenting the technology as
defined by the spec. The author was careful to point out vendor-
dependent features. I enjoyed the careful use of UML, state
transition, and object interaction diagrams in the text to explain
key concepts. Particularly, chapters 4's explanation of an
object's lifecycle and chapter 5's description of the persistent
object model. Chapter 6 is a walkthrough of the most commonly
used JDO classes and interfaces.

The book is well written and easy to follow. For the architect,
designer, or developer considering new ways to persist objects
(in a relational or object db), JDO is definitely an interesting
new alternative to consider. I had a few issues with the
examples and the CD, but frankly I didn't want to spend a lot
of time learning different product environments at the time I
was experimenting with the examples. Here's a suggestion: why
not include the JDO RI from Sun on the CD? It might be nice to
provide a set of scripts which use the reference implementation
as an alternative to the commercial offerings.

I just started using JDO. This book was a good introduction. Altho it lacks some of the details of the specification, it was much easier to understand. At just over 200 pages of text, it was easy to read cover to cover.

Some books elaborate beyond their relevant specification, e.g., The Java Class Libraries series. That's fine for a reference book, but I wouldn't want to read the whole thing all at once. Robin Roos' book abstracts some of the complexity from JDO to explain it in a way that I think a lot of people will find easier to understand.

Coming from a JDBC and home-grown persistence layer background, I can appreciate how complex the issues are. So I was impressed with how simple Robin's explanations were. I doubt it will be the last JDO book that I buy, but I'm glad that it was the first.

This book is not a big comparison of the major persistence layer technology choices today, nor an analysis of the application of JDO to a major project. If you're trying to evaluate JDO against the other technologies, then you'll need to look at the online debates. But if you want to try JDO for yourself, then this is a good start.

I hesitated before buying this book because of its first review here at [Amazon.com], but now I'm glad bought it. Roos introduces the subject well and with enthusiasm. A fairly compelling case is made for JDO. And that includes some forthright but well supported comments on JDO vs Entity Beans. No punches pulled!

The examples are relevant but not unnecessarily complex. The usage of JDO and the underlying theme of "transparent persistence" both come through clearly. The book seems fair and points out some weaknesses in JDO (eg interface extents). Getting a heads-up on likely problems is important when starting out with something new.

I particularly enjoyed the J2EE chapter. We write web apps where JDO really might be a winner.

Object/Relational mapping? Roos points out that JDO is not an object/relational mapping standard. Although most implementations work against relational databases JDO does not standardize the mapping representation which remains vendor-proprietary. Instead JDO is an API for object persistence. It standardizes how persistent objects behave and how applications should use them. The final chapter looks ahead to anticipate future JDO refinements which include a standardized O/R mapping.

I'm docking one star because the source code was not immediately available, but I have downloaded it now.

Tons of garbarge examples that don't even make sense....I will let the horse speak:

int getColumnType(int column)

String colTypeName = rsmd.getColumTypeName(1);

I am interested in connecting via JDBC from an applet. This subject is not covered in any depth, and there are no instructions for preparing your environment for the samples to work. I HATE depricated code, and the book is full of it.

This book is good for a beginner. I read this book and it helped me tremondously. This book would not be good for the experienced beginner. The code is easy to follow; although some could have been written better. It is a good reference. -- Not the best I have read.

This is a good book to familiarizing on how to implement web services using Java. What I found most valuable about this book is the coverage of AXIS, CapeStudio, SAP and J2EE.
As most other Web Services books, the chapters on SOAP, WSDL, UDDI and Web Services Security are very general and take up half of the book. If you're already familiar with these concepts these chapters are useless. Also as most web services related technologies are quickly evolving I would find this book quite outdated today.

I have some gripes about this book:

*First of all, the explanation of SOAP, WSDL, UDDI gets quite confusing and convoluted. I had a hard time understanding the explanations given about these protocols, especially about how they are structured.

*The samples that cover Apache SOAP require the IBM web services toolkit 2.4. However, you can only download the 3.0 version of this toolkit from the IBM website. The 3.0 version is not compatible with the 2.4 version. In essence, you cannot run these samples.

*The security section of this book is only theoretical. No samples. (The reason given was that most of the security technologies are still in development).

Other than these gripes, this book will give you a broad understanding of the java web services so that hopefully, you can get started on implementing/deploying this new technology.

Wrox books tend to occupy a particular niche in the market. Wrox' strategy seems to be to be early into the marketplace with a book on a bleeding edge topic. Their 'Early Adopter' series is particularly aimed at this market, but so are many of their books. If something is wrong or superceded, Wrox will publish another book on the same topic, usually a bunch more books on the topic.

Wrox also tends to publish books with many authors. This makes their books spotty, though in theory it ensures expert knowledge of a wide range of topics. In practice I don't find it so. Certain chapters in any Wrox book will be effectively unusable.

The speed comes at a price in terms of proofreading and to the useful life of the books they publish. When I purchase a Wrox book I know what I'm getting. It's a book with a short useful life which will help get me started quickly on bleeding edge topics at the cost of some frustration and skullsweat.

Typically I will replace a Wrox book later on my learning curve when O'Reilly and other more careful publishers come out with their books. There is a place for books like these. Even if they aren't 100% accurate, they are timely and are rarely completely useless. I usually don't recommend them for beginning technologists for that reason.

This book was useful when I bought it but has now almost reached it's sell-by date.

This book is just a copy of JMS tutorials from java site and has examples which are written using jmq which is no longer available as it has now become part of iPlanet group and they have broken compatibility (Interfaces have been changed) Not the worst book but certainly worst wrox book i have ever read

This book covers a lot of ground about JMS. However, the problem is that it is written by many authors, which results in repetition of some subject, bad structure of the book and more pages than necessary for explaining the subjects.

The first 5 chapters are on 250 pages and cover the basic about JMS, but I think "Java Message Service" by Monson-Haefel does a better job here. However, I appreciate that there are sequence diagrams in the first chapter that shows basic design patterns for MOM-based applications. The next two chapters is code example that shows how to use JMS from a web application and from EJBs. I'm not too found about this kind of lengthy code examples.

The chapter about JMS and Clustering is very technical, but still only scratches the surface. This is a subject that needs an own book to be covered completely. The next chapter called "Distributed Logging Using JMS" is again a lengthy code example, but a very useful one!

Chapter 10 is about XML Messaging with some XML code example. I think this chapter, like some of the other chapters as well, covers too little to be of some real value and too much for just being an overview. Chapter 11 is about Mobile Applications and the criticism against this chapter is the same as the chapter about XML.

All and all this is a book that covers a lot of subjects related to JMS, but it does it in a boring and verbose way.

I expect that with introduction of JMS and Message Driven Beans which are based on this technology we will see very big movement towards implementing various application scenarious based on JMS. This book definitely could help you to decide what should be taken in account. I also like chapter on Clustering and Scalability - each enterprise (and you as developer for this enterprise) should think about this during design stage. List of various JMS providers (SonicMQ, IBM MQ Series, FioranoMQ, WebLogic) and implemented by them features could also be helpful.

This book documents version 1.0.2 of JDK. Sun is up to version 1.3 and has made dramatic additions since 1.0.2. Don't buy something so out of date.

This book does not worth your money. This is very much like the API doc on the web, there is NO example. Better save your money to find a better ref book such as the Chan & Lee...

As others have pointed out, there isn't much here that isn't in the freely available JDK documentation. Also, most computer books lag behind the actual software they cover. There are a few indispensable "classic" computer books out there, but they're all about stuff like UNIX, TCP/IP, and C, targets that don't move as quickly as Java does.

But I don't think I'm the only professional programmer in the world who appreciates having printed documentation. It's handy to be able to take a book on the road, or to the nearest couch, and flip through the pages at my leisure. I like putting a finger in one page and a pencil in another while I flip to a few cross-references. I doubt that online docs will ever really replace the Real Thing for me.

O'Reilly is one of the two or three best computer book publishers out there (Addison-Wesley and Prentice-Hall are also excellent, but pricey). This book is typical of O'Reilly's stuff: practical, dependable and inexpensive. I do Java GUI programming full-time, and I've used this book a lot. So far as I can tell, every method for every class is covered at just the right level of detail. If you want an authoritative, exhaustive reference that doesn't cost an arm and a leg, look no further.

The book is not bad and somewhat practical. If it was sold for half of its present retail price, I'd give it 4 stars.

I am the senior web developer at a small company looking for a good book to bring my less-experienced people up to speed on JSP. I bought this book because the introduction says, "This book is designed to teach you JSP, even if you have no Java experience whatsoever." Sadly that is not true.
Just three pages into Chapter 2, 'Creating a JSP Page', the author hits you with several pages of Java source code as he compares and contrasts the java source produced by JRun, Tomcat, etc as a result of processing a simple JSP page.
The first piece of JSP you see is the page directive, and this topic begins with references to java packages. First, I would think that there are kindler, gentler ways to dip ones toe into the JSP waters. Surely some simple JSPs could be written that do not require the <%@page import...> directive, saving this subject for later. And even so, the explanation of packages would make no sense to someone who did not already understand java.
And so it goes throughout this book.

I have some programming experience but am new to Java/JSP. I choose this book to start out with and am about half way through working all the examples by hand using Forte for Java CE and then "deploying" them to a seperate test server running Tomcat 4.0. Basically, there are several errors in the example code in the book. Some of these are fixed on the versions on the cd - some not. I've wasted many hours scouring the net and pulling my hair out to get the examples to compile and work in both Forte for Java CE and Tomcat 4.0 - EXTREMELY frustrating for newbies like me. Too bad, since otherwise the book is pretty well written. Don't assume the example code is correct and you'll be okay.