Frequently Asked Questions about AspectJ

Frequently Asked Questions about AspectJ Copyright (c) 1997-2001 Xerox Corporation, 2002 Palo Alto Research Center, Incorporated. All rights reserved. Last updated December 31, 2002. For a list of recently-updated FAQ entries, see AspectJ 1.1 is currently in development, and some answers may change after it is released; for more information, see the README included with the AspectJ 1.1 distribution. Overview What is AspectJ? AspectJ(tm) is a simple and practical extension to the Java(tm) programming language that adds to Java aspect-oriented programming (AOP) capabilities. AOP allows developers to reap the benefits of modularity for concerns that cut across the natural units of modularity. In object-oriented programs like Java, the natural unit of modularity is the class. In AspectJ, aspects modularize concerns that affect more than one class. AspectJ includes a compiler (ajc), a debugger (ajdb), a documentation generator (ajdoc), a program structure browser (ajbrowser), and integration with Eclipse, Sun-ONE/Netbeans, GNU Emacs/XEmacs, JBuilder, and Ant. You compile your program using the AspectJ compiler (perhaps using the supported development environments) and then run it, supplying a small (< 100K) runtime library. What are the benefits of using AspectJ? AspectJ can be used to improve the modularity of software systems. Using ordinary Java, it can be difficult to modularize design concerns such as system-wide error-handling contract enforcement distribution concerns feature variations context-sensitive behavior persistence testing The code for these concerns tends to be spread out across the system. Because these concerns won't stay inside of any one module boundary, we say that they crosscut the system's modularity. AspectJ adds constructs to Java that enable the modular implementation of crosscutting concerns. This ability is particularly valuable because crosscutting concerns tend to be both complex and poorly localized, making them hard to deal with. Can AspectJ work with any Java program? AspectJ has been designed as a compatible extension to Java. By compatible, we mean upward compatible All legal Java programs are legal AspectJ programs. platform compatible All legal AspectJ programs run on standard Java virtual machines. tool compatible Existing tools can be extended to work with AspectJ. programmer compatible Programming in AspectJ feels natural to Java programmers. The AspectJ tools run on any Java 2 Platform compatible platform. The AspectJ compiler produces classes that run on any Java 1.1 (or later) compatible platform. How is AspectJ licensed? The AspectJ tools are open-source software available under the Mozilla Public License 1.1. The documentation is available under a separate license that precludes for-profit or commercial redistribution. Generally, we permit some usage for internal presentations; please contact us at support@aspectj.org for permission. Most users only want to use AspectJ to build programs they distribute. There are no restrictions here. When you distribute your program, be sure to include all the runtime classes from the aspectjrt.jar for that version of AspectJ. When distributing only the runtime classes, you need not provide any notice that the program was compiled with AspectJ or includes binaries from the AspectJ project, except as necessary to preserve the warranty disclaimers in our license. Although the license does not require it, please email support@aspectj.org if you are shipping applications built with AspectJ; knowing that is critical for ongoing support from our sponsors. What is the AspectJ Project? AspectJ is based on over ten years of research at Xerox Palo Alto Research Center as funded by Xerox, a U.S. Government grant (NISTATP), and a DARPA contract. It has evolved through open-source releases to a strong user community. The AspectJ team works closely with the community to ensure AspectJ continues to evolve as an effective aspect-oriented programming language and tool set. The latest release is 1.0.6 which can be downloaded from the AspectJ download page. Further development is focused on supporting applications, improving performance of the 1.0 compiler, enhancing integration with IDEs, and building the next generations of the language. Quick Start What Java versions does AspectJ require and support? The AspectJ compiler produces programs for any released version of the Java platform (jdk1.1 and later). When running, your program classes must be able to reach classes in the small (< 100K) runtime library (aspectjrt.jar) from the distribution. The tools themselves require Java 2 (jdk 1.2) or later to run, but the compiler can be set up to target any 1.1-compliant version of the Java platform. How do I download and install AspectJ? Go to AspectJ's download web page and choose which components you want download. The jar files are installed by executing java -jar jar file name Do not try to extract the jar file contents and then attempt to execute java org.aspectj.Main. (A NoClassDefFoundError exception will be thrown.) The AspectJ distribution is not designed to be installed this way. Use the java -jar form shown above. The compressed tar files (suffix: .tgz) are extracted by decompressing them with tar or with WinZip. To uninstall, remove the files the installer wrote in your file system. In most cases, you can delete the top-level install directory (and all contained files), after you remove any new or updated files you want to keep. On Windows, no registry settings were added or changed, so nothing needs to be undone. You may install over prior versions, but if the files are locked the installer will warn you but still complete; in this case, remove the locked files and reinstall. How should I start using AspectJ? Many users adopt AspectJ incrementally, first using it to understand and validate their systems (relying on it only in development) and then using it to implement crosscutting concerns in production systems. AspectJ has been designed to make each step discrete and beneficial. In order of increasing reliance, you may use AspectJ: In the development process Use AspectJ to trace or log interesting information. You can do this by adding simple AspectJ code that performs logging or tracing. This kind of addition may be removed ("unplugged") for the final build since it does not implement a design requirement; the functionality of the system is unaffected by the aspect. As an ancillary part of your system Use AspectJ to more completely and accurately test the system. Add sophisticated code that can check contracts, provide debugging support, or implement test strategies. Like pure development aspects, this code may also be unplugged from production builds. However, the same code can often be helpful in diagnosing failures in deployed production systems, so you may design the functionality to be deployed but disabled, and enable it when debugging. As an essential part of your system Use AspectJ to modularize crosscutting concerns in your system by design. This uses AspectJ to implement logic integral to a system and is delivered in production builds. This adoption sequence works well in practice and has been followed by many projects. How does AspectJ integrate with existing Java development tools? AspectJ products are designed to make it easy to integrate AspectJ into an existing development process. Each release includes Ant taskdefs for building programs, the AspectJ Development Environment (AJDE) for writing aspects inside popular IDE's, and command-line tools for compiling, documenting, and debugging. AspectJ provides replacements for standard Java tools: ajc, the AspectJ compiler, runs on any Java 2 compatible platform, and produces classes that run on any Java 1.1 (or later) compatible platform. ajdoc works like Sun's javadoc API documentation generator to produce HTML describing the semantics of Java and AspectJ source files, including entries and cross-references for the crosscutting structure. ajdb is an aspect-aware debugger akin to Java's jdb. The AspectJ Development Environment (AJDE) enables programmers to view and navigate the crosscutting structures in their programs, integrated with existing support in popular Java IDE's for viewing and navigating object-oriented structures. For many programmers this provides a deeper understanding of how aspects work to modularize their concerns and permits them to incrementally extend their development practices without having to abandon their existing tools. AJDE integrates with the following tools: Borland's JBuilder (versions 4 and 5) Sun Microsystems' Forte for Java (versions 2 and 3), and Netbeans 3.2 Eclipse (version 2.0) GNU Emacs (version 20.3) and XEmacs (version 21.1 on Unix and 21.4 on Windows) The common functionality of AJDE is also available in the stand-alone source code browser ajbrowser, included in the tools distribution. AspectJ also supports building with Ant by providing taskdef interfaces to the ajc and ajdoc tools. Typical AspectJ programs Are aspects always optional or non-functional parts of a program? No. Although AspectJ can be used in a way that allows AspectJ code to be removed for the final build, aspect-oriented code is not always optional or non-functional. Consider what AOP really does: it makes the modules in a program correspond to modules in the design. In any given design, some modules are optional, and some are not. The examples directory included in the AspectJ distribution contains some examples of the use aspects that are not optional. Without aspects, bean Point objects would not be JavaBeans. introduction Point objects would not be cloneable, comparable or serializable. spacewar Nothing would be displayed. telecom No calls would be billed. What is the difference between development and production aspects? Production aspects are delivered with the finished product, while development aspects are used during the development process. Often production aspects are also used during development. What are some common development aspects? Aspects for logging, tracing, debugging, profiling or performance monitoring, or testing. What are some common production aspects? Aspects for performance monitoring and diagnostic systems, display updating or notifications generally, security, context passing, and error handling. Basic AOP and AspectJ Concepts What are scattering, tangling, and crosscutting? "Scattering" is when similar code is distributed throughout many program modules. This differs from a component being used by many other components since it involves the risk of misuse at each point and of inconsistencies across all points. Changes to the implementation may require finding and editing all affected code. "Tangling" is when two or more concerns are implemented in the same body of code or component, making it more difficult to understand. Changes to one implementation may cause unintended changes to other tangled concerns. "Crosscutting" is how to characterize a concern than spans multiple units of OO modularity - classes and objects. Crosscutting concerns resist modularization using normal OO constructs, but aspect-oriented programs can modularize crosscutting concerns. What are join points? Join points are well-defined points in the execution of a program. Not every execution point is a join point: only those points that can be used in a disciplined and principled manner are. So, in AspectJ, the execution of a method call is a join point, but "the execution of the expression at line 37 in file Foo.java" is not. The rationale for restricting join points is similar to the rationale for restricting access to memory (pointers) or restricting control flow expressions (goto) in Java: programs are easier to understand, maintain and extend without the full power of the feature. AspectJ join points include reading or writing a field; calling or executing an exception handler, method or constructor. What is a pointcut? A pointcut picks out join points . These join points are described by the pointcut declaration. Pointcuts can be defined in classes or in aspects, and can be named or be anonymous. What is advice? Advice is code that executes at each join point picked out by a pointcut. There are three kinds of advice: before advice, around advice and after advice. As their names suggest, before advice runs before the join point executes; around advice executes before and after the join point; and after advice executes after the join point. The power of advice comes from the advice being able to access values in the execution context of a pointcut. What are inter-type declarations? AspectJ enables you to declare members and supertypes of another class in an aspect, subject to Java's type-safety and access rules. These are visible to other classes only if you declare them as accessible. You can also declare compile-time errors and warnings based on pointcuts. What is an aspect? Aspects are a new class-like language element that has been added to Java by AspectJ. Aspects are how developers encapsulate concerns that cut across classes, the natural unit of modularity in Java. Aspects are similar to classes because... aspects have type aspects can extend classes and other aspects aspects can be abstract or concrete non-abstract aspects can be instantiated aspects can have static and non-static state and behavior aspects can have fields, methods, and types as members the members of non-privileged aspects follow the same accessibility rules as those of classes Aspects are different than classes because... aspects can additionally include as members pointcuts, advice, and inter-type declarations; aspects can be qualified by specifying the context in which the non-static state is available aspects can't be used interchangeably with classes aspects don't have constructors or finalizers, and they cannot be created with the new operator; they are automatically available as needed. privileged aspects can access private members of other types Why AOP? Are crosscutting concerns induced by flaws in parts of the system design, programming language, operating system, etc. Or is there something more fundamental going on? AOP's fundamental assumption is that in any sufficiently complex system, there will inherently be some crosscutting concerns. So, while there are some cases where you could re-factor a system to make a concern no longer be crosscutting, the AOP idea is that there are many cases where that is not possible, or where doing so would damage the code in other ways. Does it really make sense to define aspects in terms of crosscutting? Yes. The short summary is that it is right to define AOP in terms of crosscutting, because well-written AOP programs have clear crosscutting structure. It would be a mistake to define AOP in terms of "cleaning up tangling and scattering", because that isn't particular to AOP, and past programming language innovations also do that, as will future developments. Slides for a long talk on this topic are at http://www.cs.ubc.ca/~gregor/vinst-2-17-01.zip . Is AOP restricted to domain-specific applications? No. Some implementations of AOP are domain-specific, but AspectJ was specifically designed to be general-purpose. Why do I need AOP if I can use interceptors (or JVMPI or ref lection)? There are many mechanisms people use now to implement some crosscutting concerns. But they don't have a way to express the actual structure of the program so you (and your tools) can reason about it. Using a language enables you to express the crosscutting in first-class constructs. You can not only avoid the maintenance problems and structural requirements of some other mechanisms, but also combine forms of crosscutting so that all the mechanisms for a particular concern are one piece of code. Deciding to adopt AspectJ Is it safe to use AspectJ in my product plans? You may use AspectJ in your product or project with little risk. Several factors play a role in reducing the risk of adopting this new technology: AspectJ is an addition to Java, and can be incrementally introduced into a project in a way that limits risk. See for some suggestions on how to do this. The AspectJ compiler accepts standard Java as input and produces standard Java bytecode as output. An optional mode produces standard Java source code which may then be compiled with any compliant Java compiler, e.g. Sun's javac compiler or IBM's jikes compiler. AspectJ is available under the Mozilla Public License, a non-proprietary, open source license. This ensures that AspectJ will continue to evolve and be available, regardless of the fate of any particular organization involved with AspectJ. Removing AspectJ from your program is not difficult, although you will lose the flexibility and economy that AspectJ provided. What is the effect of using AspectJ on the source code size of programs? Using aspects reduces, as a side effect, the number of source lines in a program. However, the major benefit of using aspects comes from improving the modularity of a program, not because the program is smaller. Aspects gather into a module concerns that would otherwise be scattered across or duplicated in multiple classes. Does AspectJ add any performance overhead? The issue of performance overhead is an important one. It is also quite subtle, since knowing what to measure is at least as important as knowing how to measure it, and neither is always apparent. There is currently no benchmark suite for AOP languages in general nor for AspectJ in particular. It is probably too early to develop such a suite because AspectJ needs more maturation of the language and the coding styles first. Coding styles really drive the development of the benchmark suites since they suggest what is important to measure. In the absence of a benchmark suite, AspectJ probably has an acceptable performance for everything except non-static advice. Introductions and static advice should have extremely small performance overheads compared to the same functionality implemented by hand. The ajc compiler will use static typing information to only insert those checks that are absolutely necessary. Unless you use 'thisJoinPoint' or 'if', then the only dynamic checks that will be inserted by ajc will be 'instanceof' checks which are generally quite fast. These checks will only be inserted when they can not be inferred from the static type information. If you'd like to measure the performance be sure to write code fragments in AspectJ and compare them to the performance of the corresponding code written without AspectJ. For example, don't compare a method with before/after advice that grabs a lock to just the method. That would be comparing apples and oranges. Also be sure to watch out for JIT effects that come from empty method bodies and the like. Our experience is that they can be quite misleading in understanding what you've measured. I've heard that AspectJ leads to modularity violations. Does it? Well I haven't yet seen a language in which you can't write bad code! But seriously, most AspectJ users find that just like when they learned OO, it takes a while to really get the hang of it. They tend to start in the usual way, by copying canonical examples and experimenting with variations on them. But users also find that rather than being dangerous, AspectJ helps them write code that is more clear and has better encapsulation -- once they understand the kind of modularity AspectJ supports. There are several good papers that talk about this (see below), but here's a basic point to keep in mind: when properly used, AspectJ makes it possible program in a modular way, something that would otherwise be spread throughout the code. Consider the following code, adapted from the AspectJ tutorial: aspect PublicErrorLogging { Log log = new Log(); pointcut publicInterface(Object o): call(public * com.xerox.*.*(..)) && target(o); after(Object o) throwing (Error e): publicInterface(o) { log.write(o, e); } } The effect of this code is to ensure that whenever any public method of an interface or class in the com.xerox package throws an error, that error is logged before being thrown to its caller. Of course in the alternative implementation a large number of methods have a try/catch around their body. The AspectJ implementation of this crosscutting concern is clearly modular, whereas the other implementation is not. As a result, if you want to change it, its easier in the AspectJ implementation. For example, if you also want to pass the name of the method, or its arguments to log.write, you only have to edit one place in the AspectJ code. This is just a short example, but I hope it shows how what happens with AOP and AspectJ is that the usual benefits of modularity are achieved for crosscutting concerns, and that leads to better code, not more dangerous code. One paper someone else just reminded me of that talks some more about this is: http://www.cs.ubc.ca/~kdvolder/Workshops/OOPSLA2001/submissions/12-nordberg.pdf Why does AspectJ permit aspects to access and add members of another type? Isn't that violating OO encapsulation? In the spirit of Smalltalk, we have decided to give more power to the language in order to let the user community experiment and discover what is right. To date this has proven to be a successful strategy because it has permitted the construction of many useful aspects that crosscut the internal state of an object, and as such need access the its private members. However, we are not discounting that some sort of restrictions are useful, rather, we are seeking input from the community in order to decide on what these restrictions should be. In that light, our position on encapsulation is : we respect Java's visibility rules we also provide open-classes, a mature OO technology we provide "privileged" access if you really need it. Introducing parents or members to classes is a well-studied OO technique known as open classes. Open classes have been used in many languages prior to AspectJ, including CLOS, Python, Smalltalk, Objective-C, and others. Building from Java, introduction in AspectJ provides better name hygiene and access control than prior languages. Introduced code obeys all of Java's normal accessibility rules for its lexical location in the aspect that it is introduced from. Such code can not even see, much less access, private members of the class it is introduced into. Further, introductions can be declared private to the aspect, so they are not visible to other clients of the class. Privileged aspects do permit access to private members of another class. They are a response to the very few cases where developers genuinely need such access (typically for testing purposes where it access is necessary), but it would be more risky to open access by putting the aspect in the same package, adding test code, or changing access in the target class. We recommend using privileged aspects only as necessary, and believe that marking them "privileged" makes any potential misuse apparent. Can I use AspectJ with J2EE? Consider the component types in J2EE: Servlet: AspectJ works well within servlets JSP: It is possible to use AspectJ to affect code in JSPs by precompiling them into Java sources and compiling these with ajc. This can be used, e.g., to customize displays by turning on and off custom JSP taglibs. The mapping from a given jsp source to java package and class name is not standardized, which means doing this imposes dependencies on specific container versions. EJB: AspectJ supports a wide variety of aspects for EJBs. It can be used for logging, tracing, debugging, error handling by layers, correlated method-level interception (e.g., chargebacks), metering, fine-grained transactions, etc. Indeed, it can be used to enforce adherence to coding restrictions within an EJB (e.g., not using java.io, creating a class loader, or listening on sockets) using declare error. The basic limitations are that there is no built-in support for writing J2EE analogs for AspectJ extensions to Java, like distributed aspects, distributed cflow, or managing state between invocations. These don't prevent one from using AspectJ to do useful intra-container implementation, nor need they prevent one from building distributed support, state management, and inter-component implementations that leverage AspectJ. It just takes some work. In more detail: All AspectJ implementations may define "code the implementation controls". The AspectJ 1.0 implementation defines this as the files passed to the compiler (AspectJ 1.1 will also support bytecode weaving). Some advice on EJB operations will generate methods that confuse ejb compilers. To avoid this problem, you can use the -XaddSafePrefix flag when compiling with ajc. EJB components may be invoked remotely, and containers may passivate and pool EJB's. Servlets have similar limitations, and in both cases the lifespan of the defining class loader is implementation-dependent (though it must span the operation of a particular request). Being limited by lifecycle and namespace, the AspectJ 1.0 implementation supports aspects that operate through non-remote invocations during the lifetime of the namespace for a particular deployment unit compiled in its entirety by the ajc compiler. This means AspectJ supports common aspects only within a single local runtime namespace (usually implemented as a class loader hierarchy). Further, AspectJ recognizes language-level join points (object initialization, method calls, etc.), not their EJB analogs (ejb find or create methods...). These lead to the following consequences: Issingleton aspects (the default) are limited to the lifetime of the defining class loader, which in some implementations may not span multiple invocations of the same application or EJB component. EJB lifecycles are different from object lifecycles, so perthis and pertarget aspects will make little sense. They do not work in the current implementation, which uses synchronized methods to ensure a correct association in threaded environments (EJB's may not have synchronized methods). Percflow or percflowbelow aspects are restricted to a chain of non-remote invocations. While EJB 2.0 permits declaring an interface local, this information is not available to the AspectJ compiler today. For same reasons as stated above fore perthis, these will not work even in the EJB container. Evaluation of cflow or cflowbelow pointcuts will be valid only with respect to a chain of non-remote invocations. In addition, any AspectJ code should respect EJB operations: The EJB container accesses EJB component fields directly, i.e., in code outside the control of the compiler. There is no join point for these accesses, and hence no way to write a pointcut to advise that access. The EJB container may pool EJB components, so any initialization join points may run once per component constructed, not once per component initialized for purposes of a client call. The EJB container is permitted to change class loaders, even between invocations of a particular EJB component (by passivating and activating with a new class loader). In this case, instances of singleton aspects will not operate over multiple invocations of the component, or that static initialization join point recur for a given class as it is re-loaded. This behavior depends on the container implementation. Can I use AspectJ with Generic Java? At this time, unfortunately not. The two compilers are just not at all compatible. In an ideal world, there would be a wonderful Open Source extensible compiler framework for Java that both GJ and AspectJ would be built on top of, and they would seamlessly interoperate along with all other extensions to Java that you might be interested in, but that's not the case (yet?). However, on 09 October 2000, the Java Community Process approved a proposal to add generic types to Java that is largely based on GJ (JSR 14). A draft specification was submitted for public review, which closed on 01 August 2001, and a prototype implementation has been released. We are committed to moving very rapidly to add support for generic types in AspectJ when generic types become part of the Java language specification. Everyone on the AspectJ team is looking forward to this, because we too would really like to be able to write code that includes both aspects and generic types. Are you working to put AOP into Java? It seems that every AOP toolset currently uses proprietary mechanisms to describe point-cuts, etc. We are working on standardization, but it's a question of timing/ripeness (imagine going from thousands of users to millions). (See .) We believe AspectJ addresses this question in the best way possible now: It's open-source. Rather than being proprietary or controlled by a vendor, it's available for anybody to use and build upon, forever. AspectJ is not a set of mechanisms, it's a language. It is currently implemented using certain techniques, but there's nothing that prevents it from being implemented with other techniques. That means users can adopt the language with confidence that implementations will get better. There is no engineering need to change Java. The AspectJ language uses the join point model already in Java, so there is no need to extend the programming model. Our implementation produces valid Java bytecode, which runs in any compliant J2SE VM and supports standard debuggers for those VM's that support JSR-45 (debugging support for multi-language/multi-file sources). This is a huge benefit to Sun since Sun must be extremely cautious about extensions to the language or VM; before adopting AOP, Sun should demand the kind of actual-proof that AspectJ implementations offer. On the issue of "proprietary mechanisms to describe pointcuts, etc.": Any AOP has to have some language to describe pointcuts and the like ("pointcuts" of course being the AspectJ term). Users would like to have one language (to avoid having to learn or transform between many languages) and the choice of multiple implementations (tailored for a configuration, subject to competitive pressure, etc.). That's what AspectJ offers. That said, we believe the AspectJ extensions to Java could form the basis for bringing AOP to Java; when that happens, there will be engineering opportunities to make the implementation and tool support better. What kind of support is available? The AspectJ users mailing list provides an informal network of AspectJ experts. To subscribe, visit the Mailing Lists page of the AspectJ web site. If you have a problem that is not a bug, you may email the AspectJ team at support@aspectj.org. You may view and submit bug reports and feature requests at http://aspectj.org/bugs. Members of the AspectJ team are available to work with users in more depth on both program design and implementation issues. The team also presents educational courses and speakers for interested groups and offers commercial support and consulting for businesses. Please contact the AspectJ team. with your request. Using the AspectJ compiler What files do I need to include when compiling AspectJ programs? You need to specify to the compiler the source files that contain your aspects and the source files that contain the types affected by your aspects. See . The AspectJ compiler will not search the source path for types that may be affected (unlike Javac and Jikes), and it only uses aspects in source form. In some cases you should compile your entire system all at once. If this is too slow, then you can try to make reasonable divisions between sets of source files whose aspects do not interact to achieve a shorter compile cycle (particularly for development aspects). However, if you get any problems or if you wish to run tests or do a release, you should recompile the entire system. I have to list many files in the command line to compile with ajc. Is there any other way to provide the file names to ajc? Yes, use the argfile option to ajc. List source files in a line-delimited text file and direct ajc to that file using -argfile or @: ajc @sources.lst ajc -argfile sources.lst For more information, see the ajc tool section of the Development Environment Guide . What Java virtual machine (JVM) do I use to run the AspectJ compiler? Use the latest, greatest, fastest JVM you can get your hands on for your platform. The compiler's performance is dependent on the performance of the JVM it is running on, so the faster a JVM you can find to run it on, the shorter your compile times will be. At a minimum you need to use a Java 2 or later JVM to run the compiler. We realize that this constraint can be a problem for users who don't currently have a Java 2 JVM available. We're sorry for the inconvenience, but we had to make the hard decision that the advantages of being able to rely on Java 2 were worth the cost of losing a number of developers who are working on platforms without Java 2 support. Here is a list of starting places where you might find support for your system. Java 2 Platform, Standard Edition developerWorks : J ava technology : Tools and products - Developer kits developerWorks : Open Source - Jikes Project Java Platform Ports The requirement of Java 2 support is only for running the AspectJ compiler. The AspectJ compiler can be used to build programs that will run on Java 1.1 (or probably even on Java 1.0) systems. This means that it can build programs that will run on Macintosh, FreeBSD, and applets that will run in Internet Explorer and Netscape Navigator that are still not yet Java 2 compliant. How can I use ajc to compile programs for a JVM that is different from the one used to run it? ajc can be used to develop programs that are targeted at the Java 1.1 platform, even though the ajc compiler won't run on that platform. Here's an example of using ajc in this sort of cross-compilation mode (assuming a Windows platform with all the default installation directories): ajc -target 1.1 -bootclasspath c:\jdk1.1.7\lib\classes.zip \ -classpath c:\aspectj1.0\lib\aspectjrt.jar -extdirs "" \ -argfile jdk11system.lst This same technique can be used if you want to run ajc on a JDK 1.3 JVM (highly recommended) but need to generate code for JDK 1.2. That would look something like: ajc -bootclasspath c:\jdk1.2\jre\lib\rt.jar \ -classpath c:\aspectj1.0\lib\aspectjrt.jar \ -extdirs c:\jdk1.2\jre\lib\ext -argfile jdk12system.lst Does the ajc compiler support the assert keyword in Java 1.4? Yes. As with Javac, use the -source 1.4 option as described in the ajc tool section of the Development Environment Guide . Are there any issues using AspectJ with the Microsoft JVM? Since AspectJ requires Java 2 or later, it will not run on the Microsoft JVM, which does not support Java 2. Does ajc rely on javac for generating Java bytecode (.class) files? No. Some previous versions of AspectJ had this requirement, and javac can still be used as ajc back end by using the -usejavac flag. You can also run ajc in preprocessor mode to generate Java source (.java) files to be compiled using javac or another java compiler. I noticed the AspectJ compiler doesn't use a parser generator. Why is that? The PARSER for ajc is written by hand. This choice was made with full awareness of the generator tools out there. (Jim had for example used the excellent javacc tool for building the parser for JPython (now Jython)). One of the reasons that AspectJ uses a hand-written parser is that using javacc taught Jim about the LL-k design for parsers (pioneered by antlr). As opposed to the state-machine parsers produced by yacc, these parsers are very readable and writable by humans. Antlr and javacc did not really suit the project: Antlr's support for unicode in the lexer is still immature and this makes using it with Java challenging. This was an even bigger issue 3 years ago when we started on the Java implementation of ajc. While javacc is freely available, it is not Open Source. Depending on a closed-source tool to build an Open Source compiler would reduce some of the transparency and control of open-source. There were also several things that were easier to implement with a hand-written parser than with any of the exiting tools. Semi-keywords -- it's important to us that "every legal Java program is also a legal AspectJ program." This wouldn't be true if we made 'before' and 'call' full keywords in AspectJ. It is easier to support these sorts of semi-keywords with a hand-written parser. (Note: ajc-1.0.x handles 'aspect' and 'pointcut' slightly specially which can break a few unusual pure Java programs. This is a compiler limitation that will be fixed in a future release.) Deprecated syntax warnings -- the syntax of AspectJ changed many times from version 0.2 to the 1.0 release. It was easier to provide helpful warning messages for these changes with our hand-written parser. Grammar modularity -- We like being able to have AspectJParser extend JavaParser. Part of the grammar for AspectJ is extremely hard for existing tools to capture. This is the type pattern syntax, i.e. "com.xerox..*.*(..)". The sort of case that gives standard parser generators fits is something like "*1.f(..)" which no one would ever write, but which must be supported for a consistent language. Integrating AspectJ into your development environment How do I know which aspects affect a class when looking at that class's source code? When you are working with the IDE support, you can get an understanding of which aspects affect any class. This enables AspectJ programmers to get the benefits of modularizing crosscutting concerns while still having immediate access to what aspects affect a class. For example, the Development Environment Guide section on ajbrowser shows that you can list or navigate between method and advice affecting that method and between a type and declarations in an aspect on that type. (The IDE support may have more features than ajbrowser, depending on the IDE.) When you are looking at documentation, ajdoc will provide links from aspects and advice to the affected code, but it provides less information than the IDE support because it only parses declarations. When you are running your program, you can trace advice as it executes. This enables you to identify advice on join points picked out dynamically, which cannot be reflected precisely by IDE support. See for more information on which Java development environments are supported. What kind of IDE support is available for developing AspectJ programs? See I want the aspects for development builds but remove them for production builds. How can I set up the build system so they are unpluggable? And so I use javac in my production build? If you are using development-time-only aspects - aspects that only exist when you are developing the code, not when you ship it - you can use implement a hybrid build process by listing the production source files into a javac-compliant argfile, and the development source files in another ajc argfiles: -- file "production.lst": One.java two/Three.java ... -- file "tracing.lst": trace/Library.java Trace.java -- file "development.lst": @production.lst @tracing.lst Then your development build can use ajc: ajc @development.lst And your development build can use ajc or javac or jikes: jikes @production.lst What plans are there to support my IDE? The AspectJ team directly provides components for JBuilder, Forte, and Emacs. We also support the open-source AspectJ plugin project at http://eclipse.org/ajdt which uses the AJDE API support for IDE's. We are interested in supporting other developers as they use AJDE to provide components for the following IDE's (roughly in order of interest and viability). IDEA/IntelliJ has an enthusiastic community and the developers are working on an extensibility API - http://intellij.com jEdit comes from a very active open-source community. Oracle JDeveloper has an Extension SDK unfamiliar to us. Together extensibility API is too limited VisualCafe may have a difficult extensibility API IBM's VisualAge for Java is to be replaced with Eclipse Some have suggested Codeguide from Omnicore http://www.omnicore.com/ Visual SlickEdit ?? Kawa has been discontinued VIM has been suggested. If you would like to build support for an IDE, contact us so we can help. To contribute or propose new IDE's, please mail us. Can I port AJDE support to my development environment? Yes. The core AJDE API is extensible and the source code is available for download. Start by studying the sources for the existing IDE support. Programming notes and tips Is it possible to change methods by introducing keywords (like synchronized), adding parameters, or changing the "throws" clause? AspectJ does not enable you to change the signature of a method, but you can (by express declaration) work around some limits imposed by the signature. You can convert a checked exception to unchecked using declare soft, privileged aspects have access to private methods, and you can use a percflow aspect to ferry additional state to a callee without changing intervening signatures. For more details, see The AspectJ Programming Guide. In the case of synchronized, we have what we consider a better solution that uses around advice instead of introduction. This solution is described in this thread on the AspectJ users list, with some additional comments . I don't understand what join points exist. How can I see them? Try using an aspect posted to the user's list called TraceJoinPoints.java . For example, you can start logging at a particular method call and see what join points occur after the call and before it returns. What is the difference between call and execution join points? Briefly, there are two interesting times when a constructor or method is run. Those times are when it is called, and when it actually executes. The main difference is that a call join point happens outside of the object (for non-static methods) or class (for static methods and constructors), and that an execution join point happens inside the object or class. This means that the within and withincode pointcuts pick them out differently: A call join point is picked out within the caller, while an execution join point is picked out where it is actually defined. A call join point is the ``outermost'' join point for a particular call. Once a call join point proceeds, then a number of different things happen. For non-static methods, for example, method dispatch happens, which will cause one method execution join point -- perhaps more, if there are super calls. For constructors, the super constructor is called, and fields are initialized, and then various constructor execution join points will occur. A call join point matches only the ``external'' calls of a method or constructor, based on a signature, and it does not pick out calls made with super, or this constructor calls. Here's more detail: Consider method execution in Java as (1) the initial call from this object to some method on the target object with a particular signature; and (2) the execution of the actual code in the particular method dispatched in the target object. The call join point starts with the initial call and ends when control returns to the call (by return or perhaps thrown exception). The execution join point starts with the method body and ends when the body completes (again by return or throwing an exception), so the execution join point always happens within the bounds of the corresponding call join point. You can see this if you use the join-point tracing aspect in TraceJoinPoints.java . as described above. As you would expect, the context differs in advice on pointcuts picking out execution and call join points; for call, this refers to the caller, whereas for execution this refers to the called (executing) object. There are some subtle interactions with other AspectJ semantics. First, the meaning of the signature in the execution() and call() pointcut designators (PCD's) differ: the call type depends upon the type of the reference making the call, while the execution type depends on the enclosing class. Second, you may choose one over another if you cannot bring all your sources within the code the compiler controls (described in the appendix to the Programming Guide). For example, to trace calls into a method from classes which are outside the code the compiler controls at compile time, then using execution() will work while using call()may not. Finally, since super invocations are not considered method calls, to trace super.foo() would require using execution. In most cases you should use the call() pointcut designator unless you have a good reason to use execution() What is the difference between cflow and cflowbelow? Both pick out all the join points in the control flow of the specified join points. They differ only in that the cflowbelow() pointcut designator does not pick out the join points specified, while cflow() does. How do I say that I want the topmost entrypoint in a recursive call? How about the most-recent prior entrypoint? This is best seen by way of example. Given a recursive call to int factorial(int) you can print the arguments for (a) the current and most-recent recursive call or (b) the current and original recursive call: aspect LogFactorial { pointcut f(int i) : call(int factorial(int)) && args(i); // most-recent before(int i, final int j) : f(i) && cflowbelow(f(j)) { System.err.println(i + "-" + j); } // original before(int i, final int j) : f(i) && cflowbelow(cflow(f(j)) && !cflowbelow(f(int))) { System.err.println(i + "@" + j); } } What is the difference between constructor call, constructor execution, initialization, and static initialization join points? Static initialization pertains to initialization of a class or interface type. Constructor call and execution are akin to method call, and initialization generalizes this and picks out the first constructor called. Their relations are best demonstrated by tracing the join points. Below is the class Test which implements an interface and extends a class along with a trace of the join points below and including the constructor call obtained using TraceJointPoints.java (linked above).

]]> Ordinarily, using a call pointcut designator is best because the call join point surrounds the others, but in the case of constructors there is no target object for the call (because it has not been constructed yet), so you might prefer to use the initialization pointcut designator. How do I work with an object right when it is created? You can advise some form of constructor join point. Constructors are tricky in Java, and that's exposed in AspectJ. Here are some rules of thumb: If you want the join point on the "outside" of object creation, use after returning from call to the constructor: after() returning (Foo newlyCreatedObject): call(Foo.new(..)) { ... } You might be tempted to use "this" or "target" to expose the new object, but remember that if you're on the "outside" of object creation, the object itself might not be created yet... it only exists "on the way out", when you return the object. If you want the join point inside a particular constructor, use: after(Foo newlyCreatedObject) returning: this(newlyCreatedObject) && execution(Foo.new(..)) { ... } Remember, though, that if you use "before" advice here, the body of the constructor will not have run, and so the object may be somewhat uninitialized. In the rare case that there are all sorts of constructors for the object that call each other with this(...) and you want exactly one join point for each initialization of Foo, regardless of the path of constructors it takes, then use: after(Foo f) returning: this(f) && initialization(Foo.new(..)) { ... } I want advice to run at two pointcuts, but it doesn't run at all. What gives? This reflects both a conceptual error and a programming mistake. Most likely you want to do something like "run the advice for all public and private calls," and the code looks something like this: within(com.xerox.printing..*) && call(public * *(..)) && call(private * *(..)) A pointcut picks out join points; it is evaluated at each join point. The expression above would never pick out any call join point, because no method signature has both public and private access. In a pointcut, pc1() && pc2() means both must be true at a given join point for advice to run at that join point. The correct pointcut would use || as follows: within(com.xerox.printing..*) && (call(public * *(..)) || call(private * *(..))) Then the advice will run at the join point. How do I refer to a static field when my advice crosscuts multiple classes? There is no way in advice to refer to the type of the code executing in a static context except by specification. This makes it impossible to refer to static members using runtime information. I would like to reuse a type pattern, e.g., to write advice that is limited to a certain set of classes. Do I have to retype it each time? No. You can declare that all the types implement an interface you define, and then use the interface type in your program. For example: /** * Example of using an interface to represent a type pattern. * sub-aspects use declare parents to add to traced types, e.g., * declare parents: com.mycompany.whatever..* implements Marked; */ abstract aspect MarkerExample { /** marker interface for types that we want to trace */ interface Marked {} /** calls to an instance of Marked not from an instance of Marked */ pointcut dynamicCallsIn(): call(* *(..)) && target(Marked) && !this(Marked); /** calls to methods defined by a subtype of Marked * that don't come from the body of a subtype of Marked */ pointcut staticCallsIn(): call(* Marked+.*(..)) && !within(Marked+); /** print dynamic calls */ before(): dynamicCallsIn() { System.out.println("before " + thisJoinPoint); } } aspect MyMarker extends MarkerExample { declare parents: com.mycompany.whatever..* implements Marked; } Where do I find example programs? Some examples are distributed in the documentation release, and you can find other code in the discussions on the users list. Are aspect libraries available? Some libraries are distributed in the release under the examples folder in the distribution. If you develop a library and want to make it available to other users, make sure to contact us . How does ajc interact with the serialVersionUID? The current version of ajc can change the serialVersionUID of generated .class files as a result of weaving in advice. This is an important fact that developers using both aspects and serialization should be aware of. It is likely that a future version of the compiler will be better behaved regarding the serialVersionUID. However, changes to the serialVersionUID attribute are typically only important when using serialization for the long-term persistence of objects. Using standard Java serialization for long-term persistence has a number of drawbacks and many developers already use alternative solutions. For one possibly standard solution, see Lon g-Term Persistence for JavaBeans Specification . How can I use AspectJ with applets? Just include the aspectjrt.jar as a required archive. For example, here is the HTML code for an HTML editor applet that contains some debugging aspects: ]]> The above markup has worked reliably with the Java Plugin (included in the JRE 1.4.x) in IE 6, Mozilla 1.1 (Win32), and Mozilla 1.0.1 (Red Hat Linux 8.0). The following link describes how to configure Mozilla/Netscape 6.x/7.x to use the Java Plugin from a JRE/SDK installation: http://java.sun.com/j2se/1.4.1/manual_install_linux.html. (Thanks to Chris Bartling for this answer.) How can I specify types for advice that captures primitives, void, etc.? In some cases, AspectJ allows conversion from values of primitive types to Object, so that highly polymorphic advice may be written. This works if an advice parameter or the return type for around is typed to Object. So: class Test { static int i; public static void main(String[] args) { i = 37; } } aspect TraceSet { before(Object val): set(* Test.*) && args(val) { System.err.println(val); System.err.println(val.class); } } will print out 37 java.lang.Integer For more information, see the Programming Guide semantics section "Context Exposure" . Common Problems When I run, I get a StackOverflowError (or a long stack trace or no output whatsoever) Most likely this is a case of infinite recursion, where advice is advising itself. It presents as a StackOverflowError or silence as the VM exhausts itself in the recursion. Of course, infinite recursion is possible in Java: public class Main { public static void main(String[] args) { try { main(args); } finally { main(args); } } } If you compile and run this program, and it will fail silently, trying to process the finally clause even after throwing the StackOverflowError. Here's a similar AspectJ program where the recursion is not so obvious: aspect A { after(): call(* *(..)) { System.out.println("after " + thisJoinPoint); } } This re-invokes itself because it advises any call. It invokes itself even after an exception is thrown, since after advice, like a finally clause, runs even after exceptions are thrown. You can fix this by following two practices: (1) Use after returning to advise normal completions or after throwing to advise abrupt completions. If you use after or after throwing, write the advice with the same care you would a finally clause, understanding that it may run after some failure. (2) Avoid writing advice that advises itself. One simple way to do so is to exclude the code within the current aspect: aspect A { after() returning: !within(A) && call(* *(..)) { System.out.println("after " + thisJoinPoint); } } A better way is often to re-write the pointcut. If the advice is advising itself accidentally, that's a sign that the pointcut is not saying what you mean. aspect A { pointcut withinTargetClasses() : within(A+) || within(B+); after() returning: withinTargetClasses() && call(* *(..)) { System.out.println("after " + thisJoinPoint); } } I've declared a field on every class in my package; how do I use it in advice? aspect A { boolean com.xerox..*.dirtyFlag; after (Object target) returning : target(target) && call(* com.xerox..*.set*(..)) { target.dirtyFlag = true; // compile fails here } } You need a type to refer to any member, field or method. It's generally better to introduce onto an interface and declare classes to implement the interface, which permits you to use the interface type in advice formals. aspect A { interface TrackingSets {} boolean TrackingSets.dirtyFlag; declare parents : com.xerox..* implements TrackingSets; after (TrackingSets target) returning : target(target) && call(* com.xerox..*.set*(..)) { target.dirtyFlag = true; } } The AspectJ compiler aborts with an OutOfMemoryError when compiling many classes. How can I fix this? The command ajc is actually a script that launches a Java virtual machine with the correct classpath. You should make a copy of this script, rename it, and then edit it. Change the -Xmx option, size of memory allocation pool (heap). You might try -Xmx128M or even -Xmx256M. ajc recompiles all files every time. How can I make it recompile only the files that have changed? ajc 1.0 does not currently support incremental compilation, but we are working on this for the 1.1 release. As a limited workaround, many build systems enable you to avoid doing a compile if no sources have changed. (See, e.g., Ant's "uptodate" task.) ajc is using the wrong JVM. How do I fix it? The easiest way to fix this is to re-install ajc (using the same .class or .exe file that you originally downloaded) and this time make sure to tell it to use the desired JDK (typically the JDK versions 1.2 or 1.3 from Sun). If you are familiar with DOS batch files or shell programming, you could also fix this by simply editing the bin\ajc.bat or bin/ajc script. My IDE is trying to parse AspectJ files which makes my project unusable. What can I do? When working with an unsupported IDE that objects to the syntax of AspectJ source files (and, e.g., automatically gathers them in a source tree as Java files based on the .java extension), you can use the .aj extension for your AspectJ files. The ajc compiler accepts both .java and .aj files, and you can set up your build scripts to include the correct list of source files. (You will have to find another editor for editing AspectJ files; you can use the ajbrowser to view edit your AspectJ files and navigate the crosscutting structure.) I used to be able to compile my program in my IDE, but when I use AJDE, I run out of memory (or it goes really slow). The ajc compiler does more analysis than (e.g.,) javac, and AJDE may in some IDE's hold a copy of the structure tree until the next tree is available from the compile process. Both mean that you may need extra memory to compile the same program. However, increasing available memory to the point that you are swapping to disk can slow the process considerably. If you are having problems and would like to find the optimal memory allocation, iteratively decrease the amount of memory available until AJDE or ajc signals out-of-memory errors, and then increase that amount by 5-10%. To increase memory for the ajc compiler, see . For your IDE, do something similar or follow the provider's instructions. For example, to increase memory in JBuilder, edit the jbuilderX/bin/jbuilder.config file to have an entry like: vmparam -Xmx384m If it turns out that your project is too big to use with AJDE, your IDE may nonetheless support external commands or Ant build processes, which run outside the IDE memory space. For an Ant taskdef, see . For a JBuilder Ant plugin, some people have directed us to . My stack traces don't make sense. What gives? Unless you are using the ajdb debugger, stack traces may have synthetic methods in the stack, and the line numbers may not track your source code. The Development Environment Guide. discusses how to interpret stack at the end of the section on the ajc compiler. My advice is not running (or running twice), and I don't know why. When advice is not running, it is probably a problem in the pointcut. Sometimes users specify pointcuts that do not mean what they intend - most often when they misspell a type name. Run the compiler in -Xlint mode, which will flag some likely mistakes, like the type name. If that does not work, use TraceJoinPoints.java to see if your join points are executing at all. When advice is running more than it should, it may be that your pointcut picks out more join points than you intend. If you are using IDE support, you should be able to trace back from the pointcut or advice to the join points which can be statically determined to be affected. To identify advised dynamic join points, you can try using TraceJoinPoints.java , but often it is easier to update the advice to print the source location of the join point. This will show if the advice applies to code that you did not consider. If you've done this and convinced yourself it's not working, it may be a bug. See . I declared a member on a class with package access, but other classes in the package cannot see it. When declaring parents on other types from an aspect, package access only applies to code the implementation controls. For AspectJ 1.0, that is the set of files passed to the compiler. That means other classes not compiled with the aspect will not be able to access the aspect-declared members even if they are in the same package. The only way for classes outside the control of the implementation to access aspect-declared members is to declare them public. ajc complains that it can't find javac. What's wrong? ajc does not try to locate javac in your path: it uses the javac classes directly. In JDK 1.2 and 1.3 these classes are found in tools.jar (in the lib directory of the JDK distribution), which must be on your classpath to make ajc work with javac. Inspect the java command that launches ajc to make sure that tools.jar is on the classpath for ajc; the -classpath option only applies to the sources compiled. I'm running under 1.4, but ajdoc asks for 1.3 (or throws IllegalAccessError for HtmlWriter.configuration) The current implementation of ajdoc uses specific javadoc classes in the J2SE 1.3 tools.jar. We are working on addressing this limitation, but in the interim it is best to run ajdoc under 1.3. When running from the command-line scripts, edit the scripts directly to put the 1.3 tools.jar first on the classpath. (The installer does not know about this limitation of ajdoc.) When running from Ant, users often have tools.jar in ${ant.classpath} (to make javac, et al work). That makes it impossible to run the ajdoc taskdef (which does not currently support forking), so you'll need to run a separate ant process, either from the command-line or via Ant's exec task (the Ant task will propagate the classpath). If the wrong tools.jar is not on the ant classpath, then it should work to put the 1.3 tools.jar in the taskdef classpath. I set up different files to my compiles to change what the aspects see, but now I don't understand how the aspects are working. It is a bad practice to use the compilation unit to control crosscutting. Aspects and pointcuts especially should be written to specify crosscutting precisely. Aspects will behave the same when you add files if you initially included all files affected by your aspects. If you use the compilation unit, then your code will behave differently in AspectJ implementations that do not limit themselves to specified files. I'm reading the code generated by ajc in -preprocess mode, and it seems like it would not work (or "like it works this way"). The generated code can be difficult for a human to read and understand. The compiler uses implementation techniques which might not be apparent. To determine if the code is behaving correctly, you should write and run a program that attempts to provoke the error you suspect. Similarly, you should not rely on invariants you infer from the generated code (especially naming conventions for generated members). Please rely only on the semantics stated in the appendix of the AspectJ Programming Guide. I've heard AspectJ can generate or inject code into my code. Is this true? This is a misconception spawned from the early implementation. AspectJ does not "inject" or "generate" code. In AspectJ the pointcut constructs allow the programmer to identify join points, and the advice constructs define additional code to run at those join points. So the semantic model of advice is like the semantic model of a method -- it says "when any of these things happen, do this". People who worked with earlier versions of AspectJ, in which ajc was very explicitly a pre-processor, sometimes thought of AspectJ as injecting code. But that was an artifact of the implementation, not the underlying language semantics. This distinction is important for two reasons. One is that thinking about it this way will make more sense at the implementation continues to evolve towards load-time or runtime weaving. The other is that it makes it much easier to understand the semantics of advice on cflow pointcuts. What are the bugs now most affecting users? 813 - Ajdoc requires J2SE 1.3 tools.jar, not that of 1.2 or 1.4. Getting Help How do I find out more about AspectJ? Visit the AspectJ project web site: http://aspectj.org. How do I submit a bug report? You can submit a bug using the web interface http://aspectj.org/bugs (preferred), or you may send email to jitterbug@aspectj.org directly. See also If it seems to be a bug in the compiler, please include in the body of the email source code to reproduce the problem. How do I submit comments and feature requests? You can email comments to all users at users@aspectj.org, email the AspectJ team at support@aspectj.org. You can view and submit bug reports and feature requests at http://aspectj.org/bugs. If you think you might simply be making a mistake, you might email some source code to users@aspectj.org. How do I communicate with other AspectJ users? You can reach other AspectJ users by using the aspectj-users mailing list. To subscribe to the list or view the list archives go to the user community page: http://aspectj.org/lists . How can I search the email archives or the web site? There is a search entry box on the left navigation bar of the web site, but it is generally more effective to do a google search of the form, http://www.google.com/search?q=site%3Aaspectj.org+%22abstract pointcuts%22 How should I write email queries? Here's the big picture of what I'm trying to do... Here's what I think it takes, in AspectJ terms (concepts, syntax, and semantics) from the Programming Guide... Here's the AspectJ code I'm using, the output it produces when run, and what I expect... The big picture helps others redirect you to other approaches. Using AspectJ terms helps others correct mistakes in thinking about the problem (the most common being to confuse join points and pointcuts). The code is key to clarifying your question and getting a good response. On the mail list, someone can reply by fixing your code. In bugs, the developers can reproduce the problem immediately and start analyzing the fix. For the mail lists, we try to follow the conventions for open-source discussions that help avoid "the tragedy of the commons." For example conventions, see http://jakarta.apache.org/site/mail.html and http://www.tuxedo.org/%7Eesr/faqs/smart-questions.html . How do I write bugs for IDE support? Bugs appearing in the IDE's may apply to the affected IDE or to the compiler. Compiler stack traces in IDE message windows are prefixed "Internal Compiler Error" and should be written up as compiler bugs. If you are unsure, try redoing the compile from the command line. Bug reports for the Eclipse support go to the Eclipse bugzilla database. Bug reports on other IDE support should have version information for both Java and the IDE, and (most importantly) clear steps for reproducing the bug. You may submit the bugs via the web form (http://aspectj.org/bugs) or via email (jitterbug@aspectj.org). One of the benefits of open-source is that you can find and fix the bug for yourself; when you submit the fix back to us, we can validate the fix for you and incorporate it into the next release. Email support@aspectj.org for instructions on submitting a patch. How do I write bugs for the AspectJ compiler? The best compiler bug report is a reproducible test case, standalone code that demonstrates the problem. Sometimes with aspects, a test case requires several files, if not some way to capture the behavior. Here's how we recommend submitting test cases: Write the test case so that when the compiler bug is fixed, the test completes normally without output (e.g., expected compiler errors are issued, or classes produced run correctly). This usually means writing one or more source files. In the bug report, briefly summarize the bug. If it is not obvious, be sure to specify the expected output/behavior (e.g., compiler error on line 32) and, if the compile should complete, the main class to run. At the end of the report, append each source file, separated with a line and the file name. (Include all sources, and do not send attachments.) Submit the bugs via the web form (http://aspectj.org/bugs) or via email (jitterbug@aspectj.org). Can you recommend reading or teaching material for AspectJ? The documentation available on this site is a primary source of material on AspectJ: Selected AspectJ Papers and Presentations Papers presented at various conferences; tutorial slide presentations. Aspect-Oriented Programming The seminal AOP/AspectJ paper The AspectJ Programming Guide A practical guide for programmers. Includes a number of examples, some quite sophisticated. The AspectJ Tutorial Slides from a day-long tutorial presentation on AspectJ. Where can our group get consulting and support? Beyond what's available on the aspectj.org web site, the AspectJ team does a limited amount of consulting and support for qualified groups. For more information, see . What has changed since the last FAQ version? Entries changed since the earlier November 26 version: About the AspectJ Project What does the fact that AspectJ is an Open Source Project mean to me? Open source protects your interest in a correct, long-lived, up-to-date, and widely-accepted implementation of AspectJ. With the source code, you control your own destiny in perpetuity. You can continue to use the implementation and update it as necessary to fix bugs and add things you need. Because the code is available to all, anyone can find and fix bugs. There is no need to hope for it to be fixed in the next product release. Those who encounter the bugs are motivated to fix them, and there are more eyeballs on the code than in closed-source, so the quality tends to be high. This can be particularly true for the AspectJ community, which tends to be highly skilled. The same is true of new features or behavior, so the implementation should be up-to-date. This is important as the field of AOP develops, to capture the latest solutions. For a programming language which forms the basis of an entire solution stack, open source facilitates the kind of adoption -- tool integrations and significant projects -- that develop and prove the technology for wider adoption. This limits delays caused by waiting for the completion of standards process or promulgation by industry leaders, and also provides the proofs necessary for such adoption. What are your plans to make AspectJ a general feature of Java supported by Sun and the other key players in the Java Industry? Although we are committed to making AspectJ available to a wide range of users, it is too early to decide on a strategy. Some options include continuing AspectJ as a stand-alone product, integrating it into IDEs, or possibly incorporating it into standard Java with Sun's blessing. We currently focus on developing for the 1.1 implementation which improves AspectJ in key areas: rapid incremental compilation, bytecode weaving, and IDE integration. Through all of this our goal is to make AspectJ integrate as seamlessly as possible with the Java programming language. The AspectJ language design is becoming more integrated, the compiler is becoming faster and more integrated, the IDE extensions are becoming more integrated. All of this is designed to help users really use AspectJ and give us feedback on it. As the system is improved and we work more closely with users, we will be in good position to explore the best path for AspectJ in the long term. When will AspectJ work from class files? When will it work at class-loading time? Bytecode weaving is scheduled for AspectJ 1.1. We believe it will work as described in an email to the users list by Jim Hugugin: The AspectJ language was designed to support weaving at many different times: compile, load, or even run-time in the JVM. Weaving into bytecodes at both compile and load-time will definitely be provided in a future release. This will allow weaving at compile-time into libraries for which source code is not available. It will also support aspect-aware class loaders that can perform weaving at load time on arbitrary classes. One advantage of a language like AspectJ, rather than an explicit meta-tool like jiapi, is that it separates the specification of a crosscutting concern from any particular implementation strategy for weaving. ...AspectJ provides a language that can cleanly capture crosscutting concerns while preserving the static type checking, modularity, and composability of Java. If you have an application for using aspects and bytecode, please let the AspectJ team know of your requirements. What are the differences between the current and previously released versions of AspectJ? The AspectJ team aims to keep the implementation up-to-date and bug-free, but to limit language changes to those that are carefully considered, compelling, and backwards-compatible, and to deliver those language changes only in significant releases (1.0, 1.1). Version Description AspectJ 1.0 Many language changes, fixes, cleanup and clarifications, some significant. AspectJ 0.8 More cleanup of the syntax and semantics. AspectJ 0.7 Clean up of the semantics, 0.7 beta 4 is the first open source release. AspectJ 0.6 Advice and crosscuts get explicit type signatures which describe the values that are available to advice at a crosscut. AspectJ 0.5 Improved tool support: better Emacs environment support and ajdoc to parallel javadoc. around advice is added, and the aspect keyword is removed and replaced by the Java keyword class. AspectJ 0.4 Clear separation of crosscuts and crosscut actions makes it possible to define extensible library aspects. AspectJ 0.3 First all Java implementation, also includes many small language improvements. AspectJ 0.2 General-purpose support for crosscutting. Users could program any kind of aspects, not just coordination. This release dropped COOL. AspectJ 0.1 A single domain-specific aspect language, called COOL, for programming coordination in multi-threaded programs.

More detailed comments are available in the doc/changes.html file in the distribution. What is the AspectJ development schedule? The AspectJ Development Schedule Version Description 1.0 Final syntax and semantic changes. Standalone structure browser. Complete documentation. 1.1 Faster incremental compilation, bytecode weaving, and a small number of language changes. 2.0 New, dynamic crosscuts (bytecode-only)

AspectJ is a registered trademark of Palo Alto Research Center, Incorporated (PARC). Java and all Java-based marks are trademarks or registered trademarks of Sun Microsystems, Inc. in the United States and other countries. All other trademarks are the property of their respective owners.