Variants Books

Very infomative book, Great insight for Java Server Guru's

I wanted to find a book that covered both the use of JavaBeans and Enterprise JavaBeans in an easy-to-understand way. I have made a comprehensive search, and came up with this book. The book covered all I wanted it to, and still there are lots more. If you just have read tutorials on the internet (like I have), and want a book for assistance, BUY IT! Recommended!

I was looking for writing database based web applications in JSP and I found the book very useful. It is a step-by-step guide for building web applications. The book covers JavaBeans , Handling exceptions in efficient manner, Custom Tags and Displaying XML files using JSP. The book has got detailed explained examples which helped me in designing my application faster. Overall I was able to design and develop web apps in an efficent manner with the help of this book.

Unfortunately, this book is too much 'how I would re-invent JSP' and not enough about how to use JSP. For example, the JSP and Servlet API Reference is just a dump of the the Sun interface without any comments. I tried to get information about the Request object and was very frustrated, since this is scattered throughout the book (I think, the index was not helpfull). I'm sure this has some good code in it, but I didn't buy it to have a code snippets book. I wanted a book that would teach me JSP and be a good reference as I develop code.

When I first got this book and just thumbed through it, it seemed like it was going to be a good book. However, the more I actually read the chapters, the more I find it utterly lacking in content. The author does not explain things very much if at all. Many places, its just pages of source code listings with little or no comments and no explanations. Then when you get to the end of one source code listing, basically the only commentary is "and here's the next listing..". This annoying lack of explanations also carries through to the appendix, where a "JSP and Servlett API Reference" is included - problem is, its nothing but a commentless, explanationless dump of the member function prototypes. Fortunately, I bought this book used for $10. If I had paid the new price for it I would really be upset and would return it. That's my opinion.

This is the worst Java book that I ever had. Even for technical managers this doesn't do any good.
I sold this book for $3.00 to a used book shop.

It's out of date, but captures the spirit of early java, and is a good distraction from the textbooks.

If you are looking at moving to Java and need answers to your business-related questions, check this book out. You won't be disappointed. From the pitfalls and drawbacks of using Java to developer motivation issues and more, you'll find lots of help here. And, all of which does not say to JAVA-cise NOW, no matter what. Includes several Case Studies, too, if you like that kind of thing.

I picked up a copy of this book this morning, and it has already answered a number of my questions. It's a good tool for showing how your budget, tools and developers can/should impact your decisions about using Java to build applications. Also discusses potential pitfalls and how to avoid them, as well as analysis of time/cost benefits of using Java as opposed to other languages.

When I first started reading this book, I was impressed, until I got to Chapter 3. This is where the book trickles off to a generalized Java advertisement peppered with good management practices which can be applied to any given development language or integrated development environment (IDE) out there, such as C++, Powerbuilder, VB, Delphi, and newer IDEs such as Visual Interdev, C++ builder and JBuilder, none of which are adequately treated in this book.

What bothered me in particular was that the copyright is 1999 but the authors elaborate on Java projects managed in 1995-1997. Thus, for the less technologically savvy companies out there giving Java a first look, this book may be useful, but for the rest of us who have, essentially, tackled or are preparing to tackle similar problems, this book serves as a general guide to good Anderson-ish management practice. From this book one may glean tidbits of useful development ideas, such as how to embark on the installation of 3-tier or n-tier Java systems, but there remains a curious, more likely intentional, omission of project management details that matter.

I expect managers out there to have already addressed similar issues with respect to large-scale development initiatives, specifically, staffing requirements, cross-training of existing personnel, capacity planning (not mentioned), performance metrics (glossed over) and hardware considerations (again glossed over) which seriously determine the success or failure of a Java-based development initiative. None of these are discussed in detail enough to warrant a study of this book.

The strongest case study found in this book is the largest, albeit dated, system which the authors seemed to have managed first-hand, and which you'll find in Chapter 2. Extensive treatment of Java deficiencies and tackling the learning curve are covered, but may be less applicable to the JDK 1.2 (now officially JDK 2) since many developers have since brought

themselves up to speed in Java and have engaged in at least minimal cross-training.

Pros:

1. Chapter 2 (the project on which the authors apparently worked, thus relevant) 2. Chapter 8 (a noble intro to conversion) 3. Chapter 9 (risk management, developing with an evolving standard - bad idea, but mentioned) 3. Chapter 14 (a good summary of Java performance problems encountered) 4. Good general management advice 5. One of the few books to tackle the subject 6. Specifically mentions Powerbuilder/C++ implementation (surprised to see it) 7. Useful project post-mortems 8. Treatment of cross-training.

Cons:

1. The ...but-we-got-it-to-work tone of items 1, 2, 3 above 2. Chapter 3,4,5 (fluffy references to other Java projects lacking sufficient detail) 3. Chapter 6, 7 (Browser compatibility and "Java isn't a fad" pep talk) 4. PR-rich e.g. no pointers, easier than C++, portable, multiplatform, secure, robust 5. Copyright 1999, Case studies: 1995-1997 (using pre JDK 1.1), thus nearly making the book obsolete 6. Utter lack of useful detail or omission such as: a. Analysis of the competition e.g. Microsoft and their implementation of COM/DCOM architecture b. Transaction servers/hardware and scalability of three-tier systems c. Project performance metrics, concurrency testing, bandwidth d. Distributed implementations and related problems e. The reporing deficiencies of Java (after finding a third-party, success!) f. Casting Java's third-party vendor and widgets in such a favorable light g. The emerging CORBA dialects and "factions" which may dilute Java's strength as the preferred distributed language h. The muddling of language vs. and integrated development environment (IDE). VB and PB were meant to remove C++ complexity for developers, but Java, by itself, is still a low-level language NOT a 4GL, thus one might expect at least a brief discussion of vendor selections in this area such as Visual Cafe, Jbuilder, J++, Sun's IDE, but there are few except mention of Unix-based or proprietary, home-grown tools.

This book is fine for learning struts but I was looking for a book on how to combine javascript frameworks like prototype, yui, jquery, with struts.

what is the best coding pratice? to have xmlhttprequests to struts actions that produce html code? xml code? json? or use something like DWR that return your MVC model as javascript objects.

this book doesn't tell you anything about whats the best way to set up your struts controllers / view to use ajax.

wrong title imo

There is some decent info on struts, and after searching for information online, I think this book puts stuff together in an easy-to-read and easy-to-follow way. The big downside to me is that the book talks too much about anti-patterns and other design issues that are somewhat ancillary to struts itself. This information isn't necessarily incorrect or even inappropriate for someone learning struts, but my need is to get up to speed quickly on struts and I would rather not see this stuff interspersed with struts itself. Perhaps if the authors feel strongly about covering anti-patterns, it could be done in a couple of self-contained chapters instead of slowing down the rest of the book.

This book, so far, seems to be a fine book about Struts. I am giving this rating to this book for one reason. For an approximately 500 page book, only about 10 pages deal with AJAX. Should AJAX be in the title? I don't think so, one could probably find that much information on the web in a few minutes.

This book got me started with Struts very quickly. I was able to quickly learn the basics and start writing my first struts app. I haven't finished the book yet, but it is already worth the money I paid.

I would like to write a longer review but I'm pressed for time so I'll keep it short and sweet.

The authors have created a very easy to follow guide (and reference) for beginning Struts development. I've found it very useful for the project I am working on. A couple of shortcomings...

In the section on Struts form validation, they don't go into how one would handle using ActionForm's validate() method to validate a form when the associated HTML FORM uses [for example] html:optionscollection to present a pulldown with choices. Forwarding to the controller, and an action that could then repopulate the beans with the pulldown values would make sense but I'll have to figure this out on my own to see if that's the way to do it.

Also, nobody responded to my email in which I asked questions about the text. I used the email address from the book but didn't get a response.

All in all, a very good book. Absolutely worth the money.

I took a year long course in school with this book and I am only 14 and I still found it easy to use and great to understand.

I teach programming and I have read many Java texts and I find this book to be among the easiest in terms of understanding and also complete in its coverage of the basics of programming. The book explains step-by-step the intricacies of the language and doesn't assume any background knowledge.

It gives plenty of examples of Java applications as opposed to Deitel's book which invariably talks mostly about applets. I also like the titbits of additional knowledge found at the end of each section, which touches on basic concepts in computer science. The treatment on IO and GUI is also excellent.

I also like the way that OOP are being taught by the use of the Turtle Class, specially written by the author. The Turtle Class is used to demonstrate how Classes are being extended by writing new methods and adding to it. A superb method of teaching, I must say.

I would definitely recommend it as a text for a Computer Science degree course.

I read this book after reading Beginning Java 2 by Ivor Horton and Slack's book is a poor comparison to Horton's. I'm sure that a person could probably learn Java by reading this book but why do it the hard way? Try Horton's book, you'll be impressed.

I purchased this book to use as a text for a beginning programming class and found the programming logic to be adequate, but overall I am not impressed with the way the author tries to teach Java in the text. I found his outline to learn and his methods of teaching the basics very poorly laid out. I feel it did not teach the basics of learning programming in any language, much less Java. What it did address, I don't feel it was presented in the proper order...he tried to teach you how to run before you even knew that you had feet. I would not recommend using this book to learn Java. This book was my initial exposure to programming and the only thing I learned for sure is that there has to be a better way to learn Java, or any other programming language, than the author presents in this book.

Programming and Problem Solving with JAVA James M. Slack $62.95 at Amazon.com

This book gives a good overview of Java Programming, then gets more specific in subsequent chapters. The writing style is clear and sticks to the point while giving good explanations of concepts. The code examples are extremely well thought out (giving the impression that the author knows what they are talking about) and even the simple examples are well-designed. I have found no complaint with this book. We are currently choosing textbooks for our CS-1 class and I have not seen a single book that can even compare to this. The organization of the book is well thought out, and the appendices are very useful as optional material. The author's explanations of his code examples and the subsequent explanations of alternate methods and the reasons why a programmer would choose one over another for a particular task are extremely useful. I would recommend this book to anyone learning Java or as a reference for understanding Java concepts.

This book is still being actively marketed by its publishing company, Prentice-Hall. However, you will find that when you go to download the images for this book, which, by the way, are instrumental to its use, that the page to which you were directed to in order to get them is gone. Go then to the publisher; you will find them there; download them and ATTEMPT to extract them. You will be informed that the file is corrupt, and cannot be expanded. It is nothing short of criminal that this book is actually still being sold but is NOT being supported. Unless you have more money you know what to do with, do not buy this book. To sell an unsupported book is show as much disregard and disrespect for the people spending their hard-earned money on it as is possible to show.

This book teaches you ADVANCED JavaScript techniques step by step. What I like about this book is that the techniques he is showing are techniques you are going to need to build websites.

An absolute BUY !

The title is deceiving: advanced is a stretch for the content. If you already have some experience using Javascript, consider another title that doesn't just cover the basics as this book does.

this is probaly one of the most helpful and informative books on the market today for HTML. its nicely laid out and has so much info that i had to stop every paragraph to soak it all in

This is one of the best books I have read to date on developing Java applications with ANT. I'd highly recomend it to anyone interested in saving time writting JAVA applications.

Ant has become a widely used tool and should be part of every developer's toolkit. This book is a nice introduction for the developer who is unfamiliar with Ant and is looking to get started using it. If you are a developer who is experienced with Ant then this book will not be of much interest to you. The book starts with a nice introduction to Ant showing how to create and use a typical build script. The first three chapters cover the basics of Ant and the authors do a nice job of making Ant simple to understand. The next two chapters cover all the built-in and optional tasks that are part of Ant. This section is of limited use to the new Ant user. Since the tasks are listed in alphabetical order and broken out into separate chapters for built-in and optional tasks, you have to know what you are looking for in order to find it. It would have been nice to have a list of all the tasks with a brief description all in one or two pages which would have made it much easier to find a task. There is one brief chapter explaining how to write your own Ant tasks. Troubleshooting Ant scripts is followed by two chapters showing real world examples of using Ant. The book ends with a discussion of tool support. Conclusion: the authors have done a very nice job of explaining Ant for the novice Ant user.

I needed a reference on Ant, and I decided to buy this one despite a negative review. The book is well-organized and well-written in a style that most developers will like.

The first three chapters do a wonderful job of introducing Ants capabilities and what you should use it for. I was already using Ant, but I learned a lot more about how I can make better use of it.

The fourth chapter is a reference of all the tags and how to use them. So far I have found that they are pretty accurate, and as an experienced user I assume that I can figure out anything that turns out to be changed (since this software is always subject to change) or even wrong.

The final chapters discuss advanced material, such as extending Ant with custom tasks, debugging build scripts, and setting up nightly builds. I feel that the book does a good job of explaining the how and why of these topics, too.

Overall, the organization of the book is similar to Oreilly's Unix in a Nutshell, where there are several chapters of reference material and a catalog of commands. I like that kind of book because it cuts to the chase for experienced users. Part of the reason I wanted this book was to structure my Ant projects intelligently, and I got my money's worth for that.

This book is absolutely worthless as an ant reference. EVERY time that I go to read a particular section of the book for fine-grained information it has proven to be a disaster. The book is simply WRONG on many of it's definitions and statements of functionality.

I have never taken the time to actually write a quick review, but fealt that I would be doing a huge disservice to fellow coders if I didn't in this case.

Heed my warning: DO NOT BUY THIS BOOK.

Like most WORX books, the information is extremely useful in learning WebLogic, but the presentation and ordering of the information is confusing and barely thought out. All you need to know about WebLogic is there, but it can be difficult to find, considerably condensed, and hard to apply when approaching the book from beginning to end. The person reading this book should have experience writing shell scripts, and have hands on knowledge of both the UNIX and Windows platforms.

Excellent concise chapters that tell you exactly what you need. One of the best reference books on the subject.

just cannot think about such confusing book... no words to explain the low level quality of it...

After months of my search, I finally found the book written precisely for my requirements. There is abundance of high quality books for J2EE technologies and application server concepts. Although the J2EE and app server concepts knowledge is the first step towards making real time J2EE Enterprise application, the deployment and administration on app server is very vital for the expected success.

I am not sure about others but I personally used to underestimate the importance of this second but crucial step for deployment and administration. And the realization comes only after practical experience.

But what do I do on realizing my mistake? And here comes the role of handbook like this. The book very clearly states the purpose for which it is written. And the comprehensiveness of the information along with the exemplified approach makes it a highly valuable resource for any J2EE developer/architect. Ofcourse, we are talking about WebLogic as the application server here.

If you are really concerned about the performance of your J2EE application to be deployed and administered on BEA WebLogic app server, I'll highly recommend this handbook. I am sure it will play a valuable role in your efforts towards building a high class enterprise J2EE application.

If you are looking for general J2EE or app server concepts, then you should pick up a generic book from the pool of available books.

If you are a developer and needs to pick a good book to put you up to speed, this is not the greatest choice, this book might be good for class room, where you could read theory and write a test for exam.

The authors of Building Spring 2 Enterprise Applications presented from Java developer's perspective how would web software required to persist
data be realized in model-view-controller pattern using framework. For those who were amazed by the popularity of Spring but no chance in
exploring till now, this book might just be the practical guide with coherent topics leaving advance counterparts by further references.


Rather than essential, framework helped solve problem in proved way so purposes of using Spring were illustrated by means of comparison. After
all, software was about integration. With inversion of control pattern, dependent deployment used to be static or via looking up mechanisms like
naming service was demonstrated to be injected at run time by configuration. Aspect oriented programming was then described to overcome the
limitations of either composition or inheritance in flexibly adding functionality to existing classes anywhere. Such cross-cutting concerns were
widely applied to areas like logging, debugging, and resource pooling. Besides, JDBC was commented to be so low level that its use introduced
management issues like exception, resource, and transaction avoidable by abstractions. While keeping batch executions for performance, we were
allowed to be more object-oriented and declaring transaction in interfacing with relational database. By mastering these concepts, one would
proceed to architect web in MVC. Not only the view could be chosen amongst Velocity, Free Marker, XSLT, PDF, Excel, and Jasper Reports other
than conventional JSP, but also the logic could be tested independent of the container.


The latest version of Spring was 2.5 while the book covered 2.0 which was 2 years ago. Its source code could neither be compiled nor executed
due to separately downloadable missing libraries, classes left as exercises, and configuration files. A sample application throughout chapters of the
book that could be run out of the box was important especially for beginners

This book does a fantastic job introducing the reader to the main benefits of using Spring2.

For all the key features, such as Dependency Injection, AOP, simplified Data Access, cross cutting concerns such as Transactioning, and templates for easy integration of other popular open source frameworks, the authors first cover the problem space itself, then the easy to understand Spring solutions, than any gotchas or caveats related to coding your specific Spring based solutions.

Excellent book at just the right level of detail.
Simplifies key points without forcing user to slog through the lengthy reference guide, or some of the longer Spring books available.

After reading the book, the authors correctly recommend checking out the open source code which implements Spring framework to get further confidence and knowledge of how the magic works. I have also been pleased with responsiveness of springframework.org's support forum since reading the book.

OK. Before I start the review I should point out that I am sun Certified Java, Web, Web Services, and Business Objects Certified (EJB). My expectations was to look at the Spring Framework for "Enterprise Applications" hinse the title "Building Spring 2 Enterprise Applications." So my expectation is to see more information of Webshere Intergration, Weblogic Integration, Glassfish Integration, JPA, EJB 3.0 integration, JTA Transactions, etc.

This book does a good job introducing the reader to the main benefits of using Spring2.

All the base features are explained such as Dependency Injection, AOP, simplified Data Access, cross cutting concerns such as Transactioning, and templates for easy integration of other popular open source frameworks.

I don't want to criticize the framework, some are enterprise class, some are not. The Dependency Injection, and AOP are the strengths of the framework. Transactions get a slide in due to the Proxy AOP impacts, but the JDBC, Web MVC are not. JPA is now an enterpise standard, and JSF/AJAX are a standard toolset. Spring MVC is Page based and great view technology, but the world has moved toward Component Web Technologies like Java Server Faces/AJAX. I wished the book headed in this direction more.

Maybe a real look at the impact of Spring AOP Proxy Objects AOP and Java Debugging, Monitoring and Profiling Tools, which I see in my development is a new experience.

Perhaps being Enterprise Spring topics of Clustering, fail over, Large Transactions, Many Transactions would be nice.

Also a little more contrast with AOP Aspect Programing with the JEE 5, Interceptors functionality which is very similar. We have choices when we develope and want to make smart choices. The book points to only a Spring based solution, when EJB 3.0 Session Bean Interceptors may be a better choice.

The book seems to criticize JEE, and offering Spring as a container in itself, which of course is a possibility for small applications, but true enterprise applications have bigger architectural issues.

The Spring documentation at the Springframework website seems a better source, but fewer examples.

Overall, great for new developers looking to focus on Spring. But truly nothing except the AOP Aspect/J engine is truly unique, or enterprise class in my opinion.

If you are unlucky enough to work in an enterprise with an J2EE 1.4 Server (JBoss 4.X, IBM's Webshere, Oracle App Server), this book looks real good, as does Spring and all their services. That was a horrible spec for business development, but the J2EE5 Servers have choices that are in line with Spring, and JEE 6 with WebBeans and pluggable container is not to far away.

EJB @Resource Dependency Injection is suitable and Google's Guice is a good supplement, And J2EE Interceptors and life cycle events is AOP lite.

Book was in new condition and shipped within a week. Would do business with again.

Too complicated to use as a tutorial, and too simple to use as a reference. This book tries to be both and does a poor job of it. Buy this book if you absolutely have to (like I did, for a class at the U of MN); otherwise I'm sure there are other books out there that can do a better job.

P.S. - I found at least one typo in chapter 1. Can you find it? :-)

This is one of the most useless Java books. I am a professor teaching JAVA in a state university. From my teaching experience and the feedbacks from students, I do not think this work is even worth reading. This book intends to introduce data structure through JAVA programming, but it does not achieve either goal. First, it is not a JAVA introductory book. If you are new to Java, the Just JAVA 2 (by van der Linden) is the best choice. If you want to know more about java, Core Java 2 is the good choice and can also be used as reference. If you want to learn data structure, there are many better books available on pure data structure or data structure with C++.

This book is too expensive for students, and it does not deliver the content that is worth 1/10th of the book price. The only reason I use this for my class is that it is required by University and I cannot change that :(


P.S. if you just want to learn more about Java, Think in JAVA is a great book and is free. The author (Bruce Eckel) did a great job in writing a great book and sharing it free on the internet [...].

We have been using this book at CSUCI as a textbook for a CS2 class with a heavy hands-on component. The book is very good in that role, and the lab manual - in spite of numerous errors in the first edition - is a very good companion.

It is neither a tutorial nor a reference; it is a textbook for a university-level course. It teaches students how to embed numerous data structures and algorithms in Abstract Data Types (ADTs), how to use them from clients, and how to utilize the existing equivalents from the Java libraries (mainly Java Collection Framework).

I highly recommend this book along with the lab manual to CS2 instructors.

too much source code and javadoc (one third of the book!). covers many areas but superficially

The author provides excellent examples and the source is available. I like the fact that this is a "simple" book. So many today are thick, bulky paperweights with poor examples or confusing theory. This book is the opposite. I could easily take the lessons and implement them within a few hours.

My only regret is that the author did not spend time telling us why his rather lightweight API was better than an EJB -or- when to use his approach and when to use EJB's (transaction management?, security?, sessions?).

I really benefited from this bookj because it contains very good examples of how to build a db api in java. The only downside is that there's no CD and no link to download the source code.

While this book contains excellent practical, real world examples, it is a little light-on in some aspects. Perhaps some of the API documentation at the rear could be sacrificed for further discussion of design issues. It is more readable than Reese's Database Programming with JDBC and Java, but a little frustrating in that the excellent code examples are not available for download or on CD. Otherwise excellent for those who need to get to work.