Yes.......

just go to the page and take a peek?  Not hard to do!

http://www.jgrasp.org/index.html

Even there project management is really simple. It just keeps references
to all the programs you want to grouped together. You can then set
compiler, UML..etc options for that project. Just as you could do for an
individual program. Plus it supports ....... never mind:

*About jGRASP*

jGRASP is a lightweight development environment, created specifically to
provide automatic generation of software visualizations for the purpose
of improving the comprehensibility of software. jGRASP is implemented in
Java, and runs on all platforms with a Java Virtual Machine (Java
version 1.3 or higher). jGRASP produces CSD diagrams for Java, C, C++,
Objective-C, Ada, and VHDL; CPG diagrams for Java and Ada; UML diagrams
for Java; and has an integrated debugger and workbench for Java.

*New Versions*

The jGRASP 1.7.1 release added more support for Java 1.5 features. CSD
generation now fully supports Java 1.5 syntax. The UML diagram shows
enums and generic signatures for classes, fields, and methods. The Java
debugger and workbench show full generic signatures with replacements
whenever possible, and allow the user to specify generic type arguments
when creating a class instance. Operations such as "invoke method" still
consider the declared type of values to be the run-time type even when a
replaced type can be resolved - this will be fixed in a future version.

Also in 1.7.1, the Java workbench can now be used without a project, and
can be started and used directly from an editing window, without a UML
diagram.

jGRASP 1.7.2 fixes a minor problem in 1.7.1. The Java CLASSPATH
extensions that jGRASP normally searches for in standard locations were
ignored.

Disclaimer: I am the chief programmer for the jGRASP
project. I believe everything that follows, but you can
take it as "advertising" if you want. I do use jGRASP
exclusively to develop jGRASP, and always use the
CSD.

In general, I would say try the CSD. Give it a few hours
at least and see if you like it.

The CSD has been shown to increase the rate and
reliability of code comprehension. This is based on a
published in-house study, with "experienced student
users" as subjects. We welcome independent verification
and related studies.

Another benefit that most would accept without
evidence is an increase in search speed - it makes it much
easier to find the start and end of each structure.

In my experience a huge benefit is a reduction in fatigue
(meaning fatigue due to "reading code") with long hours
of programming. This is just my feeling - it would certainly
be difficult to study.

It also enables simple and meaningful code folding - in
jGRASP you can fold a structure by double clicking on
the CSD "stem" for that structure.

Another feature enabled by the CSD is "context hints",
which displays the first or last line of a structure
(whichever is significant) when that line is off-screen,
when the mouse is placed over the CSD stem for that
structure. So basically you can slide the mouse across
a line and see (using Java as an example) what class
that line is in, what method, and down through all the
structures that are not currently visible.

The CSD does show complete control flow for the
"structured" parts of the code (not raw gotos, etc.)
when you know how to read it. I don't think this is a
big benefit, but in some situations it can be. One
example is in showing the path to one or more
"finally"s from a "return", "break", etc.  If the
"finally"s are off-screen (or even if they are visible),
you are likely to ignore them when reading the code.
Also it will make it obvious when a switch case is
missing a "break", when there is an accidental
semicolon at the end of a structure (if, for, etc.)
header, and some other common structural mistakes
and unexpected structures.

The CSD also has the benefits of any other code-
formatter (at least for indentation). It reduces the time
you would spend "indenting", and standardizes the
indentation format to some extent. If you don't like the
indentation scheme it uses (which is more-or-less
mandated by the diagram), you may not consider that a
benefit.

In jGRASP the CSD is editable, so during development
you would typically regenerate at least as often as you
would compile. Generating it is fast (40,000 Kloc / s
or so on a 2GHz Pentium - effectively "instant").

The CSD fits into the space normally taken by
indentation, so it really doesn't interfere with the
normal presentation of source code, it just adds
to it. I suppose there are people who find the CSD
distracting and can not "adjust" to it, but I would
expect that is quite rare.

The developers of JGrasp do a pretty good job of selling the concept
on the web site. http://www.jgrasp.org/tutorials17/08_CSD.pdf is
probably more eloquent than I can be. The primary value of CSDs to me
has been looking at other peoples code. Nested ifs and loops can be
hard to follow, particularly if you don't notice a bracket or brace
buried in the middle.

If you're just starting, the course materiel you've been given is
probably well structured, well commented, well indented and relatively
simple. CSDs might not add too much value there. But with more
complicated code I've found them very helpful.

You can use the various CSDs as templates and paste them in your code,
thus assuring that you'll have the proper syntax and formatting. I've
not really used that feature.