Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revisionPrevious revision
Next revision		Previous revision
research:software:aspectmaps [2011/03/11 15:11] – jfabryresearch:software:aspectmaps [2013/09/04 22:16] (current) – jfabry
Line 1: Line 1:
 +~~NOTOC~~
 +
 +----
 +
 +>>  AspectMaps pages navigation: **--- Introduction ---  [[aspectmaps_documentation|Documentation]] ---  [[aspectmaps_downloads|Downloads]] ---**
 +
 +----
 +>> **---NEWS---** AspectMaps V2 is a port to Moose 4.8 and Roassal, and downloadable from SmalltalkHub. Go to the [[aspectmaps_downloads|Downloads]] page to get it, play with the examples, and start visualizing **your** Java + AspectJ software! 
 +
 +<html>
 +<center>
 +<iframe width="630" height="472" src="//www.youtube.com/embed/uOmox7NgRAg" frameborder="0" allowfullscreen></iframe>
 +</center>
 +</html>
 +
 +The implicit invocation mechanism of AOP introduces an additional layer of
 +complexity in the construction of a system. This can make it harder to
 +understand how base system and aspects interact and thus how the
 +system will behave. For example, when writing
 +pointcut definitions, it is not always clear for a developer where the
 +aspect will intervene in the base code.  This can then lead to
 +situations where the pointcut either captures too many join points
 +(false positives), or where certain join points that were intended to
 +be captured, are not (false negatives).  One variant of this problem
 +is the so-called [[http://www.springerlink.com/content/r3580x542u31022m/|fragile pointcut problem]].
 +
 +AspectMaps is a software visualization tool built
 +to aid the understanding of aspect-oriented software systems. It provides a scalable visualization
 +of implicit invocation. AspectMaps visualizes selected join point
 +shadows (a.k.a. shadow points): locations in the source code that at
 +run-time produce a join point. AspectMaps visualizes the shadow points
 +where an aspect will execute, and if multiple aspects will execute,
 +the order in which they are specified to run. This results in a
 +visualization that clearly shows how aspects cross-cut the base code,
 +as well as how they interact at each join point. AspectMaps is a
 +scalable visualization mainly due to its use of selective structural
 +zooming. The structure of source code is shown at different levels of
 +granularity, as specified by the user.
 +
 + **Screenshot**
 +
 +Below we show the SpaceWar example (that is part of [[http://www.eclipse.org/ajdt/|AJDT]]), fully zoomed in on all join point shadows except for the dark blue Debug aspect.
 +  * An element is colored with the color of the aspect that applies in the element, or the color that indicates multiple aspects apply.
 +  * Zooming in on a package reveals the classes and aspects contained in that package, using a [[http://portal.acm.org/citation.cfm?id=942788|Polymetric Views]]-like visualisation.
 +  * Zooming in on a class reveals the list of instance variables and methods. These are drawn as diamonds and squares, respectively.
 +  * Zooming in on a method visualizes the shadow points where an aspect will execute, painting colored rectangles for each aspect execution. Visualization of these shadow points follows the template below.
 +
 +{{ :research:software:amshadowtemplate.png |Template of visualization of shadow points.}}
 +
 +For a quick comparison between visualizations, below we show both the AspectMaps as well as the [[http://www.eclipse.org/ajdt/|AJDT]] visualization of the same example.
 +
 +{{:research:software:spacewar-aspectmaps.png?800|}}
 +{{:research:software:spacewar-ajdt.png?800|}}