improved javadoc with powerful searching. Jude makes it very easy to browse and navigate Java documentation and to quickly find the documentation you want. It's written by David Flanagan and uses the same concise quick-reference format as his best-selling Java in a Nutshell books.
Competitors == loosely defined as tools that
[are advertised to] help you quickly
understand and navigate Java source code.
The list below includes tools that offer support for this even if they have
a different focus (full-blown IDE, metrics, coverage, editor, documentation generation,
support for multiple languages, etc). If you know of a tool that
should have been mentioned or if you would like to contribute a review,
please let us know.
Biased evaluation: Needless to say - as good as some of these tools are - no competitor
makes understanding, finding, reusing and reading Java source code as convenient and
fast as Juliet :) And no competitor seems to be designed specifically for daily, un-intrusive
use alongside existing tools.
It's opensource, supports several languages in addition to Java, includes an editor etc.
Source Insight "Project oriented program
editor with built-in analysis for C/C++, and Java programs". [Very nice!]
IBM's opensource eclipse project includes
a [nice] Java IDE (JDT subproject),
which allows precise searches like find declarations of and/or references to packages, types, methods, and fields.
IntelliJ IDEA is a Java IDE with refactoring support,
lets you do various usage searches.
Creole (eclipse plug-in for SHriMP),
Power Software's Visualize it,
Your evaluation: The best thing to do when evaluating Juliet and competitors is of course to download
them and try them out on your codebase. Some evaluation criteriae might be:
- Ease and convenience of use: how steep is the learning curve, does the
tool require training, how much work needs
to be done to get going (do you need to discover and specify
the classpath yourself or does the tool derive it for you), can the
tool handle source code in zip files, etc.
- Does the tool require .class files or work from .java files? If it
works from .java files, does it ignore all files with syntax errors or
can it recover gracefully?
- Is it important that the tool supports a changing codebase, or is
it ok if it spends (more) time analyzing a code snapshot and producing an intermediate representation,
to then provide (faster) analysis over that derived representation only?
- How fast is the tool, and how well does it scale?
- How lightweight is it? Can it easily be used by single developers as an adjunct
to existing tools?
- Information visualization: How concisely does the tool represent information? Does it
support multiple views for side by side comparison? Does it provide
filtering? In a nutshell, does it let you quickly see and grasp what you need?
- Does the tool treat source code as a first class citizen? Can you browse it? Is it
important that the tool also has a built-in editor?