AspectJ Cookbook

Rating:
Summary: Comprehensive and practical
Review: Because of AspectJ's complex syntax it really benefits from a cookbook-style approach. I find the abstract concepts of AOP are somtimes a lot easier to understand than the AspectJ syntax (involving aspects, pointcuts and advice) needed to implement them.

Russell Miles has done a great job of structuring the book in a logical way. The book begins with recipes for compilation and deployment of Aspectj code using all the usual tools. The second section explains how to capture join-points on all the event types supported by AspectJ, ie. method-calls, exception catch blocks, object initialization etc. These first two sections form a good starting point reference for AspectJ syntax.

The bulk of the rest of the book contains recipes for practical use of aspects. I'm no expert on the topic but these chapters struck me as quite a good selection of the 'cross-cutting' concerns that people usually bring up in AOP discussions. eg. language extensions, object persistence, logging and tracing, virtual mock objects, RMI, lazy loading, transaction handling, security policies etc. The author also includes recipes for using Aspects to implement each of the GoF patterns. I found some of these recipes more interesting than practical - the benefits of using aspects seemed tenous in some cases (do all of them really involve cross-cutting concerns?) although they widened my view of the potential applications of AOP.

I generally found the recipes very well written and clear. The book also includes many UML sequence diagrams that are great for showing how aspects get woven in. I think AspectJ really needed a book like this - all in all a great contibution to the O'Reilly series.

Rating:
Summary: Needs more why and less how
Review: It's always tempting to judge a book by the topic and not the actual content of the book itself, especially with a controversial topic like AOP. I won't do that hear. Though I feel that in a large way the fundamental issue with AOP, which is that it's a technology looking for a problem to solve, is the major problem with this book.

As with the other recipe books this is organized first into chapters around the fundamentals of the topic. Then within each chapter there is a set of problems, which are described, then solved using the technology. The solution is the described in detail and alternatives are provided. But where other recipe books tend to solve real world problems (e.g. connecting to Amazon web services), this book solves problems in the AOP technology itself.

Four chapters of the book are dedicated to implement GoF Design Patterns in AOP. This is interesting content. If you are an AOP enthusiast these sections alone will be worth the price of the book. But if you aren't a true believer you will not find justification for why you should implement the Design Patterns in AOP. You will only find out how they are implement. Take recipe 19.5, "Implementing the Chain of Responsibility Pattern". The problem is stated as, "You want to apply the chain of responsibility pattern using AspectJ." Ok, but why would I want to do that? What is the benefit? What are the drawbacks? This is never discussed.

Obviously a buy for the AOP faithful. Probably a buy for those seriously interested in AOP. But we are all still looking for the book that justifies AOP in terms of solutions to real world customer problems.

Rating:
Summary: Neither tasty nor filling
Review: The largest part of the book covers AspectJ language elements. The chapters have titles such as "Capturing Join Points on <Something>", "Defining Advice", and "Enhancing Classes and the Compiler". Yet this is something that one very rarely wants to do. All these tasks are just means in the service of an end. To use the title's metaphor, these tasks are not recipes in themselves, they are only intermediate steps on the way to a meal. And at that they're not well captured by the format -- for my taste Laddad's "AspectJ in Action" does a much better job. The three chapters on implementing the GOF patterns using AOP could have been interesting had the author just once strayed from the boring routine of presenting nothing but the mechanics of the respective pattern. Does he ever touch the question why anyone would want to use AOP to implement these patterns? If he does, it must have been well-hidden. Also, there are a lot of similarities which are more than superficial in the AOP implementations. As it stands, the original work by Jan Hannemann, on which these chapters are based, is a much more relishable read. Then, at the end of the book, there are three chapters on applying AOP/AspectJ at the component, application, and enterprise level as well as one on AO design patterns. These chapters are the model for what the whole book should have been like, in my opinion. They finally deal with real-world problems and how AOP/AspectJ helps in solving them better than earlier approaches do.

Rating:
Summary: Excellent programmers' hand book for AspectJ
Review: This is an excellent practical guide to incorporating Aspects, in particular AspectJ, into your object-oriented software skillset.

This book is not a theoretical study of AOP; rather, it is a guide book for the software engineer who has already decided that using Aspects will benefit his or her software and is now looking for a 'How-To'. As a handbook, it begins with how to install AspectJ; how to build projects with Eclipse and Ant; and also looks at how to deploy AO applications, web applications and web services. It then goes on to look at basic and advanced AspectJ features and usage. As a side note, the Eclipse IDE provides great visual AspectJ support and is worth having a look at if you are planning on using AspectJ ;)

This is a book that a software developer can dip into when programming using Aspects - to find out how to do something; or using the design pattern chapters - how to do it better.

Rating:
Summary: teaches how to use, but look elsewhere for why
Review: You need to already know the ideas behind aspect orient programming [AOP}, before opening this book. Plus a fluency in Java, by the way. While I have the latter fluency, I'd only met AOP briefly in a few papers.

Under the familiar O'Reilly cookbook format, the book has guidelines on various difficulties you might be having, when running AspectJ. It's a superset of Java. The new syntax is not so difficult to learn. True, it's more involved than writing a new class, that conforms to existing Java syntax. But a good Java programmer should quickly grasp how to implement crosscuts or advice.

As to the broader issue of whether you should use AOP at all, the book is silent. It tells you well how to use AOP in the form of AspectJ. But you need to decide, based on externalities, whether to take it up at all.