Currently, "javac" and "make" do not go well together, and as a result,
large projects such as JDK, sqe-tools and the like have substantial 
problems doing sensible builds.

The problem is that there is no easy and quick way to ensure that a package is
up to date.  With C/C++ you just check that each of the object files is up to
date w.r.t. to the corresponding source file AND and imported dependencies.
"javac" has the -depend switch but it is arguably overkill because it arguably
goes too far down the dependency tree.  The alternative is to pass all the
files for a package to javac, which causes them all to be compiled, which
means that any make actions depending on the class files are guaranteed to
happen because the class files get written whether they need to or not.

I would like to propose that a new switch be added to javac to ask it
to ensure that a package is compiled up to date.  I have a trial implementation
if you want to see it; it works as follows:

- new switch   -updatepackage PKGNAME

The switch causes the compiler to load all the class files for the package,
by enumerating pkg.getBinaryFiles() and loading the corresponding class
declarations.   At the same time, it builds a table of the source files
of the corresponding class files, by rummaging around inside the ClassDefinition
to get the source, and by passing the result to pkg.getSourceFile().
The compiler then scans the set of source files for the package, by
enumerating pkg.getSourceFiles(). Any source files that have not already
been found while scanning the class files, are put on the standard list
of source files to be compiled (Vector v in javac.Main) and compiled in the
usual way.

The net effect is that for those files that have already been compiled,
the compiler simply checks to see if the files are up to date.   In
addition, any sources for which there are no pre-existing class files
are also compiled.

That much works pretty well.  However, it doesn't quite go far enough.
The compiler currently never checks binary dependencies. It either checks
no dependencies or it checks all files for source dependencies.  If
the -updatepackage switch were available, a better interim solution
would be possible. In particular, it would be good to check dependencies
within the current package: build and use the dependency graph for 
ClassDeclarations within the package being built, and if a dependency is outside 
the package being built, simply check the lastModified time of the 
dependency .class file.

With this proposal, one could typically build a directory by a command of the
form:
	javac -d CLASSDIR   -updatepackage javasoft.sqe.harness
or similar.

The experiments I have done so far show that this is not surprisingly
much faster than explicitly compiling all the java files in the directory,
especially when no files actually need to be rebuilt.