Variants Books

This book is a very good book to start with web service. The explanation and examples provide most of needs to start with a web service project. It has sufficient details to use Sun tools. Readers can easily found most of their interests on this topic. The major drawback is the short of coverage on implementations of weblogic or websphere, which are of interests of most programmers. This is excellent book for starters or mid-level developers

A good reference book for Java Web Services. It had most of what I was looking for. Lacked depth and samples but the nutshell series was always meant to be more a reference than a tutorial.

Like the other Nutshell books in O'Reilly's series, this too is designed to provide the most valuable information in the least space possible. Some people criticize the Nutshell series over this issue, but it is really the strong point of this book-it is designed to be used as a desktop reference. I have always liked the Nutshell book, and this one is no exception.

Again, this book isn't designed to be a how-to, and O'Reilly doesn't claim it as such. It's designed as a desktop reference, which is really where this book shines. Java web service developers will find this a valuable addition to their library.

If you start reading about web services developed in Java, you'll quickly find that there are a number of Java technologies that come into play. These include SOAP, UDDI, WSDL, and others. Since you'll need to know about all of them to effectively develop your services, you'll need a book that covers those areas in detail. One of your choices would include Java Web Services In A Nutshell.

Like all Nutshell books, this is not an entry-level tutorial on the subject. It assumes preexisting knowledge so that less time is spent on the basics and more space can be devoted to the more complex intricacies of the technology. If the chaptersin the table of contents do not sound familiar, you're most likely not ready for this book. And yes, I would also include myself in that group...

The first 2/3's of the book cover the different web services packages, both conceptually and in practice with examples. You should be able to use the examples to jumpstart your own development efforts. The last 1/3 of the book is the traditional documentation of the package API information. As with most Nutshell books, this will be the area that quickly becomes worn and dog-earred.

Conclusion
If you are past the "What are web services?" stage, this book will be of value to you. If you are still trying to figure out what all the hype is about, I would recommend a more entry-level book like Java Web Services by O'Reilly.

I found this book gave a good overview of JAX-RPC and JWSDK
features. But this book is very specific to the Sun JWSDK
implementation. There is nothing on Apache AXIS or differences
between implementations. The biggest deficiency for me was that
there is nothing at all on DIME and it only dicusses the
non-standard Sun JWSDK SOAP with MIME attachments API without
mentioning any alternatives.

This book, which purports to be from "the ground up" actually spends most of its text on building bean *content*. If you just want to know the ins-and-outs of building a bean, testing the bean, creating a JAR file, and loading and calling the JAR file in an application, this book is shockingly lacking in that most vital of information needed by a beginner JavaBean writer. Worse yet, the book is hopelessly out of date. The Bean Development Kit it uses for testing beans is no longer supported by Sun Microsystems. The new IDE, Netbeans, is not even mentioned in this text. Lastly, I found this book hard to read. This text is dead, and its death was not pretty. Do not buy this book.

This book was loaded with examples. The examples can be downloaded off of the internet, which is great because I've had CDs in books arrive broken before.

The step-by-step RMI instructions helped me a lot with my assignments, and I learned a lot of stuff from this book.

I would not recommend this book to a programming beginner, though. It assumes that you know at least some basics of a high level language.

OK, so I am hard to please... The book was very good- delivered on its promise to teach Java Beans. I have the following observations:

1) Never came out and said exactly what a Java Bean is- a component that can be manipulated in a visual builder. The Beans spec addresses the mechanism by which a Bean exposes its features to the Builder. The book covers additional material, which *should* be covered, but never makes clear what makes a Bean a Bean.

2) Stuffed (padded?) with examples.

3) Section on Introspection was not as clear as it could have been. I downloaded the Beans spec from the Sun site, and that helped fill in the gaps.

Overall, I would definitely recommend this book.

This is a very good book well worth the money. I would have given it 5 star rating, except for one thing. The author should have explained more clearly about the method of mapping used in chapter 3 since it is different from the previous chapters. It took me very long time to figure it out. My conclusion is go buy it, but be aware of what I just said.

The book is really worth buying. It explains all the bean concepts clearly and has good complete examples. Great Job !

With the benefit of hindsight, the book's topic has been rapidly eclipsed by Service Oriented Architecture. It turns out that JMX simply was too awkward to implement. Hence, you are warned. While the book is well written, it does not indicate that you will be trapped in a dead end if you take up JMX.

Try instead looking up books on SOA. While that is not guaranteed to be more successful, it currently attracts much attention.

In classic Manning fashion this book is concise and focused, uses graphics sparingly and effectively, and does a great job with code annotation. The problem comes with exposition. What I wanted was a book that not only explained what JMX was, but why I would want to use it. I found that this book had a ton of technical detail, on what is undoubtedly a complex topic, but lacked much in terms of context. More how, less why.

That being said, I understand that most readers are looking for the technical side of the argument and the book has that in spades. Particularly nice chapters are chapter one, which does provide a little context for the use of JMX, and provides a very nice, though brief, overview of the JMX architecture. Chapter six, on agent notification is also excellent.

Frankly, I would love to see a second version of this book with more emphasis on use cases. For example, chapter 7, on dynamic MBean creation, would do well to cover why you would want to use Model MBeans, and not just assume the reader understands the solution out of context with the need.

If you are on a project using JMX or an architect who is already looking at JMX, this book is worth the look. If you are looking for a gentle introduction to the topic, keep looking.

I have found this book extremely helpful to my development efforts. The code examples were key in helping me understand JMX with EJBs and JMS. In my rapid development activities, the good, clear examples and concise points helped me write effecient and better code.

Also, it is stated in a previous review that you need to have the JDMK in order to compile the code . This is not necessary for you to be successful with this book! One does not need the JDMK; the free 'remoting.jar' can be downloaded from the JMX website at java.sun.com. This jar file contains the RMI adapter and is only needed for a small part of the book.

This book is definitely the best source of JMX material that I have encountered.

This is an excellent book on JMX. It takes us step by step thro
the process of knowing and using Sun's Reference Implementation.
It covers both the HTML Adaptor and RMI Connector approaches
thoroughly. Code examples provided in the book are well
explained. A must have for any one seriously considering a
foothold in JMX. I have enjoyed reading the book and putting it
to practice in my job. If there is
a future version, I would like to see coverage on JBoss's JMX.
Many thanks to the authors.

I have found this book extremely helpful to my development efforts. The code examples were key in helping me understand JMX with EJBs and JMS. In my rapid development activities, the good, clear examples and concise points helped me write effecient and better code.

Also, it is stated in a previous review that you need to have the JDMK in order to compile the code . This is not necessary for you to be successful with this book! One does not need the JDMK; the free 'remoting.jar' can be downloaded from the JMX website at java.sun.com. This jar file contains the RMI adapter and is only needed for a small part of the book.

This book is definitely the best source of JMX material that I have encountered.

I bought mamy books and do not have time to write many reviews. But if I was really disappointed in a book, I want to write a review. There are many junk Java books in the market. This one is not better than them. The book even does not have a good example to show what a J2EE technology is. If you have money and just want to put a book on your book shelf to look up occasionally, you can consider this book.

This is a great follow-up to the book "Beginning Java Objects: From Concepts to Code" by Jacquie Barker.

I bought this book looking for an introduction to some of the areas of J2EE that I'm not expert in, half expecting another huge book full of code listings and reprinted javadocs, but I've been pleasantly surprised. As of this writing, the book has the most up to date coverage of j2ee I've seen and manages to pack very good introductory material into all the subjects I've looked at. It also gives enough detail for you to be able to understand the topic enough to start writing code and sifting through the API javadocs. The writing style is generally clear with good examples, although I noticed a couple of sloppy sections, but that can be excused in a book this size.

I haven't bought a Que book before, but I'll look at them a little closer now.

If you are searching for a reference manual that covers the basics about all the technologies involved in J2EE this is the book to buy. Keep in mind that it is impossible to cover Enterprise Java Beans,JSP,Servlets in detail in just one book. So if you're after a special thing like only EJB feel free to buy other books that cover only Enterprise Java Beans but otherwise this book is really worth its bucks simply because it introduces you to J2EE and afterwards you are able to understand what all those things are about.

Whilst I feel the book is excellant value for money and the Author has done a good job I would argue that some of the material in the book should have been excluded (to save a tree or two) e.g. Chapter 2,52 - 54 and included in appendix ? - but hey thats me trying to reduce the 1000 odd pages that I read !!.

Overall Comment - definately worth buying, but my advice is to allocate some "quiet" time to read and digest all the material - Not really for the beginner.

It is a good book and the examples are good. I was hoping for more information on web applications. The focus is really XML Web Services.

I have read this book and find that it is a good book if you want to get started with Web services on BEA Weblogic workshop. The starting chapters are good and they really work in Workshop but the ending chapters have lost focus and become very theoretical. If the authors can work the last chapters so that they provide more hands on knowledge to devlopers, it would be great...

This is a excellent book and does a terrific job taking you through the WorkShop and using it to create Web Services.

I could have probably stumbled through the stuff without going through this book but it would have taken me much longer and I wouldn't have learned as much.

If you want to get up and running quick with this WorkShop tool buy this book and you will be rocking in a short time.

I like this book. It was a big help for me to get started with Weblogic Workshop. I found it to be organized pretty well and the information extremely helpful.
I would recommend this book to someone that wanted to get started quickly with Workshop. But one problem is by the time I got this book and created Web Services with 7.0 then Weblogic 8.1 hit the market.
Also, the BEA documentation is very good and I could have probably gotten by using their resources. However, the amount of documentation and detail is overwhelming. I found this book helpful as well as an excellent starting point for WebServices and Workshop.

If you want to learn Workshop, buy this book! By the end of the book you will be flying thru the tool.

The early chapters go easy and introduce the development environment. This is extremely well written.

And the examples in the early chapters work! You can easily create the web services yourself.

The later chapters loose focus on examples and more just explain how to do the task using workshop. And then the final chapter, "An Online Ordering System", seems to be written by an alein; the one web services does not work and will not work the way it is declared, one of the jave files is missing completely from the text but is provided on the CD. This is the reason for only four stars.

And then when you go to SAMSPUBLISHING web site, they have lost the book completely.

Great book on Datastructures. Much verbose than the other books. But the java example in this book are horrible, particularly the variables used. Just letters are used as variables, instead of appropriate names, making it very hard to follow the example.

So overall, I would suggest buying Adam Drozdek's algorithm book.

This series is a treasure to keep. The book is filled with great diagrams and very easy to understand language.

These text(s) do for the software engineer what Cormen's book does for the scientist. To be knowledgable with algorithms will greatly seperate you from a novice.

Very good examples and using Java is very smart because most OO programmers can easily understand the language (C# is practically identical).

For those who struggle with the Cormen book, (Like I did) it would do you well to get this book. You will refer to it time and time again in your career as a software developer while the Cormen book collects dust on the shelf.

First is Knuth, second is Corman that brings the art of algorithms closer to earth. Then is Sedgewick. This book provides very good balance between theory and practice and lets the practitioners know that programming is a bit more than just writing "if" and "for" and that the art of algorithms is not only art but also science. This book evolved from early editions (Algorithms in C, 1990) and keeps the standard. These two volumes is the must for every serious programmer.

Cons: Java code is a bit "C-ish" and makes it clear that it is easy to write C program in Java. In addition, section Geometric Algorithms from 1990 edition and other material following this section is missing in newer editions. Maybe this material will be included in Volume 3, that as rumor says, is in preparation.

This book is a total mess, I don't know if it's the author or the publisher but is written in a style that got me really frustrated.

The author has the bad habit of start explaining a thing a little bit (not enough to fully understand it) then say something like "we will cover this topic in depth in chapter 7", and you are in chapter 2. This sort of jump back and forth is completely frustrating, the book doesn't seem to have any kind of flow. The same technique is used inside a chapter too, you start reading about something then the author start diverging in the middle of the topic to come back after few pages.

The code samples are a total mess, it's just really bad. I mean common, read any introductory book in software development and you get warned in the first chapter not to name your variables i,j,v i1...just give them a meaningful name.
Every time I read sample code in this book I had to spent at least 20 minutes deciphering what the variables are suppose to be, why the author define variables that are not used at all or they don't have any kind of effect on the end result (yes, I did found a whole bunch of these). If you don't know Java or don't care to follow any of Java standards fine, write C code or something, at least I will be prepared to read obfuscated code.

I give this book 2 stars, it has after all a lot of information in it, even if it is scattered all over the place

Took a Java class awhile back and purchased this book. Turns out I recently had a need to brush up on Java for work. Thankfully, this book really came through to teach & refresh me the fundamentals as well as the details other books just glossed over (I was flipping furiously through 2 other Java books until Gittleman's book had the answers!). Needless to say, I can't rave enough about this book. Not sure what the other two reviewers were talking about ranking this book as low as they did. Yes, there are a FEW typos, but lets focus here on content. 5 out of 5! Go Beach! Happy Valentine's Day!

The writing in this book is often hard to follow. When they try to break down concepts for you, their analogies are often illogical or simply not helpful. Also, the order of chapters makes very little sense to me (for instance waiting till chapter 7 to introduce User-Interfaces). As a beginning student of Java, i know there are better books out there. I would suggest shopping around for a text that is better thought out.

This is a great book for a beginner Java programmer. Many of the concepts are clearly explained and are easy to understand.

However, considering that this is the Second Edition of this book, one would think that they would have addressed the errors in the programs. It is as if no one bothered to compile these programs after they were written.

For example, in Example 2.9 on pages 53 and 54, line 20 states:
"JOptionPane.showMessageDialog("The result is " + result);"
when it should be:
"JOptionPane.showMessageDialog(null,"The result is " + result);"

"Dear Mr. Gittleman: Congratulations for publishing a wonderful textbook of "Computing with JAVA: Programs, Objects, Graphics". ISBN: 1-57676-023-5 It is the best book I have seen so far in Java books: I like your sense of humor, interesting examples, assorted end of chapter problems, non-threatening, and easy to follow book. Best wishes, Theresa Park, Instructor Computer Science Department Texas State Technical College

Looking for a book to teach with? Looking for a book that discusses data structures, JDBC, Algorithm design, pretty much everything? This is the book for you. I was looking for a text for new classes I am teaching in Java and this one fit the bill. Buy it!

This book's a pretty good introduction to J2ME development.

I discovered that I had to add source="1.4" and target="1.4" directives to the javac ant task to get this to work under JDK 1.5. Otherwise, everything worked exactly as advertised. I found this out on my own, as there doesn't appear to be an errata or feedback section at the author's site.

It is a good read on nokia series 40. After reading the books, I continue to build a set of mobile application for Nokia and Samsung phones at http://www.doitech.com/default_files/super.htm The books provides many useful tips, that has shorten my development time. The application allows user to view their ODBC data at their Nokia and Samsung phone, and sync over GSM/CDMA network. Please visit http://www.doitech.com, if you can find the link. Thank you very much.

This is a near perfect guide. Readable, with plenty of examples, it explains everything and provides almost the all required information needed to start programming for Series 40 (and Series 60) phones - assuming you only know Java.

I read this out of pure curiosity, and I must say, I learned all that I needed and much more. It taught everything from internet connectivity, automated building, testing, compiling, and security from secure minded applications to fun 2D games. It's really an amazing book that probably combines a lot of different random white papers from various different perspectives and presents in a complete, comprehensive and clear manner. The examples are informative, representative of real world applications, and are easy to follow.

I found some things to be needlessly verbose, and I wish there were better summaries of objects and inheritance between the required classes, but all in all, it easily provides the foundation needed to create, debug, and test almost any J2ME mobile phone application around. I cannot recommend this highly enough.

The book gives you an understanding of the way the j2me has been implemented on series 40 devices. The best part though is that the authors have provided code snippets of simple tasks that developers need in almost all their applications. I have used the source code not only for series 40 but other devices to.

I would recommend this book for all developers as a reference book. I personally would not get this book as the only j2me book in my shelf.. but its a great second book.

Nokia is the world's largest cellphone maker. While it is being strongly challenged, especially in China, it should still be the first platform for cellphone developers to target. This book explains how within broad parameters, Nokia has opened out its models for developers. It has chosen to use a mobile version of Java. The book shows how to use this and MIDP to develop your application (which is probably a game).

One of the authors, Yuan, wrote a book on J2ME recently, and you may perhaps consider this Nokia book as somewhat of a sequel.

If you're already facile in regular Java, transitioning to this book should be easy. Perhaps the biggest change is the dumping of the Swing and AWT widgets. Simply too heavy for the resources of a small screen and limited power. Hence, graphics-wise, you may find coding rather constraining. But that's the reality of any cellphone.

Another difference shown by the book is that there is now often an emphasis on audio and video capture and playing. At least, as compared to standard desktop applications.

The authors and Nokia have produced a very cleanly laid out and logical presentation.

Good book but no CD and can't find example buildfile online at samspublishing.com. Page 4 and Appendix D both say you should be able to download the examples.

This book is a "must-have" for anyone who will be leading a development project, in addition to being extremely useful for any developer. The extreme programming section is wonderful - it does a great job of explaining a very useful methodology for delivering a successful, on-time, within-budget project. The book also thoroughly explains each topic (such as using Ant for compilation, unit testing, etc) and gives plenty of examples so it's easy to understand. I would definitely use this book every step of the way for a major development project!

As the subtitle indicates, this is a tools book, not a process book. Consequently, the XP practices are merely used as a motivation to introduce new Ant features into the build process - and sometimes this feels rather far stretched. In many cases, a good XP team should try a more team- and less tool-oriented solution than presented in this book. Also, the repeatedly mentioned "lead developer" coming to important decisions by himself feels quite contrary to XPs "Whole Team" practice.

So the book concentrates on covering Ant, and starts quite promising in this regard. Using a case study to show how a build script can evolve with the needs of a project is a nice idea and the introduction to Ant is concise and to the point. Unfortunately, the book later starts to rush through the different topics, a big amount of it covering how to integrate different tools into the build process. There are also some much-less-than-optimal examples, which makes you wonder about the depth of knowledge of the authors; they even show a hand-made solution to implementing boolean attributes for custom tasks, even though Ant comes with a much more elegant inbuild mechanism.

As an advanced "Ant build master", this book still taught me interesting new things about the tool. I'd guess that most beginners would be better off with a book more concentrating on the core concepts of Ant. If you want a good book on Extreme Programming, you will definitively have to look elsewhere.

Pros: Nice writing style, clear and not boring, touches not only Ant but quite a few other open-source tools and the Xtreme programming ways... Cons: its vast breath is counterbalanced by
little depth. Ant 's coverage is appropriate to get you started working with it quickly, and to have you appreciate what this tool can do for you. Forget about being able to work with JUnit or XDoclet just by reading this book. You will barely discover that they exist.. and expect a lot of painful hours spent on the traditionally poor open-source docs.
Overall a good buy though. If you want a more in-depth treatment of Ant I recommend Java Development With Ant
by Erik Hatcher, Steve Loughran

Before I proceed further with the review, I should note that I am the co-author of Java Development with Ant, the book which has been the best selling book about Ant to date. Thus if I were critical of this book, you'd know where I was coming from.

But I am not going to be critical -I am going to say nice things about it, and give it 5 stars as anything else would be unfair. This is a really good introduction to Extreme Programming in Java using Ant, Junit and XDoclet.

After a quick intro to the concepts of XP, this book follows the story of a team that is using the XP methodology to get stuff out the door. First Ant is introduced, the JUnit -the latter being the key to test-centric development. Then as the chapters progress, the new problems are introduced and the code and the build process refactored and expanded to adapt. I particularly like the chapter where a business merger forces a team reorganisation -organisation change does effect projects, but most software engineering books ignore such events, along with team member dynamics in general. It also repeatedly reinforces the need for automated builds and tests, and has some basic coverage of CruiseControl. CC is the system that keeps our team in check: whenever you break the build, you get email. I get a lot of email.

It doesn't go into significant depth in Ant -you will (of course) need the on line documentation, and I would also point my own book. Mostly this isn't an issue -the only place where I had significant differences of opinion was when the book recommended using the task to precompile JSP pages for tomcat. If the authors had tracked the Ant dev mail list, or the open bugreps related to this task, they'd know not to encourage that, because the underlying jasperc doesnt really let you. Also there was some commentary on Ant2.0, which is not going to be the complete rewrite promised on the web site. Again, involvement in the open source project would provide such information.

These are minor issues with the non-core parts of Ant and the book. The central theme of the book: using XP, JUnit, Ant and XDoclet for building, testing and deployment of server side code is well covered, and that is what matters.

If you want to get into Ant, this is one of the two Ant books to consider owning -ideally you should get both :) I think I'd also get one of the XP series books, like XP installed, for a more abstract treatise on XP, Fowler's Refactoring and a copy of IntelliJ IDEA, the best XP-centric IDE for Java.

I found the panther book well researched but a little basic. Some areas including the more obscure late war options need more detail and the book itself would benefit from the latest research. The book is a good read and as such represents good value but leaves you wanting more. Perhaps the Trojca books or similar would be a better option.

This book provides an excellent technical and developmental history of the Panther. The author has obviously done his research on this vehicle. The book is well worth the price.

This is an excellent book by a man who studied every little piece of information available on this vehicle for over 20 years. He climbed inside the thing many times and has been around it more than once. It is writen in a very technical language, so all of you non-mechanics and newbies out there, watch out! If there is one thing sorely lacking, it is a page of terminolgy. It would have helped a lot. Also, a more combat accounts would've been great. But overall, it is THE Panther book.

The ultimate guide to the Panther Tank, is full of detail acounting the progress from drawing board to final version of this extremly well designed battle tank of world war two. Excellent for detail for the modeller keen on fine detailing the Panther Tank in any of its versions. Great read and some fine drawinings of all the Panther Tank models built during the war.
Well worth the money.

Panther Tank the Quest for Combat Supremacy" represents over 20 years of research on the Panther and will remain for some years the definitive single volume study of the development history of the Panther tank.

In additional to this book, Thomas Jentz has recently completed a series of four short but technically compressive books, called "Panzer Tracts," covering all the variants of the Panther tank (Ausf D, A, G, F and Panther II). The "Panzer Tracts" include as-built 1/10 and 1/35th scale drawings and some new technical information not found in "Germany's Panther Tank the Quest for Combat Supremacy." The additional technical details in the "Tracts" were not known in 1995 and so could not be included in Jentz's "Germany's Panther Tank the Quest for Combat Supremacy."