AspectJ in Action: Practical Aspect-Oriented Programming

Rating:
Summary: AspectJ In Action is a great AOP introduction
Review: AspectJ In Action is a great book to use as an introduction to Aspect-oriented Programming. However, AOP is not for developers to whom Java and OO are still new. Without a comfortable understanding of classes, polymorphism, and encapsulation AOP will only further confuse things.

With that said, AspectJ In Action is a wonderful book filled with plenty of examples and explanations about the well-lit areas of AOP as well as many of the dark corners. I enjoyed reading this book because it starts out with the fundamentals and works its way to more and more complex uses of AOP without getting bogged down in language tangents. Also, the direct application of AOP in real Java design areas is very helpful in getting a better feel for when and how AOP can be applied.

I am looking forward to Ramnivas Laddad's next book!

Rating:
Summary: Definitive source on AOP
Review: I am a beginer in AOP and before I picked this book, terms like point cuts, advice sounded greek and latin to me. However after reading through the book, I now know exactly what AOP is and how to program using AspectJ.

AOP seems to have come of age and this book is excellent resource to come upto speed.

The book is divided into three parts.
The first prat introduces AOP, why AOP and about AspectJ in a very easy to understand manner. Best intro I have ever read.
Then it introduces the syntax of AspectJ

Second part introduces more advanced techniques and makes you really good at AspectJ.

Third part of the book is a real gem. Here you find, excellent and practicval uses of AOP in every day scenarios.

I am currently reading this part now and I feel confident talking to my boss to start using AOP at work.

A must read for anyone wanting to study AOP

Rating:
Summary: Best AOP book I have seen so far
Review: I have got this book at local Austin Java User Group meeting. First impression: different cover. Most of Manning books are either greenish or almost black-and-white. This one is yellow.

Part 1 provides really good introduction into AOP. This is the first book I have read on AOP; all stuff I have seen before was online or magazine articles. One interesting fact is that this book took a while to consume, compared to the usual two-week cycle I have for technical books. I guess the reason is that the book has more substance than most of the techincal books and Mannigs does not try to pad their books with API references and other stuff that can be easily found online. After the chapter goes through AOP concepts, it explains AspectJ in application to those concepts. Basic syntax as well as some advanced techniques are explained.

Part 2 has examples of basic applications of AspectJ. Of course it starts with the mandatory logging implemented using AOP. Not a very good example in general, since logging is not really a cross-cutting concern, but works for illustration purposes. Other two application areas discussed in this part are implementation policy enforcement and optimization (pooling and caching examples). Policy enorcement part is really interesting, especially if you are into call patterns.

In general, every part follows the same pattern: first the author discusses the conventional approach, then explains challenges of the conventional solution, provides AspectJ-based solution, and gives one or two examples. Very clean language, easy to follow.

Part 3 discusses advanced applications of AspectJ. First it delves into design patterns and idioms of AOP; it's not by any means AspectJ-specific, so would be useful for any AOP implementation. Examples of patterns are providing thread-safe implementations using AspectJ, implementing security (very interesting discussion on JAAS), transaction management, and implementing business rules using AspectJ. The part ends with AspectJ usage in different development phases.

Two appendices: description of AspectJ compiler and Ant integration - only 15 pages for both. Useful as a reference.

Overall impression: an excellent book. Definitely worth reading, even if you are not into AOP yet.

Rating:
Summary: Real uses for AOP
Review: I met the author of this book this weekend, and saw him give a presentation on this material. Finally, a book that shows real uses for AOP.
I have been watching AspectJ since I first saw it about a year ago. My first impression was that it was 'cool', but was worried about giving developers more rope with which to hang themselves. Yes, it was cool, but the most practical examples you would see in demos were thing like 'logging'. I was worried that it would just lead more more ways for junior engineers to 'convolute the code', without bringing much benefit for that risk.
The material in this book, ALONG WITH the support the author had from the Eclipse IDE changed my mind. Finally, there were some real examples involving transaction support, JAAS, exception handling, and more. Furthermore, he addressed these topics in the real-world sense of refactoring existing code to prove his points.
If you aren't using an IDE that gives you some support, then I still have my concerns about 'convoluting' your code; but I am more convinced than ever that AOP concepts are worth putting into my mental toolkit. I have no doubt that the way aspects 'inject' behavior into code will reduce our development time, and make our code behave more consistently (no errors because of inconsistencies in the way common things are handled). If you can add one more ball to the things you 'mentally juggle' while developing, add AOP concepts. This book will help.

Rating:
Summary: Well written introduction and thorough coverage of AspectJ
Review: I read this book a while back and wasn't completely impressed but I just picked it up again for this review and now I am much happier with it. The first four chapters provide an excellent grounding in Aspected Oriented Programming (AOP) with AspectJ. In particular the first chapter, which introduces the reader to AOP, shows the quality of writing and editing that Manning is known for.

Chapters five through to the end apply AOP to various problems within Java application development, starting with logging (of course, the AOP perennial favorite.)

On the downside I would have liked to have seen more information about where AOP is being used in production today. I'm not sure what the timing of the release was, but it would have been nice, if possible, to have had material on the use of AOP in JBoss.

I have not read the other books on AspectJ, so I cannot provide a comparison of them. Even so, I have to say that if you are into AOP, or more importantly, looking at AspectJ, then I think you have to look at this book.

(Full disclosure: I am a Manning author but I in no way allow that to effect my reviews.)

Rating:
Summary: From basics to design patterns
Review: Ramnivas Laddad wrote a comprehensive book on AOP with the focus on AspectJ. He deals with AOP and AspectJ basics, explains the (sometimes fine) differences in advice declarations, and cleans up the myths and prejudices on AOP.

Going further Ramnivas uses real-life examples to show step by step how to use Aspects in your daily work. He explains how to transform a pure Java based solution to a cleaner, more structured AspectJ solution. The reader can see that the AspectJ solution is more elegant and can always understand how Ramnivas came to his solutions. Ramnivas explains this for cruicial topics most developers have to face, for example logging or thread safety.

Special bonus is the chapter on aspect design patterns. Ramnivas shows four design patterns, that don't exist in the non-AOP world. They are quite useful in AOP, though, and AFAIK there is no other source for this important information.

"AspectJ in action" is a book for beginners as well as for advanced AspectJ programmers. It is well written and easy to understand. The real-world examples allow you to transfer the solutions on a 1:1 basis to your project and thus try in real life how aspects work for you.

Rating:
Summary: Practical, concise and most of all, it works!
Review: The book provides you out-of-box working codes to attack real world problems. The design patterns introduced in the book are most helpful. They let you feel the power of AOP. The book content are well organized and easy to understand.

You might run into some huddles while working with AspectJ in IDEs, such as OutOfMemory problem, although ANT approach works very well. But that is a growing pain of any new technology.

"I can only show you the door. You have to walk through it."
--From Matrix.

The author surely did that.