Juliet enables developers to quickly get into any Java system and
- effortlessy navigate, read and browse through it
- instantly understand how and where parts of the system interact
with the rest of the system because Juliet automatically provides the
needed information while browsing [Who writes to this field? Who calls this method?]
- get answers to complex questions such as:
Do all types which override Object.hashCode() also override Object.equals()?
- find code patterns, for example: empty catch blocks, ie catch blocks
which contain nothing but comments, whitespace or empty statements
- perform fast indexed searches for comments and string literals.
Automatic queries while browsing— While you browse through code as if it were hyperlinked, Juliet automatically shows where and how the jumped-to declaration is used.
Screenshot above: pressing the left mouse button down over a link which points to the AWTEvent class starts a drag. It's dropped over a Juliet window: this instructs Juliet to open a new page on which you can get various information about the dropped entities [here: about AWTEvent]. By default, Juliet shows 1. Who references [AWTEvent]? and 2. the declaration of AWTEvent.
If instead you want some other information about AWTEvent, simply click and select one of the available queries - the screenshot below shows how to get AWTEvent's Supertypes & Subtypes:
Powerful queries— The simple paradigm described above - dropping a set of one or more Java entities over a window to get information about the entities in that set - is powerful enough to construct interesting queries because the results of one query (for example above, the results of asking for AWTEvent's subtypes) is itself a set (above: of 25 direct and indirect subtypes of AWTEvent) which can be dropped over any Juliet window to get information on, for example: Where are the 25 subtypes of AWTEvent instantiated?
Typographic effects— Juliet recognizes the most frequently used html tags in javadoc comments and beautifies them. In addition, every block and comments can be exploded/collapsed to help focus on only important bits. The most useful feature however are the little symbols which Juliet inserts before declaring identifiers to indicate how they are used [see below].
Usage info at a glance— Code is visualized with little symbols before declaring identifiers which indicate how, where (and if) declarations are used. For each method, they also show if it overrides or is overridden, and for each type you can see if it has subtypes. And by simply moving the mouse over a declaration a popup shows more usage statistics.
Full info while browsing— While you browse through code by clicking over identifiers (or links in javadoc comments), Juliet automatically shows where and how the jumped-to declaration is used (see above).
Automatic sourcepath deduction— Simply select the directories or archives under which to recursively look for source code and leave the details to Juliet: you may not know the exact sourcepath (if you need to quickly look into a client's codebase), and even if you do you probably want to save time! Screenshot: point Juliet at the latest netbeans development build and watch it deduce well over 100 sourcepath entries - which you would need to manually add with other tools!
Archive support— Source code can be located in directories or in (compressed or uncompressed) archives (zip/jar/war/ear). Juliet's intelligent file-system browser even lets you browse into archives as if they were normal directories to sub-select specific entries in them.
Automatic project management— Switching between different codebases couldn't be easier: Juliet automatically remembers which locations you selected when you specified each codebase and assigns names to them - all you have to do is select the right name.
Support for incomplete codebases— The source code in your codebase can be erroneous or imcomplete (it need not compile): Juliet uses advanced error correction to understand as much of each file as possible, instead of simply ignoring erroneous files. Incomplete codebases are the norm if you use Juliet while you code, or for reviews of unfinished code - proper support for them is essential!.
Codebase snapshots— Juliet takes a snapshot of all the files in your codebase. This allows you to use Juliet even while you edit code: until you explicitly update the snapshot (which is very fast), you can browse through your codebase as it was before you started your changes - an invaluable help during extensive refactorings.
Scales to millions of lines of code— Juliet has no problem with codebases containing several millions of lines of code: both its speed and memory requirements scale linearly with the codebase size.
Detailed, context-sensitive help— Press F1 and Juliet indicates
all the hotspots about which you can get extra help. Move the mouse over them and
press F1 again (or click) to freeze the help popup and browse through it.
Familiar, browser-like interface— You can have as many Juliet windows as you want (Ctrl+N clones any window), each window maintains a history of previously visited pages which can be navigated using Forward and Previous buttons, you can drag and drop links between window, Ctrl+Click over any link to open it in a new window, etc.
Your own codebase "google"— Every Juliet window has a search bar (called "Find Entities") in which you need only type one or more partial words to instantly see all packages, classes, methods, fields, etc in your codebase whose name matches. It's a very fast way to quickly navigate to any entity in your codebase, but it's also useful to find entities whose exact name you ignore or don't remember.
Multi-platform— Juliet is 100% Java and runs on Windows, Linux, Solaris and other unices. The only known java 1.4 platform that's currently not supported is Mac OS X.
Small install— Juliet only measures a couple of megabytes - no sweat to install or take along to a client when reviewing foreign codebases.