5 comments about Designing Enterprise Applications with the J2EE(TM) Platform (2nd Edition) (Java Series).

1. This book (2n Edition) is informative in the context of offering a comprehensive overview of various design concept involved in each tier of the J2EE application. If you are trying to envision what a J2EE platform can do for you, this is a good book to grab. While it provides some insight on design consideration, however, it defers the readers to seek for J2EE vendor implementation rather than offering a solution. Nevertheless, it does point out some advantage/disadvantage or the trade-off associated with choosing different implementation. It also provides some coverage on design patterns, framework (struts), security, transaction and state management using HttpSession or stateful EJB session bean. If you are involved in a J2EE project, this book will serve as a good reference for high-level design concept which puts together all J2EE related knowledge that you might have learned from elsewhere.



2. A must read for seasoned professionals and those new to the subject. Invaluable insights and guidelines are detailed at every tier of architecting a J2EE enterprise application. I found myself frequently relating to the examples and wishing I had read this book to help with earlier projects. This would have saved hours of re-factoring because the authors have already detailed solutions to common design problems.

   If you are looking for code examples, don't look here. Code examples throughout the book are minimal; however this book is not about code examples, the purpose is to provide proven principles for architecting and developing J2EE applications. Instead, one chapter describes the design of the sample Java Pet Store application in regards to the books principles.

   I now have a better understanding of the J2EE platform and how to apply its technologies. I will be referring back to this book often!




3. The book is a high level overview of the application design with the Java 2 Platform, Enterprise Edition. It may be helpful for someone who wants to know how different architectural choices and technologies fit together in an enterprise application.

   It starts with an introduction to different enterprise application scenarios (Stand-Alone, Web-Centric, EJB-Centric, B2B, etc.), and then goes on discussing each of the architectural tiers in detail. In addition, in separate chapters it covers important issues like security, transaction management, internationalization, and localization.

   As a rule, each chapter gives an overview of the involved technologies, considers most important issues, and provides some tips on design and proper usage. Available tools are also discussed. Each chapter is followed by a list of references and resources. Many resources have URLs.

   The last chapter presents an architecture of the sample application. Unfortunately, quite a bit of space in this chapter is wasted reiterating general pros and cons of distributed and local architectures. My impression is that the author of this particular chapter (each chapter in the book is written by a different author or group of authors) assumes that the reader does not have any prior knowledge about the subject and have not read preceding chapters.

   A few code samples in the entire book illustrate some points in the discussion; the code snippets are neither complete nor complex, and obviously are not written for reuse.




4. This book would have been better if it had been written by people who had the ability to be a bit more objective about these technologies. (The authors work for Sun, of course.) There is a large portion of the book devoted to repeated explanations about why the J2EE platform is the best available. There are a number of plugs for client-side Java programs (applets, etc.), which is a marginal technology in practical terms, despite its theoretical advantages. I just wanted more objective information and less marketing hype. That being said, the book does have some useful information. A better and more dispassionate look at the J2EE platform spec is "Java for the Web with Servlets, JSP, and EJB" published by New Riders.



5. i like this book, it is really good for a person who intersted to understand the back world of the technology

2 comments about JavaScript for the Business Developer (Business Developers series).

1. This book is barely more than a pamphlet. I thought a book specializing in "business" techniques would have many more examples. This book a short primer on JavaScript with a few practical examples of business uses.



2. Mike Faust leads you into the dynamic world of JavaScript by starting off slowly and simply with some basic background about JavaScript and Cascading Style Sheets (CSS), including some "secrets" you might not be aware of. And when he feels you have the hang of it, he speeds up the content and moves into JavaScript functions and presents you with stuff like HTML form-checking, including the shipped jsfunctions.js JavaScript function member. And then he finishes with a great example of JavaScript, XML, and AJAX. And at the very end is one of my favorites: a great JavaScript Language Quick Reference.
   Great book and a lot of usefull information in just 160 pages...

5 comments about Data Abstraction and Problem Solving with Java, Walls and Mirrors, Updated Edition.

1. This was one of the best books in Computer Science. It is organized very well, made easy to understand. It is helpful to have have a book like this; I didn't need any help at all from my intructor to get the top grade. There's also many topics that you may want to keep for future reference. It's definately a good choice.



2. This book was used for a 200 level computer science course at my school and it multiplyed my level of frustration by a factor of 2. There is way too much pseudocode in this book. While I see the importance of pseudocode when actually developing your application, I don't think it's quite practical for the purposes of teaching. About half of the book's chapters will create entire methods and classes in pseudocode only to have that same code rewritten in actual Java syntax one or two pages later. In my opinion it just seems a waste of page space and time since you could easily write the proper code and just comment what concept or idea should be going on in real Java syntax. Often times, the authors will start a sentence with phrases such as, "Clearly...", "While this implementation is pretty straightfoward...", and "Obviously..." Then when I start reading the actual paragraph that's supposed to be obvious, confusion would set in, and other choice words come to my head that would describe the clarity of the writing. I have a feeling the only reason why the computer science department at my school chose this book is because someone knew one of the publishing rep's and that's why it's been used for so long. If you want good books on how to actually program and work with data structures on a theoretical level, then I suggest Data Structres & Algorithms in Java by Robert LaFore. His writing is way more concise and I found it solidified the material in about half the time as when I was trying to read this book. In fact, I would say almost any programming books published by Sams' Publishing are really quite good. I picked up Teach Yourself C in 21 days a few years ago, and it was super easy to understand what it is I was typing. I am not the only one who has the belief. One of my friends in the graduate program pretty much said the same thing and said he didn't even read the book when he took the same class as an undergraduate.



3. This is a rather badly written book. I don't know what the reviews mean by saying it was a readble book... I found it confusing and the language used is unnecissarily vague. Like someone had commented. The authors tend to use "obviously" "clearly" etc way too much, especially when the subject is unclear and unobvious. The pseudocode is probably the most annoying part of it. I think thats why lecturers prefer giving their students this book, as they can easily set excercises without having to worry about students looking to the book for answers. I don't recommend this book for people new to the subject. If you already know the subject well, and want to reinforce your understanding, then its a very good book. But if you're new to the topic, just read the first chapter and you'll know this book is not for you...



4. 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.



5. This is not a good beginning Java programming book. It is better for problem solving, but I wish all the concepts covered would have contained Java code.

No comments about Java for RPG and COBOL Programmers on iSeries Student Workbook.

1 comments about Natures Pharmacy: Break the Drug Cycle With Safe Natural Alternative Treatments for 200 Everyday Ailments.

1. This is an excellent resource for everyone. These are simple remedies that actually work. This book is an excellent alternative resource for many common problems. Most Americans are reluctant to try alternative remedies, but the rest of the world has used them with sucess for ages.

4 comments about JDBC Pocket Reference.

1. The O'Reilly JDBC books are the worst of their Java selection: too short and only cover the bare minimum to get simple tasks done.



2. "JDBC Pocket Reference" by Donald Bales is another great reference book from O'Reilly. Like many of O'Reilly's pocket reference books, the book has a small form factor. You can easily carry the book in your briefcase or back pocket. The book is only 145 pages long. The first 45 pages give a terse and concise explanation of how to use the JDBC API and the last 100 pages provides a quick reference to the JDBC 2.0 API. The following paragraphs provide more detail on how the book can be used by a programmer.

   The book is intended for programmers, but could also be applicable to ambitious database administrators (DBA) that want to create Java utilities to monitor and automate some of their DBA tasks. If you are familiar with SQL and database topics the book can provide you with a quick reference on syntax and procedures that you might forget. The book is not a tutorial on SQL, client/server programming, or relational databases. If you are not familiar with these topics or you want to learn more the JDBC Pocket Reference is not for you.

   The first 45 pages of the book are packed with helpful examples of how to use the JDBC API. Most JDBC programmers are familiar with these examples but often need reminders on proper syntax for different database vendors and drivers. Here are a few examples of explanations I found helpful:

   1. JDBC Driver types: There are four classes of JDBC drivers called type 1, 2, 3, and 4 respectively. Type 4 is the only pure 100% Java driver and is the only type described in the book, but it is helpful to understand what driver types are available.

   2. Database URL Syntax: Getting the proper database connection string can be frustrating since every database vendor is different. This task is usually done only once at the start of a project so it is easy to forget the correct syntax. The Pocket Reference describes 9 different database drivers giving the appropriate connection information, online references, archive file name, and supported properties for the driver.

   3. Using JNDI to obtain a data source.

   4. Using DatabaseMetaData API to find information about the database properties and capabilities.

   5. Good examples for executing standard SQL statements and retrieving the results through the ResultSet interface.

   6. Store Procedures: Using the CallableStatement object to execute a stored procedure is one of the most difficult JDBC calls because stored procedures are vendor dependent. The book outlines how to set input and output parameters appropriately to make the call. I found this very helpful since a lot of the documentation from database vendors do not describe this operation very well.

   7. Properly handling "null" values in JDBC. This is important because a database NULL is different than a Java null.

   8. Inserting and updating binary blobs is explained.

   9. Describes and explains how to use User-Defined Data Types (UDTs) to help you map objects to a relational database.

   10. Describes proper escape sequences ensure that your JDBC code is portable across database vendors.

   The only criticism I have for the book is its lack of examples for database connection pooling and transaction support. Committing and rolling back transactions was mentioned briefly, but the book didn't give any examples. Also, the only reference to distributed transaction support was in the JDBC API reference under the XAConnection class. Distributed transaction support is a big part of the Java 2 Enterprise Edition (J2EE) and comes standard with most J2EE containers. Then again this is just a pocket reference so the author couldn't include everything.

   ... I highly recommend it for any programmer that works with database systems. The books provides a quick reminder on proper syntax and procedures without requiring you to carry a backpack full of 500 page books.




3. The first third or so of this book consists of a nice, concise overview of JDBC, with an example for each concept. The rest is basically a printed copy of API documentation you can get online. These really are easier to read it online — the docs for DatabaseMetaData, for example, are about twenty pages long and much easier to deal with in hyperlinked format. The descriptions have been reworded (and shortened) and sometimes are a little easier to understand in the book.
   
   The book is probably enough to get you started using JDBC, especially if you have some experience using database APIs in the past (ODBC or a vendor-proprietary one).
   
   So, my recommendation is: It's half useful, so buy it used for half price. ;-)



4. A friendly and well-written book recommended for anyone ready to learn JDBC. This JDBC Pocket Reference well-written and well-organized introduction to the JDBC. It uses a careful, example-based, easy to understand approach. Contains many examples and other useful information.
   Thank you

5 comments about Developing Enterprise Web Services: An Architect's Guide (HP Professional Series).

1. Over the past year, I have read quite a few books on Web Services, some good, others not so good... but this book really stands out.
   The concepts were covered in sufficient details and in a very informal manner. It gives you a very good idea what you would need to consider when deciding to implement a SOA solution in your organization.
   Highly Recommended!



2. I bought this book with lot of hopes, all I got is a JUNK. This book is nothing but a copy of specs obtained from OACIS and W3C. If you think about on implementing a WORKING Web services architecture using Java or .NET, then all you find is ZERO content. There is no working real-world architecture or implementation example discussed in this book. All the chapters are disconnected.

   Waste of money.




3. This book isn't much better than freely available online documents on the same subjects. The book suffers from the usual problems of a book with too much level content and no practical hands-on information -- Architecture with out practical solution or a prototype model is constructing a building with out foundation. The authors explained individual topics to the extent that it is even confusing. I found this is the last book to be used for quick reference. This book is quite useless to me and I am a googling around for better information.



4. A great guide to designing and implementing web services and the common challenges and pitfalls that can be found along the way.

   Examples, patterns and case study provide excellent illustration while the subject matter is delivered in a consistent and surprisingly easy to read manner.

   I'd recommend this book to anyone that wants to find out the ins and outs of providing web-services, rather than developing a simple web service for their own benefit - most .NET books can deal with that in a couple of pages.

   Buy this book to dig deeper and find out about the issues that you should be considering.

   Enjoy




5. Consider this - Web Services and SOAP is perhaps the only recallable evolution of technology that has witnessed the single largest involvement of standards bodies and industry bellwethers. The result? A puzzling plethora of proffered protocols that continues to confuse both sideliners and early adopters every day.
   
   While managers are finding it increasingly difficult to understand the direction, developers are craving for clarity, consistency and a unified approach for WS adoption. "Give me the tools" they cry every day, while they keep adding to their "To Read" list a handful of new acronyms every week. The big question is, when can we build Rome, if at all?
   
   With a gentle and brief (thank god!) introduction to underlying concepts such as SOAP, XML and UDDI, authors start talking about broader concerns - conversation, transaction, security, workflow, QoS and everything in between. While accentuating nuances of evolving standards and guessing the future trends, authors offer strategies, patterns, and tips on pitfalls to avoid. They skirt around the political interoperability issues around J2EE and .NET and focus purely on the standards. Architect's Note included at the end of every chapter makes title justified.
   
   An implementation of WS-based ordering system presented as a case study concludes the book by bringing it all together through excellent step-by-step approach.
   
   Although almost a year old, this book can be a survival guide for people in the trenches and the ROI-Savvy managers as well. It helps you tell the wheat from the chaff.
   
   Ajith Kallambella
   (...)

5 comments about Java Gently: Programming Principles Explained (3rd Edition) (International Computer Science Series).

1. I have recently being appointed to teach Java and Object oriented programming to a class in my Institute. Upon poor advice from one of my colleagues, i recommended this book to my class. However i have found it to be a totally frustrating experience using this book as a class text. It is structured very poorly and the author seems to jump all over the place. she introduces complex examples early on the book without any proper explanation of the underlying concepts. She leaves the proper discussion of objects too late in the book and the object and class design methodologies are unclear and poorly explained. an awful book i have now switched to another book by Morelli called Java Java Java which is structured much more cleverly.



2. If you take a look at the reviews so far, you will see one common denominator: those who have little programming experience are greatly frustrated with this book. But programmers who need to learn a new language, seem to think that it is quite OK. I would have to place myself in the first category. I read the first couple of chapters as part of a university course, but soon abandoned the book. The learning curve is way too steep for beginners. The progression of themes bears witness of limited pedagogical insight. But I still believe that folks with plenty of programming experience may enjoy this book. I give it two stars, though, primarily because of the inappropriate title. This is NOT a 'gentle' introduction to Java. Maybe the third edition has improved in this respect (published December 2000)?



3. This book was used in one of my freshman classes as an introduction to Java programming. The book was fairly easy to understand and did a decent job of explaining things.

   I think my biggest complaint is the use of the javagently text class. The way the book is written made the reader/user too dependent on it, and at a loss for what to do if/when the class wasn't present.

   While using JavaGently I found myself frequenting the API's at java.sun.com. I have since used it for reference, but the lack of detail on material covered by the javagently text class has had a negative impact on this book.




4. ...>I really like what the author and publishers have achieved with the third edition, especially in augmenting the material with modern programming aids to be found in similar books. The book helps students with far more than just Java programming. It has syntax and semantic forms, UML diagrams, several indices into Java APIs, classes, methods, example programs, a ten page general index (double columned), over 50 full examples and case studies, and a more sound object-oriented introduction than in many comparable books. It also has the most active and appreciated website we have ever seen.



5. This book was required reading for my graduate-level foundation Java class. Having no previous experience in object-oriented programming, I was reassured by the title that Java Gently would ease me into the programming world. While the road wasn't as "gentle" as I had hoped, the book does provide readers with practical examples for implementing Java 2 and explains how concepts used in introductory programs can be applied to more complex ones. Although Java Gently is an introductory book, it would be more useful for someone who has programming experience in another language. Perhaps then the learning curve would be a bit more "gentle."

5 comments about Multithreaded Programming with Java Technology (Sun Microsystems Press Java Series).

1. I purchased this book hoping to develop a deeper understanding of multi-threading, the proverbial under-the-hood down and roll-your-sleeves-up nitty gritty. Frankly this book left me quite disappointed. It's poorly organized and poorly editted. While I am sure it has some valuable content, the low readability level and very poor organization (it really gives the impression that it was sort of patched together) prevented me from ever getting into it. In my humble opinion, the book

   "Taming Java Threads" by Allen Holub is a fare better choice if you want to master Java threads.




2. Any book on multithreading this well written and illustrated and going from test-and-set to volatile- well mon, you gots to
   understand what you getting- the very best. Mucho kudos to the
   writers and their collaborators- power players if there ever were power players. I give it a ten.



3. That this book was a member of the Sun Java series was the primary reason make me take a look at this book.

   I have been highly disappointed. This body of work for this book is primarly a rushed port of the authors other title - named, funnily enough Multithreaded Programming with PThreads.

   The Java topics seem to be bolted on as an after-thought - and makes the book read and present very badly. For example a good amount of examples are presented in C not Java, demonstrating POSIX threading!

   The author is also in the bad habit of presenting material out-of-order, so that the reader has to wait sometimes 50 pages for clarification. This does not breed suspense, merely frustation at the disorder.

   The low-level OS technical coverage is quite adequate - with a good explanation of LWP and POSIX threading (if only this is what I bought the book for!).

   The author is clearly a C type who has come to Java and tries to basically recreate the semantics of C POSIX threading in Java... while at the same time constantly drifting back to a topic that he is clearly more comfortable with - PThreads.

   This is hardly an embracing approach for a book with the word Java in the title - an obvious cash-in on the behalf of the publisher, Prentice Hall.

   Do not buy this book.




4. This was the first threading book I read--which turned out to be a huge mistake. The material is very dense and only a small part of it is Java. Most of the book deals with operating system threading concepts. There is a lot of space dedicated to contrasting MS vs. Unix threading models. Also, comparisons between Java and c threading.

   If you are looking for a solid beginner book on Java threading (or threading in general), I highly recommend Concurrency: State Models & Java Programs. This is the second threading book I read and I highly recommend it if your goal is to _understand_ thread theory and problems. It approaches the subject in a very rigorous manner and models all concepts using finite state machines and then showing the Java source code.

   If you are already comfortable with basic threading concepts and some systems programming then I would recommend the Multithreaded Programming with Java Technology.

   I deducted a star because of a few annoying typos and for a few convoluted sections.




5. This is the only book I have seen that thoroughly covers how threads are implemented in a modern OS and how this affects how code runs. It's certainly the most useful book on threading I have. It's a good book to buy after you've written some concurrent code and have some problems.
   
   It's not a Java book - it's a platform focused
   multithreading book. It could do with some restructuring to make it more accessible.

5 comments about programming.java: An Introduction to Programming Using Java, Second Edition: An Introduction to Programming Using Java, 2nd.

1. I just finished a class which was taught with this book, and I know more about Java than I ever wanted to. I think that the book was extremely well written, and was presented in an extremely easy to learn format. If you are interested in programming using Java, I would advise reading this book.



2. This book works much better when used in conjunction with a lab manual. I have used this book successfully in teaching a beginnning Java course to non-computer science students.

   The approach is non-traditional in the sense that the students start programming a graphical user interface from the very beginning. This approach engages the students and helps them learn more quickly because they can "see" the effects of the changes they make to their code.

   The authors take a top-down approach and avoid overwhelming students with too many details.




3. This book doesn't have the greatest reviews and I think it's because it has the wrong audience. I'm an old time Cobol programmer who's read some books on java but really had a hard time sitting down and getting a program organized and working. This book solved my problems. Between the hands on lablets and the numerous problems in the quiz section at the end of each chapter I finally began to be able to use what I knew. Also there's a fabulous chapter in which the authors actually build an application from scratch, explaining their thinking and ackowledging the time it takes to get it up and running. This book is for people who want to be able to use java when they're done but I think it's too hard for total novices. It would have been nice however if there were solutions to some of the problems.



4. Not a good choice for beginning programmers. The authors try to make it simple by using "goo-goo ga-ga" language sometimes, but that doesn't help too much.

   One good thing is that the book is small, yet dense and the authors write decently. It's just that the content is too dense for first-time programmers. I suspect that if you have experience programming, you'll like this book okay.




5. One should always be wary of a Java book that places a chapter entitled "Java Language Basics" on page 163. Like too many authors, Decker & Hirshfield somehow feel the reader will bebefit from delaying such a topic until chapter 5. The first 4 chapters are filled with examples begging for basic explainations. The very first page of chapter 2 has code demonstration applets and as such contains inheritance. This is immediately followd by a discussion of methods, overriding and graphical programming.

   If you want to jump into Java head first without a clue to the basics, this is the book for you. When I wonder why software has such quality and reliablity problems, it's probably because the programmer learned a language from a book like this one.