Adjacency matrix code visualizer

Adjacency matrix for JDK 1.8 (3.8M)

Run on jdk1.8.0_45/jre/lib/rt.jar. It took 1 minute to generate.

Adjacency matrix for Guava 19.0 (116K)

Run on guava-19.0.jar. It took 2 seconds to generate.

Adjacency matrix for Minecraft 1.9.2 (422K)

Run on 1.9.2.jar. It took 3 seconds to generate.

Note: Minecraft code is obfuscated. Class and packages names are random. I do not know if the obfuscation also messed with the connections between classes.

Netty 4.0.36 (246K)

Run on netty-4.0.36.Final/jar/*.jar excluding *-sources.jar.

Adjacency matrix for GWT 2.7.0 (3.1M)

Run on gwt-user.jar and gwt-dev.jar. It took 46 seconds to generate.

Adjacency matrix for Eclipse mars2 (11M)

Run on eclipse/plugins/org.eclipse.*.jar. It took 5 minutes to generate.

Adjacency matrix for Hibernate 5.1.0 (834K)

Run on core-5.1.0.Final.jar and core-5.1.0.Final.jar. It took 6 seconds to generate.

Adjacency matrix for Apache Commons (331K)

Run on commons-cli-1.3.1.jar, commons-io-2.4.jar, commons-math3-3.6.1.jar, commons-compress-1.11.jar, commons-lang3-3.4.jar. It took 2 seconds to generate.

Adjacency matrix for JUnit 4.11 (54k)

Run on junit-4.11.jar. It took 1 second to generate.

Adjacency matrix for adjmatrix 1.1 (27k)

Run on adjmatrix.jar. It took 1 second to generate.

Note: Very boring.

Best seen when the nodes are sorted and colored by Package. Nicely separated packages will have box shapes along the diagonal in the same color, and not many points above or next to this box.

A box of the same color shows that classes within a package uses each other. The adjacency matrix for Guava shows a nice separation between packages. We see a big blue box, followed by small orange, teal and red boxes.

Having few points above or next to the box means that package is not connected to other packages. A Tools packages would have many points above and below it because it is being used by all classes. In the adjacency matrix for Guava the pink and dark green packages at the top left look like tools packages because of all the dots below them. The classes in those areas are mainly com.google.annotations.GwtCompatible and com.google.common.base.

Best seen when the nodes are sorted by similarity and colored by package. Sorting by similarity groups together classes that are highly connected to each other and not highly connected to others.

You should see boxes along the diagonal. If a box has two colors, then two packages are heavily connected. The middle group in Figure 1 shows 3 different colors forming a box around the diagonal. Those 3 colors mean that 3 packages are tightly connected to each other.

If there are two boxes with the same color, then that package could perhaps be split into two packages. If we sort the adjacency matrix for Guava by similarity, we see that the blue package is split into a big, tightly connected box in the top left corner, and we barely see another blue box in the center.

A cyclic dependency is when class/package A uses class/package B, and B uses A (cycles of more than 2 classes/packages are also possible).

When you sort by tree, sort package, similarity, or jar, any dot below the diagonal is a link in a cyclic dependency. When sorting by packages/similarity/jar, classes in the same package/group/jar will have been sorted by tree.

Base classes are the classes in your code that are used everywhere.

They are best seen when sorting by used and zooming in to the top-left corner.

If you see colors in the full height at the left part you have classes that are heavily used from all your classes. Some most used classes are: CoreException from Eclipse, HibernateException from Hibernate, and Object from JDK.

You can also find classes that are not used at all. These classes might be dead or untested (if you included your unittests in the adjacency matrix).

God classes are classes that control everything and have way too much responsibility.

They are best seen when sorting by uses and zooming in to the top-left corner.

Some classes that use the most other classes are: Workbench from Eclipse, ModelBinder from Hibernate, JavasScriptConfiguration from GWT, and XToolKit from JDK.

All classes in the JDK are at most 6 dependencies away from the class sun.tools.jar.resources.jar_zh_TW. The class java.lang.Object connects to all but one other classes after 3 steps. The one class that is 4 connections away from java.lang.Object is com.sun.corba.se.internal.Interceptors.PIORB, a rather boring class.

If you just want java.util.ArrayList, you still need 1684 other classes from the JDK. I found this by zooming in to the node representing ArrayList, then clicking "Add uses" until no new classes were added to the matrix.

You can play with this by filtering/zooming until a single class is showing. And then clicking the "Add connected", "Add uses", and "Add used" buttons.