5 comments about Data Abstraction and Problem Solving with Java (2nd Edition).

1. There are several problems with this book, from a student's standpoint. I concur with the reviewer above who stated that the book has too much pseudocode. It is very difficult to know exactly what to do when it comes to the actual programming, since there are so few concrete examples written in Java.
   
   Additionally, the writing is tedius and boring - the authors repeat the same point in many ways through each chapter, to the point where the same sentence is there tens of times, just worded slightly differently. It's confusing and frustrating for students trying to do the assigned reading, which takes hours due to the writing style and really doesn't convey much actual information.
   
   Finally, there are very few self-test questions with answers. How can we learn if we can't correct our mistakes? The exercises should have answers or solutions so we can see how we are doing. This is especially true for students who are teaching themselves. If they are taking a class and the Instructor wants to set problems or assignments, he or she should make up his own.



2. I've had to read parts of other data structures books, and they've all been terrible. With this book, for the first time, I felt that the author was successful in clearly demonstrating the topics at hand. The examples and text are very clear and easy to understand. My only issue is that it's shallow in some areas. For example, the Balanced Trees section covers 2-3 trees and 2-3-4 trees, but only glosses over AVL and Red-Black trees. These topics are covered in the class I'm taking right now, so I was somewhat dismayed that I had to turn to online resources for these. That said, I'm very glad the professor chose this book over any other!



3. This is a horrible book
   
   I dont have much more to add than what the previous two reviewers did.
   Too much pseudo code -- and even the pseudo code is not all in one place.
   Its all over the pages in the chapter making it very hard to understand what is going on with each class. Very dry, convoluted style of writing - tedious, repetitive. The organization of the chapters is poor at best.
   
   All in all, really poorly written book. Its a shame this text was chosen at my school because I believe there are several great data structures books out there.



4. The book was in pretty decent shape other than a few pages in the index that were unbinding from the rest of the book. The writing in the book actually helps me understand things better when I can actually read it.



5. I didn't appreciate this book until after I was finished with my class and had moved on to upper level programing classes at my University. I had an excellent teacher for the class and just never read the book. Now, in my new class, which we are using c++, we are working with more complicated and in depth use of the same concepts and algorithms that are in this book. I was rusty on working with it so I searched a gazillion books and all over the web and was still confused about what I needed to do my project before I remembered that I had it before in java and grabbed this book off my shelf. I was amazed at how amazingly precise and well defined each algorithm and code was after search for a solution all day. It teaches you HOW to program these concepts, not just give you the code. Shows you how to think about the problems. Very very good book.
   
   Those who think this book has too much psuedocode are most likely to be fairly new to programming and don't understand the syntax and how to piece things together as well as they might need; plus I don't recall ever enjoying learning any concepts with Java. The psuedocode in this book pretty much tells you exactly how to program the topic, and even more importantly, shows you exactly what is happening. Psuedocode can be difficult to visualize when you are new to programming, this is true, but with more a little experience, I find this book invaluable. The book is about programming concepts explained using Java, it is not a java book.

No comments about The Definitive Guide to Grails, Second Edition (The Definitive Guide).

No comments about Building Applications with IBM Rational Application Developer and JavaBeans.

No comments about Java: Learning to Program with Robots.

No comments about Java Foundations: Introduction to Program Design and Data Structures.

5 comments about Java 2: The Complete Reference, Fifth Edition.

1. I got this book as a prize at a Java User Group meeting. Overall, it's a good reference book to keep. One thing I wish it had covered is the JSPs, since it does cover the Servlets.



2. Not the right place to start off learning the language but definetely a must have for serious Java programmers.
   
   The only reason I give it a four is because of its bad paper quality and non-colored presentation.



3. The best way to learn a new programming language is to churn a lot of code and get familiar with the language semantics and richness. Mr. Schildt follows the same teaching paradigm and initiates a novice in the world of OOPs programming using Java.
   
   The book is of course not suitable for a person who has some background in Java. The book definitely targets the uninitiated in the OOPs concept and builds up considerably upon the concepts gradually. Some pros about the book:
   * The book covers the language basics very neatly.
   * Numerous examples make the comprehension better.
   * Chapter on 'Multithreading' and 'Exceptions' are well written and neatly illustrated with working examples.
   * Treatment of Java Event Delegation Model is one of the best among all the available texts.
   
   Some cons for the same:
   * Less focus on Swing and more on AWT.
   * Very little coverage of important topics like 'RMI' and 'Serialisation'.
   * Poor treatment of important topics like 'Inner Classes'.
   
   All in all from a novices' perspective, the book presents a good starting point. But from an advanced programmers' point of view - the book has still miles to go.



4. This is one of the better books on J2SE 1.4. In fact, I had first started reading Core Java 2 book but it was very confusing. Mr.Schildt has really arranged the topics well.
   The only drawback is that there are no excercises for the initial chapters on Java programming. A few such problems would go a long way in helping readers get really comfortable with the different aspects of Java and OOPs



5. If you are a JAVA beginner you MUST have this book. It's an excellent reference book and even today (after so many years in the Java industry I still consult with this book)
   
   I have read numerable books in the area and this one really rocks (again, beginners only).
   It takes the reader step by step (and with gloves made of silk) and explains the concept of OOP with great and useful examples.
   
   I liked the chapter on the multithreading since it was illustrated with excellent examples.
   
   --dgz
   JHexagon

5 comments about Developing Java Web Services: Architecting and Developing Secure Web Services Using Java.

1. The other reviews saying "Repetitve and shallow content" are all 100% true.
   It repeats itself over and over again. Is not only boring but it's also extremely hard to follow.
   I'm an experienced java/jsp developer trying to get into web services, and this book only gave me frustration and disapointment.
   When I started reading this book I thought that WS technologies were very complex and hard to understand. Then I realized the only thing hard to understand is this book.
   
   I'm taking this book back to the store.



2. This book is okay as a starting-point in learning Java web services. It attempts to cover a wide range of topics but fails to expand on some subtleties crucial to the understanding of these topics. One obvious example of this is the distinction between document-literal binding style and document-based web services. The book touchs on both concepts but stops right there without any explanations on how these concepts are related or not related, what are the implications of choosing a binding-style from the perspective of a web services developer or an admin, whether the choice of a binding-style determines the programming model, the API set, etc.
   The authors tend to be loose from time to time with their use of terminologies and concepts. Admittedly, part of this is due to the state of the art of web services itself. That being said, some of the comments in the book are quite confusing and misleading. One example is found on page 454 of the book "JAX-RPC is also a best-fit solution over JAXM ... where high performance ... are defined as the key requirements." This is simply contrary to the common wisdom that loosely-coupled messaging applications usually out-perform their tightly-coupled RPC style counterparts when "performance" is defined as the system throughput. RPC style apps may offer a more predictable response time at the cost of inferior throughput. However, this point was never expanded on with any further information. Similar comments can be found throughout the book.
   The writing style of the book is quite verbose and repetitive. Quite often the same point can be found twice or more in one paragraph.
   With its shortcomings, the book is still a decent introduction to web services. However, I would recommend supplementing with other online sources. There are many wonderful technical articals on SUN's blueprint site, IBM and Oracle's developer communities.



3. Better read the specifications than this book. It is merely a compilation. No attempt has been made to illustrate a single concept. Some times, I wonder whether the authors understood something at all or just wrote the book out of passion to write a book, since there is NO value addition to your understanding. Not worth even a buck.
   
   (...)



4. Don't be fooled from the good reviews this book has gotten. this book is the WRONG choice for anyone willing to LEARN about web services in Java. It is merely a boring, dry, wordy, repetive, confusing (and confused) compilation of web-services related topics.
   The authours might be good programmers maybe, but as they are clearly very poor technical authors.. their writing style is boring, excessively wordy and abstruse.
   Not clear and concise enough to be useful as a reference and absolutely terrible as a tutorial.
   The preface tells how the idea of writing this book came form one of the authors who, sitting in a pub with the others was the the only one who wasn't drinking. I have some advice for this guy: start drinking.



5. I bought this, hoping to be able to use it on a web services project I'm doing.
   
   I find it's completely out of date. Both Sun's JWSDP and Apache Axis have moved on since this was written, and you'll get better information from their websites than you'll get from this book.
   
   Don't bother with it.

5 comments about Program Development in Java: Abstraction, Specification, and Object-Oriented Design.

1. I have some problems understanding inheritance and other OO terms. This book teach not only the meaning of those term but also teach the advantages and how to use them. After reading this book, i know why those term is very important (inheritance, abstraction, etc) and can use it in my programming life.

   If you'd like to become java expert, buy this book.




2. This is one of the best Computer Science books I have read. It is one of those books where every word is worth reading. And it is so concise. After reading this book, I understood clearly what exceptions were, how good design is done, etc. Also, the fundamental concepts like abstraction, decomposition, etc are so brilliantly described that you will never be hazy about them again. The most favourite topic of mine is the procedural SPECIFICATION part using the REQUIRES, MODIFIES, EFFECTS clauses. It really helped me see how procedures are specified.

   Finally, a word of caution. This is not a book for beginners or for those who are looking for learning Java syntax for writing toy programs. If you have been programming in a OO language (any OO language)for some time and have been using terms like abstraction, design etc without FULLY understanding them, or if you want to learn how to methodically approach the programming process, this book is indispensable!

   Thanks you Prof. Liskov, I learnt so much from your book.




3. Barbara Liskov brings name recogntion the text. Respect comes for reasons, though, and this book shows many good reasons for respecting this educator and her co-author.

   This would be a good book for a second or third course in comptuer science. Even so, seasoned pros should take this book seriously. The reader is assumed to be familiar with basic programming and data structures. The reader is also assumed to be familiar with Java - "development in Java" means that Java is the vehicle, not the topic being taught.

   Techniques in this book are a level above the most concrete. It's premise is that any piece of code must be viewed in many different ways; right and wrong answers are the least of it. The book starts with a simple but rigorous set of commenting conventions - it makes one wish for a truly rigorous programming language. For each method, one specifies its prerequisites or assumptions, the set of objects with state chaged by the method, and the specifics of the change being made. The authors focus clearly on ambiguous specification at this level; explicitly undefined behavior has a valid role in many rigorous designs. This leads naturally to discussion of parameter checking, error handling, and proper use of thrown exceptions.

   The authors develop a few unusual but critical ideas, including mutability - the possibility that an objects data content can change after creation. In well-disciplined programs, this property has far-reaching implications. Liskov and Guttag involve mutability in equality testing, object identity vs. data equality, and valid naming or indexing.

   Encapsulation and data hiding have long been design staples, but the authors' examination keeps the idea fresh. They discuss, from the standpoint of provable correctness, how data exposure puts programs at risk. They also make clear how, viewed with an eye to maintainability, the risks of even read-only exposure of an object's data content. They stop short of discussing true formal verification or industrial practice, though, a decision I think appropriate to the book's level. Readers with deeper knowledge can still appreciate the discussion at its implicitly deeper levels.

   By the time the authors address high-level system specification, it seems almost obvious. Without high-level specification, there would be no way to fill in the more detailed specifications that now come naturally to the reader. The authors also address that tricky moment between specification and implementation: the intuitive process of design.

   Only the end of the book disappointed me, a half-hearted presentation of design patterns. It seems almost perfuctory, presenting DPs just because it's the done thing, not because the authors add their usual depth to the topic.

   I really wish I had more upper-level students and professional colleagues who had been trained according to these authors' program. Their software designs, as students and as professionals, would be stronger and safer if they had.




4. Percect book for a computer science student who must learn the fundemantal concepts of Object Oriented Design (OOD) in order to success and able to design and develop production quality software that are reliable, easy to mantain and modifiable.. It outlines the important steps for each chapter but the order of the chapters should be rearranged.



5. Just don't bother with it. Read Stroustrup all the way through and you'll be better off. If you really MUST do Java, read the online Java docs from Sun, starting with the tutorials. They discuss the same things Liskov does but without the idea of specification.
   
   Use a tool like JavaDoc or Deoxygen consistantly through your program and not only have you gained everything else Liskov discusses, you haven't spent time wading through her, often contradictory, arguments on the subject.
   
   Thats not quite fair, if you really do believe that an Object is a model of something in the real world, and not a clever piece of syntax for expressing your logic and enhancing readibility, than you will very likey LOVE this book.

5 comments about J2EE 1.4: The Big Picture.

1. Sun does a lot of things right with their Java products, but one thing they do wrong is in how they name their versions of Java. J2EE 1.4 is an environment that allows you to do very many things. Short for Java 1.(2) Enterprise Edition, it is a set of tools used to write large, distributed applications, although from the name, it is hard to discern that fact. Since distributed applications have many parts, simply understanding how those parts can be put together is a major undertaking. This book is designed to give the reader a broad overview of J2EE, the various components and what each is used for.
   There is very little code in the book. What does appear is skeletal and easy to understand. The premise is that Antoine is starting an online gourmet pizza business after being successful in selling locally. His online component is wildly successful and before long he realizes that he must scale his online business dramatically upward. The current structure of his website does not allow for rapid and efficient expansion, so his online business is in danger of collapsing under the weight of his success.
   The book is designed to be an overview of the different ways the components of J2EE can be used to create an application server. It is not in any way meant to be an in-depth technical manual, the goal is to explain the components of J2EE in a way that non-technical people can understand. That goal is successfully met, there is never a time where the authors rise to a technical level beyond that of someone who understands how software operates.
   If your goal is to learn the overall use of J2EE in creating large distributed systems, then this is the book for you. However, if you possess some technical knowledge, then it will probably not be interesting or challenging.



2. Good non-techie intro. I'm now ready for a technical introduction to J2EE.
   
   It helps to have an introduction to enterprise architecture (i.e. Martin Fowler Enterprise Patterns) before moving on to this book.



3. The book is full of "cutesiness" which makes the book much longer than it need be.
   Conversely - what the book lacks is a good solid explanation, with detailed examples, of basic elements of J2EE like the Home_interface Component/Local/Remote interface - and how they actually tie-in with the Clients and RDBMS. It's not that these things aren't mentioned. They are. For example chapter12, p.148 :
   "The Home interface is kind of like a hostess at a restaurant. In fancier restaurants you don't find your own table and order your food directly from the chef; you ask the hostess to find you a seat and the hostess assigns you a waiter who talks to the chef.You ask the waiter for your food".
   Followed by 8 pages containing some codes and and explanations - that don't really explain how you connect everything together.
   
   So in conclusion - if what you want is to know the buzz-words, the book is to long.
   If what you need is technical detail beyond a long explanation why J2EE is like a fancy restaurant,
   and that: "The database just sits around holding data. Sometimes it hums snatches from Broadway musicals softly to itself but mostly it doesn't do much. And that doesn't do anyone any good. like a library without a librarian" (p.159)
   - than this book is disappointing



4. This is quite possibly the worst book ever written. I've actually not finished reading it, and probably never will; I've tried three times, but end up putting it down after 20 pages every time I pick it up. I recently brought it on a plane trip with me so I had several hours with it, but it's just not possible to get very far. You truly have to suspend disbelief while reading this piece of garbage: "Are they really writing this? Doesn't Prentice Hall use editors? Or at least some sort of grammar check?"
   
   Every aspect of technology has been personified or anthropomorphized. The Dolphin is constantly talking to the Statue of Atlas who in turn talks to the Golden Retriever, but they only explain once that the Golden Retrieve equals the database server, so after five pages when you've forgotten that fact none of it makes any sense any more. You literally need Cliffs Notes to decode what the authors are talking about. All the "characters" talk to each other, with dialogue and everything. And the dialogue is AWFUL. If you can't write poetry or prose, then why bother writing a little play between the web serving Bee and the web containing Horse? Reading terrible writing is surprisingly distracting. Midway through trying to comprehend a concept the authors cut away to an example where the Scarecrow says something unbelievably stupid to the Cowardly Lion and all you can think is "how did this make it into the final draft?" Congratulations: you just wasted the last five minutes of your life, and you have nothing at all to show for it. (Aside: they actually use the characters from the Wizard of Oz to represent some concept, but the analogy is so flawed that they literally take several sentences explaining how the Tin Man represents Resource Management. You will never get those three minutes back, and you will be dumber for having read it. Shouldn't an example metaphor whose purpose is to illustrate a point be somewhat obvious?)
   
   This book is 90% filler and 100% poorly written. I just cannot figure out who the target audience is. It is not for anyone remotely technical. Anyone who is functional and has risen to a managerial role is probably too busy to deal with the ridiculousness of the book. But if you do have the time to wade through this disaster and are simple enough to appreciate this mess, then how could you possibly need to know about J2EE? Who are you people that gave this book five stars?!? What companies pay your salaries?!?



5. I continue to recommend this book to people who are unfamiliar with the Java Enterprise platform. This book is well-written and easy to digest--the perfect introductory book!

5 comments about Teach Y ourself Java.

1. A few months ago I decided to teach myself Java. I purchased a few books, and I am happy with my purchase of this book, "Teach Yourself Java".

   After reading more heavy, definition type programmer to programmer java books, this book has been very helpful to return to for a less 'wham to the head' over-view and tie-together.

   On the other hand, this book certainly won't cover it all. To learn java, you are going to need to simultaneusly read multiple books.

   For someone looking to learn java, with little java experience, this book is not a bad purchase.




2. First of all, this book is very well written. The examples are short and very concise. I personally learn by typing the examples and I like them to be short and to the point! This book is also very good from the aspect of not holding you back. It covers very basic control structures through sockets! I also like the fact that there are 394 examples you can download from the web easily. This is definately more ecological. Now some bad ... 1) The 394 examples that can be downloaded are not categorized! BUMMER. You must sift through all of them to figure out which ones apply to your current chapter, although some titles do make this easier. 2) If you are like me and constantly use the index to search for stuff ... you probably won't like this one. 3) Out of 707 pages, 170 of them are dedicated to answering end of chapter questions. That is 24% of the book! I don't consider this a plus. I would have preferred to download answers instead of downloading examples! SUMMERY: This book teaches programming in JAVA without getting bogged down in all the available pre-written web stuff ... although it does cover some web applications. It doesn't hold you back and doesn't assume that you already know a programming language. If you do know C++, you can navigate this book rather quickly and be up and running fast! I'm very happy with this book overall.



3. Mister O'Neil has chosen very effective strategy. Every chapter composed of a short theoretical introduction and working examples demonstrating the theory in practice. Definitely my level of Java programming has been considerably improved after reading this book. I would recommend this book for those readers who want to step up from beginning to intermediate level of Java programming.



4. I was having a hard time understanding Java Exceptions/throw/throws. I read the chapter on Exceptions in this book. The chapter was full of short code examples that makes it easy to understand. I also loved the pre/post quiz and exercises. The writing appears to be very good.
   
   The best Java book for beginners has to be Kathy Sierra's Head First Java. Although, Some think that that should be used as a supplement book. The second best beginner's book is Herb Schildt's beginning java. I would place this book 3rd. I would not purchase Ivor Horton's book or the Java in 24hours. However, Murach's Java 2 is an excellent combination of reference & learning material.



5. This can't be the best book to choose for teaching yourself Java. It's intended to be a learning guide, but it's presented more like a reference. Recognize that part of my frustration is due to my unfamiliarity with object oriented languages. I'm just learning about OOL's, following a long dormant programming history from the 80's, the pre-OOL era. OO programing is significantly different than what I used to do. I'm fascinated with it, but it's going to take some time.
   
   The other major part of my frustration is that much of the explanation text in this book just ain't plain english. It sounds more theoretical. If you're already familiar with OOL's, it probably wouldn't be such a burden. But it's like jumping right into the deep end for me.
   
   I agree with the prior comment that pointed out that the fun stuff (GUI) is at the end. I know you gotta crawl before you can walk, but I think it would keep people's interest better to do something practical and fun along the way.