Livedoc seamlessly integrates source-code statistics provided by Code Recommenders into the HTML output of Javadoc via a new Doclet and several Providers using the headless API of Code Recommenders 2.0 in an OSGi environment.

Additionally, integration with online services like bugtrackers or mailing lists is planned.


The Livedoc plugin (respectively the standalone command-line application) is an incubator project developed as part of the Google Summer of Code. Note that it clearly has some rough edges. It’s not production ready yet.

Latest Online Demo

Sample output of Livedoc can be viewed here:

Disclaimer: The online demo may include third party providers that do not come with Livedoc.

Release Planning

Version Release Date Features



"Call Also" Provider, Recursive subpackages



New Provider API, Package Summary View, "Method Self Call" Provider



"Class Self Call" Provider, Better model resolution, Debug mode



Diff. source/model artifact coordinates, Google Analytics Provider


2014-07-09 (←- Current)

JDK 8 Compatibility, DocLint of JDK 8 Javadoc


(August 2014)

Interconnected web of Javadoc documentation for different APIs

System requirements

Livedoc needs a Java 8 JDK installed and is not compatible to prior versions of Java.

Since the release of version 0.11, Livedoc is Java 8 compatible and makes use of the extended JDK 8 Javadoc API. This allows us to support the DocLint feature of Javadoc (see below) and clears the way for multiple Javadoc runs on whole source repositories with just one command line call. Furthermore, JDK 8 Javadoc fixes some bugs, which were sometimes critical to Javadoc runs.

However, since we cannot afford a simultaneous release plan, Javadoc is not compatible with JDK 7 any more, thus you need an installed JDK 8 (and not just a JRE!) to use Livedoc.


Livedoc comes as an Eclipse product and can be downloaded from milestones product download site.

Usage Guide

For a quick start, here is an out-of-the-box working command line for Livedoc:

./livedoc org.eclipse.jgit:org.eclipse.jgit: -d ./output -highlight

Livedoc will start generating Javadoc for the org.eclipse.jgit package with annotated Code Recommenders statistics, stored in the folder ./output.

This is possible because the org.eclipse.jgit coordinate above is both legal in the Maven Central repository ( as well as in the Code Recommenders model repository (

For a usage synopsis, just run ./livedoc without any parameters.

In Detail

Livedoc requires three inputs from you:

  1. A Maven repository for source files (packaging: jar, classifier: sources)

  2. A Maven repository for Code Recommenders models

  3. An artifact coordinate identifying the JAR file you wish to create Livedoc documentation for

Source Repository

The sources JAR files need to be available in a maven. This repository can reside locally on your harddisk or remotely, for instance on a Nexus repository.

A basic testing repository is available from Codetrails. It provides a source code repository with some artifacts from Eclipse projects for testing purposes (you can look up the contents with your internet browser):

If you wish to use a local repository, you can deploy existing JAR files using the mvn deploy command. For example, to deploy your JRE jar to a local Maven repository, just grab your JRE’s source archive ( in your JDK installation folder for Oracle JDKs) and type the following (for Java version 1.7):

mvn deploy:deploy-file -Durl=file:/some/folder/repo -DgroupId=jre -DartifactId=jre -Dversion=1.7.0 -Dpackaging=jar -Dclassifier=sources

After that, you can use /some/folder/repo as your source code repository for Livedoc (on JRE runs).

Model Repository

The location of the Eclipse Code Recommenders models (for Eclipse Luna) is

For a list of all available Eclipse releases, go to and click on Show Directory Contents.

If you want to livedoc your own source code, you’ll have to mine models for it first. Take a look at for further information.

Artifact Coordinate

Livedoc uses the maven artifact coordinate notation:


You can get the GROUP_ID and ARTIFACT_ID from your Maven repository. Note that on VERSION, you’ll have to always provide the ‘full’ version (x.y.z), e.g. for JRE 1.7 its 1.7.0.

Command line

Putting these informations together, the Livedoc command line has the following syntax:

./livedoc GROUP_ID:ARTIFACT_ID:VERSION [-sr URL] [-mr URL ...] [-Xdoclint (all|none|[-]<group>) ...] [-Xresume] [-d DIRECTORY] [-debugging] [-encoding ENCODING] [-highlight] [-jar] [-mc GROUP_ID:ARTIFACT_ID:VERSION] [-noDependencies] [-p PROVIDER_ID [PROVIDER_ARGUMENTS] ...] [-splitIndex] [-subpackages "org.eclipse org.apache ..."] [-transitive] [-u URL] [-verbose]

with the following options:

Parameter Description


The Maven coordinate of the source artifact for which you want to generate Javadoc.

-sr URL

Maven repository containing sources JAR.
Defaults to

-mr URL

Maven repositories containing Code Recommenders models.
Defaults to


Choose Livedoc Providers and configure filter thresholds for recommendations, each Provider respectively.


Optional Maven coordinate for the model artifact used to enhance the Javadoc.
If not set, the source coordinate is used for the model.

-u URL

Maven repository to upload Javadoc JAR to


Destination directory for the Javadoc HTML output files


Debug output messages, includes full stack traces

-encoding ENCODING

Overwrite auto-guessed encoding of source files


Shall Livedoc highlight its output with a yellow background?


Want to have a zipped JAR output for Javadoc?
Warning: Requires -d <DIRECTORY>


Disable download of additional classpath entries via direct maven dependencies


Splits the index file into multiple files, alphabetically, one file per letter, plus a file for any index entries that start with non-alphabetical symbols.

-subpackages "org.eclipse org.apache …"

A list of packages to Javadoc (full recursively), otherwise all found packages in the maven coordinate will be used.


Shall Livedoc try to also resolve transitive dependencies instead of only direct ones?


Output messages about what Livedoc is doing

-Xdoclint (all|none|[-]<group>)

Enable or disable specific checks for problems in javadoc comments, where <group> is one of the following:
accessibility, html, missing, reference, or syntax.


Fast mode, no unpacking, no temp directory cleaning
WARNING: For testing purposes only.


Livedoc comes with five Providers (more coming soon!), which enhance the HTML output with several code statistics:

Name Id Description

Method Overrides


Methods frequently overridden by subclasses

Method Override Patterns


Groups of methods which are frequently overriden together

"Call Also"


Subsequent method calls

Method "Self Calls"


Methods called frequently by implementors of a method (from subclasses)

Class "Self Calls"


Methods called frequently by subclasses

Google Analytics Provider


Adds Google Analytics to your Javadoc web page

You can decide which Providers you want to use with the -p flag, e.g. with

./livedoc org.eclipse.jface:org.eclipse.jface:3.8.102 -p ovrm -p selfm

only the Providers Method Overrides and Method "Self Calls" are being used. If you want to simply use all available Providers (dependent on the plug-ins loaded), you can also skip the flag

./livedoc org.eclipse.jface:org.eclipse.jface:3.8.102

and all Providers will be used, except for the Google Analytics Provider, which is a special case: This Provider will add the necessary Javascript Code for the Google Analytics API to your web page, including your own Tracking-ID. (see also: "Provider Configuration")

The following code statistic Providers are currently available:

Method Overrides

The Method Overrides Provider shows recommendations for methods which are frequently overridden by subclasses of a Class:

ovrm jface dialog

Method Override Patterns

The Method Override Patterns Provider shows recommendations for groups of methods which are frequently overridden together by subclasses of a Class:

ovrp jface dialog

"Call Also"

The "Call Also" Provider shows recommendations of the form "People who called Foo also called Bar":

callAlso jface dialog

Method "Self Calls"

Method "Self Calls" are calls to methods which are made frequently by implementors of a super method:

selfm jface dialog

Class "Self Calls"

Class "Self Calls" are methods called frequently by subclasses:

selfc jface dialog

Provider Configuration

Regardless of whether you’re using all providers or just one, you may want to filter their output. Otherwise you may end with hundreds of recommendations for a class, but with extremly low percentage values. Additionally, some Providers may need additional arguments to fit your special needs. For this, each Provider can be configured on its own, using command-line arguments.

Let’s start with filtering the output:

Livedoc provides three thresholds for this, configurable for each provider:

Threshold Flag Description ovrm ovrp call-also selfm selfc



Show only the top N recommendations






Times observed


Show only recommendations with N or more times observed






Show only recommendations with N or more percent





However, not every threshold can be used with every Provider, only the ones with "X" marked in the table above. Using a threshold with an unsupported Provider won’t have any consequences to filtering.

To specify a threshold for a Provider, you’ll have to pass it as a Provider option, this happens with square brackets, following the syntax -p PROVIDER_ID [-FLAG VALUE], e.g.

./livedoc org.eclipse.jface:org.eclipse.jface:3.8.102 -p ovrm [-percent 15] -p ovrp [-top 5]

Now, only method override recommendations with 10% or more will be shown, plus the top 5 method override patterns.

Additional Provider Arguments:

The three thresholds for filtering are optional, Providers can also work without these filter values. However, there are Providers which need additional arguments to work, thus they won’t be loaded if these arguments aren’t present.

An example (and currently the only one) for this is the Google Analytics Provider. With this Provider, you can let Livedoc easily insert the Tracking-Code for Google Analytics into your Javadoc HTML code.

To achieve this, you will have to provide your Google Analytics ID as an Argument:

./livedoc org.eclipse.jface:org.eclipse.jface:3.8.102 -p analytics [ANALYTICS_TRACKING_ID]

If you select the Google Analytics Provider (with "-p analytics"), but don’t provide an ID, the following error will be printed:

15:22:47.865 [main] ERROR o.e.r.i.l.javadoc.RecommendersTaglet - Provider "AnalyticsProvider" couldn’t be set up, skipping it.
    Message: org.kohsuke.args4j.CmdLineException: Argument "WEB_PROPERTY_ID" is required
    Exception: org.eclipse.recommenders.livedoc.providers.LiveDocProviderException

and the Provider won’t be loaded!

DocLint feature support

Livedoc supports the new DocLint feature of JDK 8 Javadoc. However, a slight syntax modification to the original Javadoc -Xdoclint is needed to configure the option in Livedoc:

./livedoc ... [-Xdoclint (all|none|[-]<group>) ...]

E.g., with

./livedoc ... -Xdoclint all -Xdoclint -accessibility

you would enable all groups of checks except the accessibility checks. For a reference of the group checks, see the JDK 8 Javadoc Documentation:

NOTE: The DocLint feature in Livedoc is an opt-in instead of an opt-out like in original JDK 8 Javadoc. Meaning by default, the -Xdoclint option is disabled and no type of group checks will be made. See also this blog post by Stephen Colebourne why we made this decision.

Direct and transitive dependency resolution

Let’s take a look at this Livedoc command line:

./livedoc org.eclipse.jface:org.eclipse.jface:3.8.102 -sr -mr -d ./output -highlight

Livedoc can handle the org.eclipse.jface package, however it has one problem: During the Livedoc run, you’ll see command line outputs like the following:

error: package org.eclipse.swt.widgets does not exist
import org.eclipse.swt.widgets.Control;
4396 warnings

This means that the artifact org.eclipse.jface:org.eclipse.jface:3.8.102 has dependencies on the package org.eclipse.swt.widgets. Without these dependencies, Javadoc won’t be able to use fully qualified names for these Classes and thus, Livedoc can’t include Code Recommenders statistics for them.

Livedoc tries to resolve (download) these dependencies from your source code repository using the source artifact’s meta information. However, Livedoc will only try to resolve direct dependencies. Transitive dependencies won’t be resolved by default, as this could take some time (and bandwidth). You can force Livedoc to resolve transitive dependencies using the -transitive flag:

./livedoc org.eclipse.jface:org.eclipse.jface:3.8.102 -sr -mr -d ./output -highlight -transitive

The result will be less warnings , fully qualified names in the HTML output and more statistics from Code Recommenders! Of course, Livedoc can only use dependencies which are included in your source code repository.