Running a Java program involves three steps. First the programmer types in Java source code. Then a piece of software known as a "compiler" converts this Java source into a form called the Java byte code, stored in "class files" or "zip" files. Finally, the byte code is then input to a program called a Java Virtual Machine for execution. This final step allows Java to remain independent of the type of hardware executing the program.
The Jikes Compiler created by IBM researchers has two advantages over other Java compilers. First, the team that created it did so from fundamental principles. It adheres completely to the Java specification. For that reason it can diagnose errors in code better than any other Java compiler. In addition, the new compiler is written in the C++ computer language instead of Java. Although it sounds counter-intuitive, it's not necessary to use the Java language to compile Java code. C++ is a mature computer language that programmers have used for several years. Because of that familiarity, compilers based on C++ work appreciably faster than compilers that use the Java language.
Two of the other tools help programmers to debug Java programs. The Jikes debugger is a graphical user interface that gives programmers an interactive view of their programs in action. These views permit a programmer to check for errors and locate bugs much faster than tools that rely on command-line control.
Dejavu, meanwhile, helps programmers debug what they call "multithreaded" applications. Programmers usually debug a program by running it over and over and checking the consistency of each part of the program. When a multithreaded program runs, the threads take turns, but the time slices per thread can vary on each run. The variable time can alter the program's behavior from one run to the next, destroying the programmers' ability to spot bugs. Dejavu collects key information from each thread of the multithreaded program, and uses that information to ensure that the threads of the program take turns exactly the same way in each run. Then programmers can reliably debug multithreaded programs.
is a tool that lets you visualize and explore a Java program's run-time behavior. It is useful
for performance analysis, debugging, and any task in which you need to better understand what your
Java program is really doing. It displays performance bottlenecks, object creation and garbage
collection, execution sequences, thread interaction, and object references, and has features to help
find and solve memory leaks. Jinsight can also take repetitive execution behavior and boil it down to
its essentials, eliminating redundancy and uncovering the highlights of an execution.