Variants Books

The book is thick, but wastes space with needlessly long examples, where shorter ones would suffice. It spends no more than 200 pages on the core language before it touches on xml, java server pages. jdbc,swing, and java beans. Thankfully there are better books to learn java.

I give this book 1 star because although the product details states that digital form of the book is printable, it is not.

This sort of false advertising makings me sick.

If it were possible to give this book and Amazon a negative number of starts, I would.

DON'T BUY THIS BOOK IN DIGITAL FORM!!!!!!!!

The authors have done a wonderful job. I am a senior-level programmer/DBA with decades of experience in dozens of languages EXCEPT Java. Their book has great, accelerated coverage of AWT, Swing, Threads and other topics.

I particularly like the way they discuss AWT separate from Swing -- other Java texts that I have purchased have the two technologies very intermingled. It is very helpful sometimes to just program in old AWT since it is very compatible and supported for web programming.

I am a CS student and UNLV taking some Java courses. Because of transfer credits I got into a Java class that was way over my head. My instructor recommended this book to me to help me catch up and it did far more than that for me. I read the first several chapters in a weekend and it all made sense - the authors started from the ground up and clearly explained how programming languages work and specifically how Java implements everything. Most books tell you how to do something, how to accomplish some kind of task, but don't explain the reasoning behind it - this book is different! Not only can I write Java programs but I understand what they are doing under the hood!

I finished the book within a month, following all of the examples and not only did I get an 'A' in my course last semester, but I have built an MVC Servlet-based application and deployed it on Tomcat.

I highly recommend this book to anyone that is learning Java, it is an indispensable resource. It will help you understand why Java does stuff, not just how to use it!

I have tried couple of other Java books earlier, but this one is the best of them all. The clear and concise writing style along with appropriate examples makes this book one of the best in the class. This book is useful to a wide variety of readers, starting from front-end developers to backend and web developers.

It would be great to see some discussion on PACKAGE and CLASSPATH in future edition.

I bought it for a friend and never heard a complain about it. I guess it's a good book.

When you want to dive into the field of actually program a wireless device you can easily find yourself become confused. One question is simply: What do I need to get going with the first project. And although it is a simple question to ask, it is not yet a simple question to answer, because it depends! The dependency is what device you want to address and what options you have when you want to develop an application.

This book is written by a humble and very competent programmer. He is humble because he just want to tell us how to code a PDA, be it PocketPC or Palm. He does not want to demonstrate much more than this. And this is how it should be, given the title of the book, because what he does is telling us all the steps needed. Here the authors competence really shows.

The book starts with a brief introduction to the J2ME configurations, the CLDC and the CDC API's. Continuing then to the MIDP profile where the author already demonstrates a simple generic MIDP applet. The next two chapters really rocks the boat: Here is compared the Palm and the PocketPC platforms with regard to J2ME, so if you have the choice then you can easily decide what to go for. In any case you will here find the most needed information: What development environment should you use for a specific platform - and where do you get it. The author brings links to a collection of no-cost tools and what more: All the links are correct!

At this point you really must begin to program at least a "Hello World" program for you selected platform. McBride helps you with every step in this for both platforms. He discusses JDBC, Internet access from the PDA's and how to use misc. connection methods, for example Infrared Connections or Mobile Phone. Everything is demonstrated with very good screen pictures of the PDA's or good program lists. He even demonstrates how to use web-services and the SOAP clients.

The last part of the book deals with the future, meaning technologies such as JXTA (dynamic peer-to-peer network) and ideas about Jini. Bluetooth was already demonstrated earlier in the book. Again, everything is written clearly and makes you want to start the programming now.

The book is highly recommendable! On no more than 239 pages including the index you'll get all what is needed to start doing your own development with confindence that it will work. I really believe that all the code in the book was tested. Do yourself a favor: Buy this book if you want to program JAVA on the PDA's!

It is a stark measure of how far computers have come that the author reminds us that today's typical PDA has about the same CPU power and 4 times the memory of the first Macintosh, and likewise of a comparable contemporary PC. So while you may be a programmer on a current workstation with heaps more memory and speed than a "constrained" PDA, migrating to it would still mark you as a power developer by the standards of a not so distant past.

If you are already programming in Java for a desktop, then this book will be an easy stroll in the park. The graphics and networking libraries are different from J2SE and J2EE. But this is only insofar as they have necessarily much less functionality, though retaining just enough to hopefully do what you need. Gnash your teeth at the loss of cool graphics, if you must, but that is how things are. The neatest part of the book is the descriptions on how to offload the heavy computations via web services. This may be new to you.

By the way, if you are interested in the book, also check out "MIDP 2.0 Style Guide" by Bloch and Wagner; also published by Addison-Wesley. The two books complement each other. The latter gives a high level description of the appearance and functionality of a UI on a small device. Wilding-McBride's book then shows code examples to actually let you do this, at least for PDAs. Surprisingly, neither book appears to reference the other, though they are by the same publisher and came out just a few months apart. So, at least let me do that for them here.

So this book started well, with lots of sensible thoughts like making all the source code available for download to avoid long listings in the book itself. Although as I read through there still seemed to be a fair amount of code (e.g. p109 -113 is all code) but presumably this was still only the "critical" bits of code needed to understand thte points being made. Generally I thought the first three chapters of the book were very strong - the description of CDC, CLDC and MIDP left me feeling more certain about what they actually are:

CDC and CLDC are "configurations" which means JVMs with some basic APIs
MIDP is a "profile" which is additional APIs which will work on top of a "configuration"

Chapter two was particularly interesting, focusing as it did on the different types of PDA available, comparison of prices, relative market shares, and performance specifications for different PDA/Java combinations. Although naturally this look at the current market will date most quickly, it provides an interesting insight into PDA trends in this period. Overall the book gives a strong impression of having been written by a single developer (which it has) who has a lot of hands on experience with Java on PDAs, and thus has a lot of relevant advice to give. This is exemplified in Chapter three where we are taken through a selection of open source and cheap development toolkits, as well as the process of setting these all up to get started developing on the PDA.

Unfortunately after this strong start the subsequent chapters fall to some extent into the standard "work through the API" approach, so that while the chapter on user interfaces encourages us to consider carefully the restricted screen space on PDAs, the body of the chapter is simply a description of the different types of user interface component, rather than a more detailed look at when each of the component should be used and to what effect.

I don't want to be overly critical here since there is a burden on authors of technical works to make sure that important sections of the API are covered, however I find I am not really able to take in more than trivial amounts of code from the page of a book (I need to be running it and making changes to bits before I understand it). The screen-shots from the PDA help here, but really I wanted more from something in book form. Ideally I would like to see a paragraph or two on the pitfalls and advantages of using each kind of UI component in a PDA setting. Even better would be a sample project, where we work through two possible user interface solutions, one designed without much thought on the constraints of the PDA and one designed with the PDA in mind.

To be fair some general guidelines for developing on the PDA are outlined in chapter four but it is fairly short, and lacks examples. To make this book "really useful" rather than just "handy" I would like to see a much more rigorous analysis of two versions of a sample project, one done correctly and one done incorrectly from the PDA perspective. This kind of comparison is hinted at tantilisingly at various points in the book such as the comparison between SOAP, HTTPText and HTTPStream in the networking chapter. The author shows that he is capable of presenting the pros and cons of different alternatives in particular areas, so it is a shame that this approach could not be developed more thoroughly. The very short concluding chapter on Futures, only confirms the impression that more time could have been spent on this book to good profit.

Still, while I think the reader can rightly ask for more, there is still alot here - I am sure that anyone developing Java on PDAs would be well advised to have a copy of this book on their desk. We can only hope that the author will be given more time to develop the themes touched upon in this work in a subsequent publication.

While I do not currently write anything for PDAs, it is clear that the majority of the growth in the use of new computing devices will be in handheld devices. This will of course require an enormous amount of new software to be built. While the power of the handheld devices continues to grow, convenience, if nothing else, will demand that the size remains small. This will limit the size of the screen and the amount of memory available. Therefore, while it is possible to port software used on desktop platforms to handhelds, it is not an easy task and even in the best of circumstances, significant changes have to be made.
In this environment, it seemed logical that I learn the basics of how to program PDAs. Since I am now primarily a Java programmer, this book seemed like a logical place to start. From reading it, I learned a great deal about how the programming of PDAs is done. The book opens with a description of how the Java standards relate to PDAs as well as the availability of Java implementations on the most popular PDAs. This is followed by a list of ways to obtain the software needed to start developing software for PDAs. Chapter four covers some of the major restrictions encountered when programming PDAs. This chapter is essential and was the most interesting. The remaining chapters contain demonstrations of programs that create screens displaying the usual range of user interfaces. Buttons, checkboxes, filedialog boxes, alert boxes, textboxes and the various layouts are illustrated with code. Some of the common actions, such as serializing object data, accessing JDBC databases and using Internet protocols are incorporated into the programs. As an experienced Java programmer, I found the programs fairly routine, although there were some differences that needed to be understood.
There are no great revelations in this book, just a solid introduction to one area of computing where the growth over the next decade could be incredible. I have elderly relatives who have never touched a computer, and yet they have cell phones and are learning how to use some of the advanced features.

Very happy with the content of the book, but very disappointed that the book only lasted a week before it fell apart.

If not for its minor typo errors in the text and code, I would have given this book 5 stars.
If you're a bedroom Java programmer like me, then you can repair the code easily. Also the code examples weren't "perfect" implementations of Object Oriented Programming concepts but I believe this was intentional considering the latter would have been an additional layer of complexity and would have detracted from the book's instructional value.

The chapter on Servlets could have been longer by providing simulated web-based transaction (i.e. two-player tic-tac-toe or even against the server, or a simple business transaction using a non-database source -> text file).

The bonus JavaMail chapter was superb! If you excel in AWT/SWING, then you could make a GUI-based e-mail client with this chapter!

In my opinion, the RMI and CORBA chapters could have provided a little background on distributed computing theory. While the book overall is clear and well-organized, those without distributed computing theory background (like me) would have trouble understanding these chapters (i.e. where did the words stub and skeleton come from?) I bought this book for the networking and not the distributed computing chapters, anyway, so don't let my inexperience with distributed computing make this book any less worthwhile.

I'm just being my own opinionated self but I found this book to be truly excellent and personally give it 4.5 stars!

One of the best books I've purchased.

I bought "Java Network Programming and Distributed Computing" for Sun's Developer certification exam which requires knowledge of the information given in every chapter, for example RMI, sockets, serialization, and threading.

The book progressively gives you information you need to understand how the different protocols work, when, where, why, and how to use them and gives good explanations of its source code examples.

I feel I received more than my money's worth and will be looking for more titles by David Reilly and Michael Reilly.

This book is an introduction to four major areas: networking, Java language, Java network programming, and Java distributed computing. Dozens of published books are specifically dedicated to each of these topics in detail, but this book is trying to give a reader a taste of all these technologies at the same time.

The book is easy to read. Most of the material is clearly explained and illustrated. Code examples (demos) are clean and complete. The demos are not contrived, but present to the reader interesting implementations that may be reused and give a good idea of how programs that are commonly used may work (SMTP, POP clients, HTTP server, etc.). Each of the demos is followed by a detailed explanation that focuses on how the demo works.

I like the book, although I think that the chapters covering Java language programming are extraneous: if you don't know Java, you should learn it from Java language specific books first, and only then venture into the advanced topics of Java network and distributed programming.

The book reminds me somewhat of the classic "Unix Network Programming" by Richard Stevens, which was a must for any C/Unix programmer more than a decade ago.

Most of my experience in network programming comes from W. Richard Stevens' "UNIX Network Programming", where there's lots of detail in the TCP/IP protocol, and using C to implement it. At the time, the professor teaching the course tried to provide us with comparable programs in Java, but not having a good Java networking book to consult from was a drawback to those segues.

This book serves as an excellent companion to Stevens' book, so that you can get the feel for how Java accomplishes networking capabilities. I still prefer the TCP/IP detail that Stevens' book provides, but that's mainly because I like the language independent concept of networking.

I created a small client2client messaging applet, sent it to a couple of friends for testing, and enjoyed how quickly and easily it was to get it working. Java abstracts a lot of the detail away from the user, since it was designed from the get-go to include networking capabilities, and this book uses those abstractions to its advantage. I'll probably want to get my hands dirty and see how much hands-on control I can get with Java sometime later.

(Reilly*2)'s book is a great way to just jump into network programming without getting your head too tangled with TCP/IP intricacies. This is not to say that the book doesn't cover those details, but it doesn't delve into them as deeply as Stevens' book does. In my view, that's a drawback to it being an absolute reference, but for many who just want to start developing client/server apps, this may be just what you're looking for.

i seen that other people had good marks to say about this book, and one had adverse things to say about it, take my advise either borrow it from a friend, or look at a salvage book store, save your money, give it to charity!

Whether you see the Internet as a business venture, or simply wish to find out more as a new user, `Marketing on the Internet' is a delightful book to read. Its logical structure takes you through an overview of the subject right onto specifics on doing business on the world wide web. What's more, the authors have taken care to cover issues such as security and privacy, which are crucial elements of any e-commerce transaction today. There's also a section on creating your own web site, which is a great help to small businesses and individual users who wish to design their own `pages'. With its huge list of online resources available to draw additional information from, this is an 'everything you wanted to know' book about marketing on the Internet. Don't let its bulky textbook format put you off. Read it if you're thinking about getting `into' the Net.

This book, written in 1996, set up much of what we know about Internet Marketing. Pretty much every book that followed it used the concepts and ideas. The author won the Tenagra Award for Internet Marketing in part due to this groundbreaking book. The concepts are as fresh today as when written. A must have book for net marketers

Whether you see the Internet as a business venture, or simply wish to find out more as a new user, `Marketing on the Internet' is a delightful book to read. Its logical structure takes you through an overview of the subject right onto specifics on using the Internet as a marketing tool... leading onto ways and means of doing business on the world wide web. What's more, the authors have taken care to cover issues such as security and privacy, which are crucial to any e-commerce transaction. There's also a section on creating your own web site, which can help small businesses in getting their venture going. With its huge list of online resources available to draw additional information from, this book is an "everything you wanted to know" book about marketing on the Internet. Don't let its bulky textbook format put you off. Read it if you want to get `into' the Net.

I have read now numerous internet marketing books and this one is still the best. This was the first internet marketing book and created what we now think of as "the standards" for internet marketing. Brilliant. Read this one if you read any of them.

Very nicely written keeping real world requirements in mind. Could have had some more examples.

This book is not really about testng. it's more about the author's opinions about testing, which are for the most part valid, but I bought this book mostly for the testng part, and I guess I'll have to wait to find something more targeted towards teaching just testng.

College-level libraries strong in Java programming guides need NEXT GENERATION JAVA TESTING: unlike many Java programmer's guides, it provides a pragmatic discussion for Java developers interested in building stronger code for applications, and packs in chapters discussing testing methods, tradeoffs associated with testing, applications of testing theory and rules, analysis of partial failures and remote invocation, and more. In-depth and extensive code examples throughout also differentiate NEXT GENERATION JAVA TESTING from competitors, making it a top recommendation.

Diane C. Donovan
California Bookwatch

"Next Generation Java Testing" has a subtitle: "TestNG and Advanced Concepts." This isn't surprising given the creator of TestNG is an author, but is important to realize. It starts with 6.5 pages on why TestNG is better than JUnit 3.8. Then only two paragraphs on JUnit 4. This has been a pet peeve of mine for some time. It's like comparing the current version of C# to Java 1.3 and then saying Java is worse because it doesn't have generics.

I liked the code snippets in the TestNG sections as they focused on relevant pieces. The examples were to the point. Especially the performance and J2EE sections. I liked the concepts described in chapter 2 (over 100 pages.)

The authors describe open source libraries that integrate with TestNG. I liked this coverage although JMock could have used a code example for comparison (easyMock had one.) Ant targets were provided for the code coverage examples.

Chapter seven is titled "digressions." Some quotes from the text on this: "pet peeves, rants, annoyances and musings", "much ... very tangentially relevant", "some ... outright irrelavant." I agree with some and disagree with some. I think this chapter would have been better as a series of blog posts than a chapter in a book.

If you are using/planning to use TestNG and can ignore the rants, this is a good book.

At last a book that deals with testing applications (in java) that seems to be written by author's who have worked with real life, non trivial projects(TDD with adding two money objects together, anyone?).
This book describes using TestNG along with some advanced TestNG concepts and goes on to show how to use the framework to test out JEE projects. There are also chapters showing the developer how to integrate TestNG with other frameworks (like spring, DBUnit, jwebunit etc) which is useful as this is perhaps the only place where JUnit is better than TestNG. Inspite of the fact that TestNG documentation is pretty good, this book is worthwile buying (even if you use JUnit as your testing tool of choice).
There is useful coding and refactoring advice along the way(also a commentary on TDD), and a miscellaneous chapter of sorts which seems to have been written by Hani and edited by Cedric to remove all profanities!.
I do hope the author's expand the testing enterprise application bits to cover more testing scenarios and examples in later additions.

Great book! I had been chewing around DWR with Spring for a while. This text presented all I needed to know in understandable terms with examples. The author's attention to the background understanding needed is appreciated. Now have DWR working with Spring.

The authors have taken good efforts to neatly introduce, analyses and compare various javascript tools specifically meant for AJAX.
The flow of the book is well managed and its very reader friendly.
This book is definitely a one stop reference for knowing what development tools, editors, libraries available for supporting AJAX in Java web applications.
Comes with 50MB examples source code. The source code has been configured to easily deploy and test using ANT.
This book mostly addresses the freely available AJAX tools.
Few drawbacks i found:
A lot of pages have been spent on describing and comparing between java frameworks, the authors could have avoided it since this book about using AJAX in java framework.
The code listings in the chapters (like html, javascript, jsp) were not well formatted, so it very difficult to read.
The authors gives more preference to JSF framework which is again not the context of the book.
Thats it.

Since the book is published recently(July06), this book covers many latest AJAX and JAVA Framework products, so its saves your time on finding a right tool
for your ajax based websites.
I dont want to write again the table of contents of this book but want to mention that you will sure learn all the bit and pieces that you need have for setting up a AJAX based
java web applications.

In researching AJAX-specific books, I found they all covered the raw core stuff (what XMLHttpRequest is, what it does, and how to use it) but most of them gave only passing coverage to the frameworks/toolkits available for AJAX and DHTML processing. (e.g., "XYZ is a very nice new toolkit for building AJAX-based web applications. Go to the XYZ web site and read the documentation that isn't there yet to see non-existent examples and learn how to use it.") "AJAX Hacks" came pretty close with some good examples, but without enough breadth and depth. (It is, after all, a "hacks" book.)

Just the presence of good examples and good coverage of Prototype, script.aculo.us, and DOJO in this book is enough to make it worthy of note. But the focus of the book is using AJAX with Java frameworks like Struts, Spring, and JSF, and in that regard it also does not disappoint. So you get not only some nice coverage of the client-side toolkits/frameworks that make Ajaxian things happen in the browser, you get a solid grounding in how to connect them to server-side applications using these Java frameworks.

Some deeper coverage on things like JSON and REST would have been nice, though.

"Ajax" is simple ... but if you want to use Ajax, then you need to write JavaScript. Quite probably lots of client-side JavaScript.

And that's where "Pro Ajax and Java Frameworks" comes in. It does a good job of explaining Ajax, what it is, and how your web app will benefit from using it. So do all the other Ajax books on the shelf.

But that's just Chapter 1. The REST of the book discusses tools and techniques for writing and debugging JavaScript. And then introduces some great, full-featured Javascript libraries to save you the tedium of having to "roll your own".

This information is enough to help you successfully launch your first Ajax-based web app. It doesn't matter if you're using Apache or IIS; if your backend is J2EE, .Net or simple HTML: the book will pay for itself on your first project.

But all of that's only the FIRST half of the book! The most valuable information is covered in the second half, which goes into great detail on how to effectively use Ajax with frameworks like Struts, Tapestry, Spring and, lastly, with JSF.

A great book: highly recommended for any web developer who wants to understand Ajax ... and how to use it effectively.

I really don't like this book, and don't understand the positive reviews it got. It's a vague and shallow overview of a bunch of ajax-related framework that will not help you get anything useful done. Buy only if you have money to waste. If you are a Java developer interested in Ajax, and looking for a useful book, try "Practical Ajax Projects with Java Technology". Not perfect but worth some money.

I am using this book to bring myself up to speed on a project that combines Velocity with Struts. I'm working with Struts and Velocity modules built by a consulting company. Before the project, I didn't know either one. Now I am in the middle of the project and somewhat familiar with both. Most of the velocity commands I am able to figure out pretty quickly without the book, which is good because every time I try to find something ($link.setAction for example, which is needed to obtain the URL for forwarding) it's not there. Maybe I'm missing something, but if I am, it also is not identified in this book. I'm doing much better by referring to my Struts reference(Programming Jakarta Struts) and searching the web.

Although the first few chapters provide a good description of the Velocity Template Language and how to drive it, I found myself progressively flipping pages after that. I also read Harrop's Pro Spring, which was much more information-dense despite being over twice the size of this book.

If you are not yet familiar with concepts like MVC, layered application design, Struts, Spring etc: ignore the previous ;-)

It is a good book, nevertheless be careful to try to take the Java code for your production environment, in page 189 when it is explaining about the shopping cart makes money operations with type double when should be used BigDecimal in this case.

This is an excellent introduction to the Velocity template engine. It covers the basic use and syntax of the engine, then embedding and extending it. It's very well written and organized.

On the downside I think the graphics could have been used more effectively, and I would have liked to have seen more on the basic template syntax. Overall, however, I highly recommend this book to anyone for whom the Velocity template engine is a central part of the architecture.

I have always been a strong supporter of Velocity. I even wrote an article for JavaRanch about Velocity back in March. Velocity is an open source template framework designed to simplify the task of generating content such as web pages, email, or any other text-based output. The Velocity documentation available from Apache is short, low on examples, and leaves holes (even if it is fairly good compared to some other open source projects). This book fills in the gaps and gives excellent coverage of the many features that are available with Velocity.

The book starts with an introduction to Velocity and then explains how to install and configure it. The author then discusses the Velocity Template Language, examines its shortcomings, and demonstrates how to get around them. Best practices are covered early in the book. Although Velocity is normally thought of as a web-based framework, the author doesn't let us forget that it can be used for both stand-alone and web applications and gives us detailed chapters on both. Velocity tools are well covered including Anakia, which can be used to transform XML. The Velocity architecture is explained as well as ways to extend that architecture.

The examples are well thought out and give good coverage of the features of Velocity. The most interesting part of the examples is how little work it is to integrate Velocity into a well-designed framework. The author shows how Velocity fits into both Struts and Spring, demonstrating that Velocity is not meant to replace these frameworks but rather to simplify content generation in any framework. I can strongly recommend this book for anyone interested in Velocity. For anyone not interested in Velocity, the question is, why not?

The authors are XQuery standardization committee members with long tenures at Oracle, thus possessing an unique grounding in that 'other' query language, SQL. As a result, the book is balanced with respect to what SQL/XML and XQuery can respectively do. A number of examples are provided, to illustrate where XQuery is useful and where other query mechanisms might work.

I've been an XQuery developer for an academic press for a number of years, and I read this book cover to cover. It sets out to describe methods for querying and does so,
in an almost scholarly fashion, for many common but different contexts. I found it provided cohesion to the diverse world of XML, from broad subjects to the details of spec grammars--a very welcome contribution to a technical library.

My only complaint with this book is that it emphasizes DTD over Schema a bit too much. For this and other reasons, I felt the treatment of XML seemed a little dated, and also a bit shallow.

If you need to learn XQuery or XPath fast, this is not the book, or you need to skip the first 8 chapters. XQuery and XPath are hardly even mentioned until Chapter 9. The first 8 chapters discuss everything except what is in the title. XML is a pretty boring topic, and excess verbage doesn't help.

I have had this book for almost a month now. This book is painful to get through. I can usually get through a technical book within a week and try some examples. I started reading this book front to back and did not skip any sections.

I am not a NOOB when it comes to XML so I found this surprising. I am a certified XML developer (from before XQuery), an experienced programming engineer of 8 years, an MCAD.Net, and I have even written a paper on XQuery for a Master's Program and I simply have become unmotivated and am struggling to get through this book. As others have stated in reviews, this book takes a long time to get to the point. I like to get my money's worth when I buy a book though.

I kept asking myself chapter after chapter "when do we start programming some examples?" The first 10 chapters are filled with everything but XQuery. The author covers the background of XML and why we would use XQuery in detail. I see the argument for why this book may be beneficial to some but if you wish to get up and running on XQuery this is not the book for you.

I may update this as I finish off the book. I am getting more into actual XQuery syntax and grammar as of chapter 11. A flip through the TOC shows that the author covers some implementation info. My goal was to have a better understanding of how to actually implement XQuery and learn some of the more detailed points of it versus just FLWOR that the numerous online tutorials offer. I have purchased another book by O'Reilly instead.

Update: I received the O'Reilly book right after writing this review. I flipped through the TOC and first few pages of XQuery by O'Reilly for a comparison. Wow! These two books could not be any different. I am on chapter 5 of the O'Reilly XQuery book just in a few hours of off and on reading at work. It appears thus far to be the better choice. Luckily, work is paying for these books so I was only cheated out of time buying "Querying XML".

I used Schaum's Outlines Series during college and was always impressed. This one was also impressing!

I have also repeatedly noticed that Java can be difficult to learn. This is because it is really Object-Oriented and I always found it difficult to have the JDK and everything else together for a student that was getting the first exposure to Java to obtain practical experience to build confidence.

Bruce Razban,
President/Founder, Razban Internet International,
Silicon Valley, CA, USA

In the fourteen chapters, this book does an good job of helping students get a grasp of Java, compare their answers to correct answers and learn from their mistakes instantly. The typical problem for others that do not have this book is that they get stuck and then, they have to find the correct answer by trial and error.

I would however, recommend a more robust coverage of the Object-Oriented example.

I found this book as a very good way to teach and learn, and it is reasonably priced.

Bruce Razban,
President/Founder, Razban Internet International
Silicon Valley, CA, USA

While this book is far from complete, and the examples are less than practical, it has the virtue of being affordable by students. It's a good choice as textbook for a course, where the main content comes from instructor-provided handouts.

Earlier I had purchased Hubbard's C++ and had no complaints.But this book by the same author leaves much to be desired. The explanations are well written, ...typically Hubbard style, but I was very dissapointed by the way the examples and the chapters were organised in the book. A newcomer who is learning example by example and from chapter to chapter is bound to get confused. In an earlier chapter, an example uses try and catch block to take an input from the user, but the mechanism of try and catch blocks are explained much later in the book. So this book is basically for those who are already conversant with Java and just needs a good brushing-up. If you are new to Java, use this book as a supplement rather than your main text. The examples in the book are excellent and fun to try out.

As another reviewer has pointed out, there's a lot of help in setting up the jdk, but be aware that the information is given only for Windows. The basics of the language are covered well, but you should have your textbook handy. There are a few mistakes (not mistakes really, but the author didnot want to bring in all the complexities). As a college text, I was looking for some more math based examples, but there aren't too many. The ones he does give don't use adequate formatting of the results. For example, the results for a particular problem (getting the values of sin(x)) are given to 16 decimal places or so. But the exercises themselves are great for practising, which will surely come in useful.

The thing you have to keep in mind is that it is designed for students. It concentrates on the basics of the language -- flow control, variables, etc. It has great exercises. But it doesn't really focus on GUI design. I found it invaluable for prepping for the Cert exam however.

And, it is very cheap.

I have had this book for a while now, and I do find myself going back to it very often. It is very well written and explains the nuts and bolts of a complex technology in a way that is neither too simplistic nor to verbose. A good balance of theory, reference, tutorial, and design guideline.

The story build-up is terrible. Each time the authors try to explain something, they start talking about something else they promise to explain a few chapters later. Too much how, not enough why.

My opinion: very well written, much easier and more fun to read than Ed Roman's book. Plus, excellent coverage of the related subjects: JNDI, transactions and so on. If you have to buy only one book on EJB, buy this one. If you can buy two books, second one is O'Reilly's book, which actually might be somewhat better choice for beginners or if you have to learn EJB fast (but not deep!)

I give this book an A+. The first thing that hit me is the book is full of practical knowledge and experience. It's obvious that the authors have built enterprise-level systems for real companies and have not just packaged up the spec. The chapters are well organized and the writing style is exactly what I want. My only complaint is the CD contains a copy of WebLogic 6.0 and not 6.1 as it should. I've been told that the publisher is correcting the mistake. No big deal because WL is available for download from BEA. Having a trial copy of TopLink with the book is an added bonus.

I found this book to be an excellent source on EJB and design in general. The authors don't stick to the normal format of typical EJB books and actually cover material that you don't find in other books. This makes for more of an enjoyable read.

The included source was very helpful, as well as the warnings and tips. Good work on such a broad and complex subject.