aspectj publications

Books and articles about AspectJ are listed below by date.
This list does not contain academic papers or publications we
haven't heard about. If you know of something not listed,
please email a description to
aspectj-users@eclipse.org.

Eclipse AspectJ :
Aspect-Oriented Programming in Eclipse with AspectJ and the AspectJ Development Tools,
by Adrian Colyer, Andy Clement, George Harley and Matthew Webster.

In this book, the lead developers of AspectJ
"cover every facet of AOP development with
AspectJ and Eclipse, from creating new projects through extending and
documenting full-fledged applications. You'll find an authoritative
tutorial covering the entire AspectJ language, a complete API reference,
and realistic guidance on adopting AspectJ..."

It is time to move from AOP theory and toy examples to AOP practice and real applications.
With this unique book you can make that move. It teaches you AOP concepts, the AspectJ language,
and how to develop industrial-strength systems. It shows you examples which you can reuse.
It unleashes the true power of AOP through unique patterns of AOP design. When you are done,
you will be eager-and able-to build new systems, and enhance your existing ones, with the help of AOP.

The AspectJ Cookbook shows readers why, and how, common Java development problems
can be solved by using AOP techniques. With our popular problem-solution-discussion format,
the book presents real world examples to demonstrate that AOP is more than just a concept;
it's a development process that will benefit users in an immediate and visible manner.

Aspect-oriented programming (AOP) promises to increase the power of OO applications by
modularizing functionality that cuts across classes (such as logging, transaction management,
design patterns, and security). If your application has this type of functionality,
you can benefit from using AspectJ, an AOP language that is a seamless extension to Java.

In this code-intensive book, the authors present a detailed overview of the concepts of AOP and
AspectJ, and take you step-by-step through the process of building an application.

In this book, four leaders in AOSD development bring together today's most significant advances.
Drawing on contributions from the field's leading researchers, they introduce fundamental AOSD concepts,
present new technologies for AOSD engineering and programming, and detail early application experiences
with AOSD methods.

In this highly anticipated new book, Ivar Jacobson and Pan-Wei Ng demonstrate how to apply use cases—
a mature and systematic approach to focusing on stakeholder concerns—and
aspect-orientation in building robust and extensible systems. Throughout the book, the authors employ a single,
real-world example of a hotel management information system to make the described theories and
practices concrete and understandable.

In this new book, two AOSD experts apply theory to the practical realm of real-world development.
They explain the different kinds of aspects, help the reader identify them, and provide guidance on
successful design and implementation. The result is an applicable and easy-to-digest methodology for
simplifying and optimizing the development of software systems.

In a November 2001 Java Pro magazine article, noted Java pundit Daniel Savarese states,
"The days of Object-Oriented Programming may be numbered, One day we may all be using Aspect-Oriented Programming ."
While this may be hyperbole, the AOP bring certain needed improvements to the OOP.
AspectJ is a Java-based tool that allows developers to apply standard Java syntax to AOP principles,
much as C++ allowed C programmers to use C syntax in an object-oriented manner.
There are AspectJ add-ons available for Borland's JBuilder, Sun's Forte for Java and for the EMACS text editor.
Aspect-Oriented Programming with AspectJ introduces AOP and the AspectJ tool. The book also shows how,
by using existing Java programming knowledge, the developer can use AOP in meaningful development work.

In this article, AJDT contributors and IBM aspect-oriented software development team members
Matt Chapman and Helen Hawkins introduce you to AJDT. You'll learn how to install the tools;
how to create, run, and debug AspectJ applications; and how to visualize and navigate the crosscutting
structures inherent to aspect-oriented programming.

"Aspect-oriented programming does involve deep
concepts in programming, but the basics are easy enough to yield immediate
benefit with relatively little effort. This fits well with both a fast paced
extreme programming style and a conservative style that requires proof of
benefits at each step before committing to the next step. The full value of
completely adopting AOP may be as profound as the transition from structured
programming to object-oriented programming, but with little or no cost for a
gradual and gentle transition."

(Originally titled "Test-Inoculated: Programmers Love Not Writing Tests")
This introduces AspectJ using code snippets that
verify compile- and run-time invariants, capture and replay input,
and set up stubs and drivers for integration testing.
(corresponding
sources are available)

"To keep the cost of test development low, unit
tests must run in isolation. Mock object testing isolates each unit by
providing mocked implementations of code on which the tested class depends.
But object-oriented techniques cannot successfully replace collaborating
code in situations where dependencies are retrieved from a globally
accessible source. AspectJ's ability to crosscut the structure of the tested
code allows you to cleanly replace code in these types of situations."

"AOP and AspectJ solve real problems, and early
adopters are increasingly trying AOP concepts with AspectJ. Like any other
new programming paradigm, it will take time before both technologies reach
their full potential. As more developers use AspectJ, the experience gained
will guide the language's evolution. Simultaneously, design patterns and
anti-patterns will appear. AOP's adaptation as a mainstream programming
methodology will be a fun thing to watch and, better still, participate in."

"Aspect-oriented programming (AOP) is a new
programming technique that allows programmers to modularize crosscutting
concerns (behavior that cuts across the typical divisions of
responsibility, such as logging). AOP introduces aspects, which
encapsulate behaviors that affect multiple classes into reusable modules.
With the recent release of AspectJ by Xerox PARC, Java developers can now
take advantage of the modularization AOP can provide. This article
introduces AspectJ and illustrates the design benefits that result from its
use."

"Most software systems consist of several concerns
that crosscut multiple modules. Object-oriented techniques for implementing
such concerns result in systems that are invasive to implement, tough to
understand, and difficult to evolve. The new aspect-oriented programming
(AOP) methodology facilitates modularization of crosscutting concerns. Using
AOP, you can create implementations that are easier to design, understand,
and maintain. Further, AOP promises higher productivity, improved quality,
and better ability to implement newer features. This article, the first in a
three-part series, introduces the AOP concept and the problems it attempts
to solve."

"AspectJ contains many very interesting language
features and you may start looking for excuses to use them in your programs
once you realize everything they make possible. AspectJ's authors recommend
that you get started using aspects for writing, testing, and profiling code
before moving on to make it an integral part of your production code base.
AOP has many years to go before it becomes a mainstream programming
methodology, but I have a feeling that aspects are here to stay, and that at
least some AOP features will eventually make their way into Java and other
programming languages."

"We have tested AspectJ extensively and feel
confident enough in it that we use it in production. We have never had a bug
caused by the compiler-generated code. The tools are still rough around the
edges, but we have seen steady improvement in functionality and quality over
the past year. Support is excellent. Despite some minor annoyances and
limitations, I can't imagine not using AspectJ."

"It's not every day, or every year, that you come
across something that makes you rethink your entire approach to
programming. Mark my words, aspects are going to cause an epochal shift in
programming right up there with the object shift of a decade ago. . . there
is no question that within a few years, aspects will be as much a part of
the programming lexicon as objects are today. . . AspectJ is the best tool
to help Java programmers investigate an exciting programming concept whose
time on the main stage of software development has come. Do yourself a favor
- download it today."

"The first time I really grasped the wonderful
power of object-oriented abstractions, I thought I'd seen the ultimate model
on which all kinds of complex systems could be grown. . . However, I was
wrong: There's something deeper, something that's truly beyond objects.
Admittedly, this isn't a concept that's easy to explain, because I'm still
so steeped in an object-oriented view of the world. However, just as a
sailor can sense a changing sea, I note subtle signs that point to a marked
transformation, a disruptive technology, on the horizon."

"Pity software engineers. With the touch of a
button, their programs let us make global fixes in a long text, say, or a
spreadsheet, yet programmers often need to correct their own work one
tedious line at a time. That irony isn't lost on Gregor Kiczales, principal
scientist at Xerox's Palo Alto Research Center (PARC) and professor at the
University of British Columbia in VancouverÑand he has a fix in mind.
Kiczales champions what he calls "aspect-oriented programming," a technique
that will allow software writers to make the same kinds of shortcuts that
those of us in other professions have been making for years. . ."

"Aspect-oriented programming is a novel topic in
the software engineering and languages communities. AOP appears to have the
potential to significantly improve the reliability of programs, particularly
by modularizing error-handling policies and allowing for easier maintenance
and better reuse. In this article we introduce AspectJ, the first
aspect-oriented programming language, and demonstrate how you can use it to
construct more reliable software."

"Abstract: AOP defines a new program construct,
called an aspect, which is used to capture corsscutting aspects of a
software system in separate program entities. This article is divided into
three parts: first, an explanation of the concepts of AOP; second, an
introduction to AspectJª, an implementation of the AOP concepts in Java;
finally, a comparison of the AOP approach to metalevel programming."