Customer Reviews

Aspect-Oriented Programming with AspectJ

5 star:		(3)
4 star:		(1)
3 star:		(1)
2 star:		(0)
1 star:		(1)

 

 

I have never rated a book as lowly as I have for this one. It is horrible. Let me count the ways:

1. They forgot to edit the book

Not only are there spelling errors and grammatical errors, but numerous code errors, API errors (or ommissions), and code left out of the book! The grammatical errors actually make certain parts of the book impossible to understand. I had to search on the web to find the answers.

2. VERY poor organization

In one chapter he tells you the code you'll need to compile something we won't do until four chapters later. Worse, although he attempts to create an incremental build of your code, the code you can download online only works in the final version. Of course if the book actually had the incremental code that wouldn't matter, but it only has some of it. I spent half my time just trying to figure out what in chapter 4 goes with what in chapters 2, 5 and 7 (for example).

3. Missing SQL Code

I had to guess what the tables were like since he forgot to include SQL code in the book AND (!!!) it isn't in the code download online either!

4. Poor explanation of everything

Almost every example he gives in the book has either no explanation, or a useless one. For example, he might tell you that some code "introduces" the class to their new parents and that "introduce" is the official name for this action. Of course, don't ask him to define the keyword "introduce" for you. You have to figure that out for yourself. This whole book reads as though it were written by someone who loves to be smart, loves big names and acronyms that define him as a high level programmer and doesn't want to sound too simple by actually taking the time to explain it to you. As they say, "those who can't do, teach." In other words, those who weren't naturals at it had to struggle to learn so they understand they have to explain it to you - Kiselev does not.

Don't buy this book.

I liked that book - it manages to squeeze a lot of new information into relatively small volume - though may be at the expense of the ease of understanding by novices.
Explanations are concise and relying on reader's intelligence, without "I'm teaching you" condescending approach so common for many "methodology" books.

Code examples are useful - if you don't care much to compile them. They rather have to be treated as pseudo-code that illustrates the AOP concepts - and very effectively, I think.

I wish more books like this one were published - short, to the point, respecting both my time and my bookshelf space.

After reading piles of aspect oriented papers, primers, and so forth, this book was a refreshing change. Clear, to the point and intelligent, this book is a must have for anyone serious about AOP or AspectJ. The book is presented in three main sections: an example application, a guide to AspectJ itself and a host of appendices, including Patterns and an API reference.

This is the first book on the subject. Mr. Kiselev is in a difficult possition: the technology is still so new, and the developements in the area over the course of the next few years will be major, most likely rendering much of this work useless. Right now, however, this is the book to get. When the time comes, we can only hope he updates.

As the subject is relatively "new" for the general public, the documents obtainable from [URL] had been the best tutorial until the arrival of this book.

The author has a in-depth understanding on the AspectJ and he was able to present his knowledge clearly in his book. The "aspect traces" provided were able to help the readers understand how AspectJ really works. The examples helped me to grasp the difference between the "call" and "execution" pointcuts.

I didn't give this book five-star because the few chapters on the "AspectNews" application were not convincing because I don't think it likely that AspectJ will be applicable to a non-trivial Web application for the exact reasons given by the author in the last chapter (ch. 14) of the book.

If you need a book that explains the technology, then buy this book.
If you need a reference guide, then buy this book.
If you need some examples that illustrate the power and limitations of this technology, then you should *definitely* buy this book.
If you are looking for the big picture, concerning the big freaking aspect-oriented programming thing, if you want to read about scientific justification, and if you're looking for proof, then you *might* consider buying this book, but I didn't find it very valuable from that perspective.
If you just want to be entertained, then you might consider buying something else. Maybe something like 'The Amazing Adventures of Kavalier & Clay'.

I have read this book with great interest. My conclusion - this is
excellent introduction into new field of information technology. The great
advantage of the book is the "from simple to complicated" style of
presentation that allows to recommend it as a great introductory course for
self study. The extension of Java classes into AspectJ can play the same
revolutionary role for Java developers as some years ago
Microsoft MFC implementation did for Windows 3.1
programmers. The concept of dynamic crosscutting can be enormously useful
for everybody involved in the development of real-life business applications.
The style of presentation allows to start using AspectJ for application
development very quickly. The large number of simple examples is
represented in the way similar to the famous Stroustroup's C++ book.
This book can be recommended to everyone who is interested in the new way
of thinking and the current state of information technology innovations.

I have not succeeded to compile and execute the code from the book due to a
lot of technical problems. The code listings and examples in Kiselev's book
can be recommended as invitation to think and develop you first application
in AspectJ.