Featureous is a tool for feature-centric analysis of Java software. The need for such a tool comes from the scattering and implicitness of implementations of user-observable behaviors of software (features) in the vast majority of object-oriented programs. Scattering and implicitness of features in code means that it becomes more difficult to find and understand only the relevant fragments of code when fixing a bug/modifying a feature/implementing new feature by reusing existing code.Featureous aims at improving this situation by providing a means of analyzing and modifying object-oriented programs in a feature-wise, rather than structure-wise, fashion.

Featureous provides a number of visualizations (feature-centric views) that facilitate feature-centric analysis of programs. The metrics, graphs and charts encompassed by the views are being generated from so-called "feature traces". Feature traces can be generated for an arbitrary program by means of tracign its execution.
The feature-location mechanism use in Featureous employs dynamic analysis to discover the traceability links between features and their corresponding classes, objects and methods. After a programmer recovers a list of a program’s features from its documentation, or its graphical interface, she has to annotate each feature's "entry points" a program's source code. Feature entry points are the methods through which a program’s control flow enters implementations of a feature. Annotated program is then transparently instrumented with a tracing aspect when a programmer executes "Trace project" action provided by Featureous. After a user triggers features in the interface of an instrumented program, the information is saved in form of feature-traces, which serve as an input to further analysis.

Featureous is verified to be compatible with the following versions of the NetBeans Platform: 6.9.1, 7.0Beta.

Follow the instructions on the Download page.

Please consult the Contact page.

Yes, you can. However, we would greatly appreciate if in return you filled in the feedback questionnaire included with the tool.

The set of features of a program depends how you want to look at the functionality of a program. The way we used to do that in some papers was to have features like (assuming that we are dealing with emulator software): "emulator startup", "exit emulator", "open game", "close game", "setup controls", "soft reset", "hard reset", "choose region", "choose tv type", "show/hide fps", etc. Depending on the granularity you need, you can group some of the features together, e.g. "open game" + "close game" together could become "game management". More details on the methodology behind this can be found here: http://dx.doi.org/10.1016/j.scico.2010.10.007.

A good heuristic for starting to place the feature entry point annotations is to find the action listeners that get invoked when you activate a feature of your program by click a button somewhere in the main menu or press a key on keyboard. When this is not enough, i.e. if some features get triggered somewhere else than GUI (e.g. some special emulation features like maybe "render fonts"), you would have to go deeper in the code to identify the right places.
When you have identified a feature-entry-point method, you need to annotate it with @FeatureEntryPoint annotation parameterized with string-based identifier of a corresponding feature. The JAR file that you can use to import the annotation from will get created for you in your project's directory the first time you run the "Trace project" action.
For a step-by-step tutorial on how to do all this you can visit the Demo section of this website.

Assumming that you have already annotated all relevant feature entry points, all you need to do is to execute "Trace project" and interact with your program in order to trigger its features. Alternatively, you can also write feature-triggering JUnit test cases and use the "Test-trace project" action to execute your tests on an instrumented program.

In the main menu of the NetBeans IDE, go to [Window->Other->Show Featureous].

You can consult the Features section of this webpage or read some of the papers in the Publication section.

What you need to do is to create a new Module Suite in NetBeans IDE. To the dependcies of this suite you'll need to add the cluster of JAR files (directory containing JAR files) that gets created by NetBeans when you install Featureous. The JAR files will be typically found somewhere in your user directory. After you have done this, you can start making your modules dependent on Featureous and using the provided API. A small demo on this can be found in the Demo section of this website.

Please check if you are using a supported version of the NetBeans IDE.

The problem is in the OpenGL JOGL/GLU binaries for your platform. This happens, because the view uses OpenGL to create a 3D diagram, which makes the view platform-dependent. We have included OpenGL binaries for Windows, MacOS and Linux but we have not tested all of them yet. If you can point us to binaries that work correctly for JOGL in your OS, we will gladly include them in Featureous.

There is a difference between how the correspondence between the text and the GUI is calculated in 6.9.1 and in 7.0 Beta2. Our goal is to stay compatible only with the latest release of the IDE (in this case 7.0).