Customer Reviews

Struts Kick Start

5 star:		(13)
4 star:		(4)
3 star:		(2)
2 star:		(8)
1 star:		(6)

 

 

I bought this book to learn Struts: not to learn ABOUT struts. The authors clearly have a firm grasp on the topic, but unfortunately, this book is more of a 481 page example of them showing the reader what they know than it is instructing the reader in how to learn what they know. I have had this book for several weeks, and have read through many of the chapters before finally coming to the conclusion that this book is really quite worthless.

For example, one of the main selling points for me was that Torque was covered - and even included on the CD. But when I got to Chapter 6, where Torque is discussed (all three paragraphs of it), it's such a "high-level" overview, that I'm no better off than when I started. Here's a quote from the book: "After you've set up the XML file [the code preceeds this quote] and a property file [no code, no explination - what property file?] that tells Torque which database and connection pooling scheme to use, you use Ant [how?] to have Torque automatically use both the SQL files [which SQL files?] to create the database and the Java files to map classes to tables." p102. Do you see how vague and unhelpful this is?

I'm totally surprised at the good reviews this book has been given. I purchased it based on those reviews and now ... well. The book is wordy and lacks some basic get you started information you would expect from a book with a title containing the words "kick start." The authors got it part right - it should read, "Start kicking." The authors seem to be upholding a long-standing java tradition: make it complex and avoid fundamental procedural steps. For what its worth, when I'm learning something new - upfront - I need to take baby steps - confidence builds and learning is accelerated on and up. Chapter 3 dives directly into a "hello world" application without one single word in the entire book devoted to "Here is what you need to follow along boys and girls..." Not one line of "before we begin, do this and do that." So if your looking for a good text on "guessing with struts" look no more. I give it two stars because there must be some value somewhere in these pages.

I disagree with the other reviewers that are complaining about the example applications or lack of advanced features. I think books that have examples that are too complex or advanced get away from helping you learn the basics because the examples are too complicated to read quikcly when you are in a hurry. With Struts Kick Start, I can go right to the place in the book that explains the specific thing I'm looking for quickly.

I've looked at all the available books on Struts and I own three of them. Struts Kick Start is the one I have found the most useful in helping me learn because it provides the best coverage of the basics of Struts and has many more coding samples for the struts tags than any of the others. The others refer you to the site for struts tags or just seem to replicate what is already on-line. Struts Kick Start explains each one in detail and gives sample code that you can cut and paste to use on your own. It also provides some great examples of unit testing and build scripts that I've been able to put to use without too much pain.

This is a great, useful book.

Struts Kick Start

I started learning how to use the Struts framework in late in 2001, after I became fed-up with hacking web applications together with the digital equivalent of "Duct-tape Engineering". At that time there were no books available for the budding Struts developer, "Read The Fine Manual" was not an option ... you read the website, you read the code or you asked questions on the mailing list. This situation finally changed this fall with the release of a flurry of titles dedicated to Struts. I present here my thoughts on one of the latest: "Struts Kick Start".

What is Struts?

Struts is a framework for developing web applications. It is a distilation of the current set of known best practices into a working code set that can be extended to meet almost any web application requirements. It part of the Jakarta Project at the Apache Software Foundation.

What do I know about Struts?

I have been developing web applications, using Java, for four years and using struts for over a year, and am a regular participant on the Struts mailing list. I was also a technical reviewer for one of the other Struts Books released this fall and was recently invited to speak at the University of Wisconsin, Eau Claire on the use of Struts.

What's good about this book?

There are many excellent things that I could point to. I particularly like the obvious depth of research that accompanies this book. There is a very interesting history of the development of the MVC design pattern and they even name the inventor. Do you know who invented MVC? If you want to know, buy the book!

The chapters cover everything that you will need to know, in the order you are most likely to need to know it. There's even a chapter explaining the "struts-config.xml" file's DTD! (You may want to skip that on the first few readings :-)

There is good coverage of the Struts taglibs. I see a lot of questions about these on the mailing lists, so this information is very timely and it looks very well explained.

I like the coverage of other open source tools that work well with Struts. This is an important point because Struts does not do everything for you (by design), so there will be areas that will benefit from other tools. I'm looking forward to trying out some of their recommendations and easing my own Struts development lifecycles.

What's not so good?

Just one niggle, and it's more of a programming style issue, but in their example code they have references to their business objects. They explain that it is important to separate out business logic from action logic, which it is, but then proceed to use their business object within the action.

Now, I realise that example code is not the same thing as robust, production-ready code, but when people are first learning a language or framework, they tend to copy exactly what they see in the book they are learning from. Even though example code should be light on error checking (for reasons of readabilty), it should be heavy on correctness and good style.

Should you rush out and buy it?

If you are about to use Struts on a project, are new to Struts and need dead tree documentation for those RTFM moments or are evaluating Struts for future projects, then you absolutely need this book.

If you are an intermediate Struts user, then this book would still be very useful to you and I can certainly recommend it.

If you are an experienced Struts user, then you've almost certainly exchanged emails with James or Kevin, on the Struts mailing list, so you can make your own mind up!

I would highly recommend this book for anyone looking to get a practical, working knowledge of Struts in a short amount of time. It also gives clear advise and recommendations on design issues and technology choices not only for using Struts and JSPs, but also on integrating with back-end databases, Enterprise Java Beans systems, and Web Services systems.

The book develops a practical Struts application, including database integration, that walks through all the real world development stages from design to deployment, highlighting best practices and key issues at each step. While doing all this, the book is brief and to the point. This keeps it fast moving and interesting while providing a useful working knowledge of Struts. The authors provide clear recommendations on many
issues. Design or technology options that exist at various points are highlighted and the trade-offs identified, but the authors do not get bogged down in technical digressions at these points, but rather state their recommendation with their reasons and then refers to other resources for the reader who wishes to delve into the issues further.

In addition to the basic Struts application, the conceptual background is clearly laid out and chapters on the details for all the Struts tags are provided. Another highlight of the book are the chapters on advanced topics of integrating Struts with Enterprise Java Beans and with Web Services. In a brief amount of space, these chapters walk through all the steps to set up and run an example application that can serve as a model for real world development. Again, all the key design and technology decisions are highlighted and explained.

A big plus with this book is that all the example applications and the technology products needed to set them up and run them are included on the CD that comes with the book, so you can be sure you are working with the exact same software and setup that is documented in the book.

The Struts framework is becoming a de-facto standard for developing interactive web applications using servlets. If this type of development is something you are responsible for, you should consider getting a copy of this book to help you take the next step in your professional development. The "kickstart" concept means that the authors don't spend a lot of time on fluff or auxilllary material. You are quickly exposed to the core concepts along with a large number of examples to illustrate those technical points.

There are a number of assumptions made in this book. The web server used for examples is the Jakarta Tomcat server. If you're using that platform for your development, you'll be very comfortable with the book. The authors also assume a prerequisite knowledge of JSP, as well as the use of MySQL for writing applications that access data from relational databases. From a cost perspective, this is all good in that you can set up your test environment for free. On the other hand, if you use other packages such as IBM's Websphere Application Server and DB2, you'll have to make the adjustments on your own.

The book is very comprehensive in what it covers, and there is an abundance of code to help you see working examples that you can use for your own purposes. Since I'm not as "up to speed" on servlet technology as I'd like to be, I'd prefer a somewhat slower style for learning. But that's not a knock on the book as much as my own personal preference.

Conclusion
If you're comfortable with web applications, deployment, and servlet coding, this will be a good choice for getting started with Struts. If you're still relatively new to all this, you may want to get a book that doesn't assume quite so much to start with. Once you get familiar with Struts, this would be a good companion book for examples.

When I am writing this review, the price of a used copy starts from 56 cents. You can imagine what quality you can expect from a book whose owner is so eagerly willing to part with it.

I did read this book and here is what I have to say. In short, do not buy this book or even read it. It's a waste of time.

I can't believe Craig McClanahan recommended this book. How much did Sams pay him to say that?

This book fills a major gap in the Struts literature: it shows you how to solve real-world problems using Struts. If you want to learn the details of how Struts works, you need a different book. However, if you're sick of wasting an hour every time you need to figure out how to use an html tag you've never used before, this is the book for you.

I'm learning Struts so I can use it to write a commercial application. I didn't buy this book until I had finished the first two modules of my app, and I really regret it. I remember wasting 3 hours one day figuring out how to use <html:select> in conjunction with <html:optionsCollection> to render a lookup table from my database. I'm pretty handy with Google, but the fact is, there's not a lot of solid information out there about how to use the Struts tag libraries. This book contains the exact code I needed - I could have copied it into my JSP and been on my way in less than a minute.

It's obvious to me that Turner and Bedell struggled through Struts the way I did, and decided to write a book with all the answers once they figured the answers out. They did a fantastic job. They cover all the aggravating details you're going to face writing real apps, and they explain the solutions clearly and accurately.

Bottom line: After reading the three major Struts books, I can tell you that none of the books alone will get you where you need to go. I recommend "Programming Jakarta Struts" for learning Struts theory, and this book for learning how to get real work done.

Problems started from chapter 6, beginning was simple, easy, as beginning of any other JSP book. Author decided to make a nice example of struts application, the "stock tracker" application. I was so happy to see a good example, since other books lack complex examples. This example was realistic every-day type of applications we see on the web (banking or paying bills, rental). It also deals with retrieving XML data from the disk, and I find this also an often case in the real world applications. So the example had all chances to be good, and therefore book seemed to be oriented to people who really want to do some progress in JSP (and struts) development and to do some serious applications, not hello world in 21 ways ("hello from jsp", "hello from DB", "hello from servlet", "hello from preprocessor", "hello form plug-in"). So his example was promising to provide some logic, state machines, db access and synchronization, that "hello in 21 ways" approach lacks.

Also some use cases were mentioned and at that moment the book had all chances to be really serious one. Real life example, use cases, db, xml, regular expressions. In only he touched xalan and xerces it would be state of art idea for the book. Wow!

However, all fails down, since author just mentions these technologies, but never goes down to the details, possible problems, drawbacks and finally leaving you on your own to learn them.

Use cases without UML diagrams. He does not mention any other UML diagram. If the decided to go into use cases, the he should have done it as it is done in real life, use a tool to draw them and go thru activity diagram, state diagram, class diagrams, component and deployment diagram, etc. I got impression like he tells a reader: "Hey, there is something called Use cases, learn them alone".

Again, he needed a db backend, he used MySQL and provides SQL schema which is good enough to copy paste to my SQL command editor and to get tables ready. To access db from servlets he used Torque tool to generate java source code for accessing/updating records for tables he designed. But again same mistake follows - doesn't go any further than saying "It's worth taking a moment to see how Torque works" - and that's all he says about Torque! Ant is needed to run Torque. No even a sentence about how to launch Ant on Torque to generate java code for your own tables of your own application, which I believe, it is to expect from a reader to do. Well, perhaps he thought you will use provided java source on the CD and not build your own code. But what if a reader wants to do his table?

So now I got nothing out of that nice example. After several days trying to rearrange sources and put them into a project for JBuilder, WebSphere, Eclipse, somehow I got that code compiling and working, and then run into various problems regarding exceptions about locating property files, unable to connect Torque classes to MySQL, etc. I think that author should have provided several project files for several tools to help a reader to launch and start any of the provided examples, or at least, to provide Ant build files for some free application server.

Finally, the general problem in the book is that author does not go into the depths of any technology that he uses, leaving a reader in troubleshooting alone. He has no serious attitude nor is willing to take a reader by hand and show him/here nuts and bolts, problems and highlights of Struts. Everything is kept on an introduction and shallow level. Book was meant to impress with its example, which is left in "wireframes", unknown UML term for me. My favourite sentence from the book: "The Action can be very simple or very complicated."

I give 2 stars because I liked the example. For someone of my experience (6 years in java) I would recommend some cookbook rather than this one, my greetings goes to Struts books: Struts Survival Guide, Struts in Action, Professional Jakarta Struts, in exact order. There are nice tutorials by Borland and IBM about struts and JSPs.

First, this book was published in 2002, which means it was written in 2001. Rather out of date.

I have three very major complaints.
1. The author, like almost all Struts book authors, starts right off the bat giving examples of JSP files that include Struts tags...a topic that is not covered until many chapters later! So the beginner (me) is left scratching his head wondering what all this gibberish is about. How much easier it would have been to provide the early examples in HTML and then later show them using tags AFTER tags have been introduced and discussed.

2. There are l-o-n-g sections of nothing but HTML/JSP code with almost no commenting. Do ANY publishers get it that they don't need to print EXACT code listings? The printed page could have arrows and circles and bold print highlighting codes snipets and discussing what they do. This book leaves it up to the reader to find the important nuggets in hundreds of lines of code.

3. Certain sections are so terse as to be meaningless, and even go so far as to tell the reader to look at the Struts documentation and then you'll understand it all. HELLO?? That's why I bought the &%$#!! book.

On the plus side, the font is nice, there is plenty of white space and it is easy on the eyes.

Skip this one. This is my 5th Struts book and I'm STILL looking for a good one. I think a good rule is that if a book is written by an open-source code author, avoid it like the plague. Coders are NOT writers. Unfortunately, the editors don't seem to be writers either. Maybe that job was outsourced...