Here are some places you can go to for help if you have problems with
Dependency Finder.
- JDepend
-
JDepend traverses a set of Java class and source
file directories and generates design quality metrics for each Java
package. JDepend allows you to automatically measure the quality of
a design in terms of its extensibility, reusability, and maintainability
to effectively manage and control package dependencies.
- BCEL
-
The Byte Code Engineering Library is intended to
give users a convenient possibility to analyze, create, and manipulate
(binary) Java class files (those ending with .class). Classes are
represented by objects which contain all the symbolic information of
the given class: methods, fields and byte code instructions, in
particular.
- ASM
-
ASM is an all purpose Java bytecode manipulation and
analysis framework. It can be used to modify existing classes or
dynamically generate classes, directly in binary form. Provided common
transformations and analysis algorithms allow to easily assemble custom
complex transformations and code analysis tools.
- JDiff
-
JDiff is a Javadoc doclet which generates an HTML
report of all the packages, classes, constructors, methods, and fields
which have been removed, added or changed in any way, including their
documentation, when two APIs are compared. This is very useful for
describing exactly what has changed between two releases of a product.
Only the API (Application Programming Interface) of each version is
compared. It does not compare what the source code does when
executed.
- Jar Jar Links
-
Jar Jar Links is a utility that makes it easy to
repackage Java libraries and embed them into your own distribution. This is
useful for two reasons: you can easily ship a single jar file with no
external dependencies, and you can avoid problems where your library depends
on a specific version of a library, which may conflict with the dependencies
of another library. Jar Jar Links was initially developed for use in
building
TonicPoint Builder,
and is licensed under the GPL.
- classdep
-
classdep lets you browse and analyze dependencies
between individual classes and entire packages or designated package
groups in your code. It helps reduce coupling, detects dependency
cycles and gives assistance in refactoring by showing which classes
might be directly affected by a change to another class. classdep
does not require source code, just bytecode of your application to
process.
- JavaNCSS
-
JavaNCSS is a simple command line utility which
measures two standard source code metrics for the Java programming
language. The metrics are collected globally, for each class and/or
for each function.
- IntelliJ IDEA
-
A great IDE with easy to use usage tracking features
and automated refactorings.
- Xrefactory
-
An add-on to Emacs for tracking usage and automated
refactorings.
- reView
-
Headway reView is a powerful new visualization tool
that shows you all the dependencies in your Java application at all
levels and between all levels - between packages, classes, packages
and classes, methods, methods and classes, .... Fully automatic,
intelligent graph layout algorithms let you understand better the
structure of your code and helps you to continuously optimize your
codebase. Powerful dependency analysis aids help you solve many
every-day problems quickly.
- Structure 101
-
Structure101 builds on over 5 years experience with our
advanced, award-winning, static analysis and reverse engineering products.
Structure101 takes something very complex and difficult to control -
software structure - and makes it easy. The Structure101 Client does this
in a very simple way - by exposing and measuring your software's structure.
Just being able to see what's there now, at every level of the design
hierarchy, will make your developers more productive and help them grow the
code in-line with the intended architecture and within reasonable
complexity limits. There's no need to work in the dark any more.
- OptimalJ Package Structure Analysis Tool
-
The OptimalJ 2.2 - Package Structure Analysis Tool
is a new tool for analyzing and improving the structure of Java programs.
The Package Structure Analysis Tool takes Java sources as input and:
- Visualizes the dependencies between packages and classes with UML class diagrams.
- Detects cycles in the dependency graph.
- Recovers an intended architectural layering from a polluted implementation.
- Suggests which dependencies should be removed to improve the structure.
- Allows refactoring of the source model.
- Immediately shows the effect of the refactoring on the dependency structure.
- Allows the refactoring to be applied to the source code.
- Allows source code to be verified against a design model.
- WebGain Quality Analyzer
-
part of WebGain Studio, a complete development environment.
- MagicDraw
-
MagicDraw is a visual UML modeling and CASE tool
with teamwork support. The development tool is designed for a Business
Analysts, Software Analysts, Programmers, QA Engineers, or Documentation
Writers. The tool facilitates analysis and design of Object Oriented (OO)
systems and databases. MagicDraw supports the latest standards of Java,
UML and XMI and provides the industry's best code engineering mechanism,
with full round-trip support for Java, C++, and CORBA IDL programming
languages. MagicDraw also provides database schema modelling, DDL
generation and reverse engineering facilities.
- Objecteering/UML
-
Visual UML modeling tool with an OO metrics module.
- Together Control Center
-
Another visual UML modeling tool with code audit
and metrics capabilities.
- CodeSurfer
-
Dependency Finder for the C language.
- Small Worlds
-
Small Worlds™ provides key insights into the
dependencies among software components, the system lifecycle, stability,
and maintenance. Managers, engineers, developers, and testers all benefit
from the innovative, global approach to their software.
- The DMS® Software Reengineering Toolkit
-
The DMS Software Reengineering Toolkit is a set of
tools for automating customized source program analysis and modification
of large scale software systems, containing arbitrary mixtures of
languages ("domains"). DMS can also be used for domain-specific program
generation. This toolkit is the first step towards the implementation of
The Design Maintenance System™, an ambitious vision of a 21st
Century software engineering environment that supports the incremental
construction and maintenance of large application systems, driven by
semantics and captured designs
- Juliet
-
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.
- NoUnit
-
How Good are your JUnit Tests? NoUnit measures
your Junit tests in your project using Java, XML and XSLT. NoUnit gives
a picture of your code , like a graph gives you a picture of a set of
figures, to allow you to see what is *really* going on.
- Ignominy
-
A tool used at CERN to analyze large software
used in high-energy physics simulations.
- Ivy
-
Ivy is a free java based dependency manager,
with powerful features such as transitive dependencies, ant integration,
maven repository compatibility, continuous integration, html reports
and many more.
- JUNG
-
JUNG -- the Java Universal Network/Graph Framework
-- is a software library that provides a common and extendible language
for the modeling, analysis, and visualization of data that can be
represented as a graph or network. It is written in Java, which allows
JUNG-based applications to make use of the extensive built-in
capabilities of the Java API, as well as those of other existing
third-party Java libraries.
- Hackystat
-
Hackystat is a framework for the automated
collection and analysis of software engineering product and process
data. It differs from other approaches to software metrics technologies
in [many ways].
- testability-metrics
-
Testability-metric is a tool which analyzes java
byte-codes and computes how difficult it will be to write unit-test. It
attempts to help you quantitatively determine how hard your code is to
test and, where to focus to make it more testable.
- Google Singleton Detector
-
The Google Singleton Detector, or GSD, is a tool
which analyzes Java bytecode and detects the use of Singletons.
- FindBugs
-
A static analysis tool to find bugs in Java
programs.
- DepAn
-
DepAn is a direct manipulation tool for visualization,
analysis, and refactoring of dependencies in large applications. DepAn
provides a rich framework for visualizing and analyzing the dependency
graphs of large application. It evolved in response to the engineering
challenges inherent in comparing alternative software architectures.
- gpl4jung
-
The aim of this project is to provide a graph query
language that can be used to query graphs represented in
JUNG. There
are numerous applications for this, including the declarative definition
of architectural antipatterns and smells in systems. The project is
inspired by the use of XPath queries (on the AST) to describe code level
antipatterns in
PMD.
- Layering
-
OptimalJ, 2004.
The Acyclic Dependency Principle and
package layering to reduce dependencies.
- Agile Software Development: Principles, Patterns, and Practices
-
Robert C. Martin, objectmentor.com, 2003.
Everything you ever wanted to know about
dependencies, and then some. This book covers a lot of the
fundamentals of writing software, including the author's pet
peeve: dependencies. Winner of the 2002
Jolt Award.
- Surf the Code
-
Rick Wayne, Software Development magazine, March 2002.
Product review of CodeSurfer 1.5.
- Acyclic Dependencies Principle
-
Kirk Knoernschild, 2001.
The Acyclic Dependency Principle.
- Ignominy: a tool for software dependency and metricanalysis with examples from large HEP packages
-
Lassi A. Tuura and Lucas Taylor, CHEP '01, September 2001.
Ignominy is a tool developed [...] to analyse the
structure of software systems. Its primary component is a dependency
scanner that distills information into human-usable forms. It also
includes several tools to visualise the collected data in the form of
graphical views and numerical metrics. Ignominy was designed to adapt
to almost any reasonable structure, and it has been used to analyse
several large projects.
- Reducing Coupling
-
Martin Fowler, IEEE Software, July/August 2001.
How to manage coupling and dependencies.
- Protected Variation: The Importance of Being Closed
-
Craig Larman, IEEE Software, May/June 2001.
The Open Close Principle and the importance
of dependencies.
- Design Principles and Design Patterns
-
Robert C. Martin, objectmentor.com, 2000.
Various design principles, design patterns to
ensure them, and metrics to verify their application.
- OO Design Quality Metrics
-
Robert C. Martin, objectmentor.com, 1994.
The importance of managing "good" and "bad"
dependencies. Dependency metrics, including instability,
abstractness, the "main sequence", and the distance from it.