Adding Code

Now that we have the directory structure in place, we can
begin adding code to our project. We'll divide our
calculator program into three different files:
CalcModel.java,
CalcPanel.java, and
Calculator.java. Grab the
.zip archive and place these files in
the com/devious/calculator directory. Use
File->Refresh to update the Eclipse project.

Project with source files added (You can click on the screen shot to open a full-size view.)

CalcPanel.java handles most of the user interface
for our calculator. Calculator.java handles setup
and launching of the GUI. Most of the important work happens in
CalModel.java, which implements the actual "mechanics" of
our calculator: responding to events, performing numerical
calculations, updating the display, and so on. The easiest way to
explore the code is by switching to either the Java perspective
or the Java Browsing perspective. Use the Open Perspective
item in the Window menu or click the Open button
on the perspective toolbar.

As you use the Package Explorer to browse the source
code, you may notice that the Outline view seems a bit
superfluous. You can click the X in the upper right corner of
the Outline view to close it. Should you want to see it
again, you can use the Window->Show View->Outline menu
item to display it again. Those interested in a multi-paned
source code viewer a la Smalltalk should give the Java
Browsing perspective a try.

Java Browsing perspective (You can click on the screen shot to open a full-size view.)

Running Code and Debugging

So you've managed to download and install Eclipse, create a
Java project, and add the folders and files needed for a simple
application. Now it's time to see the application run. You'll need to use the Java perspective to complete the steps
necessary to run the app:

From the Run menu, select the Run... item.

In the wizard dialog which appears, select "Java Application"
from the list of Launch Configurations, then click
the New button.

(You can click on the screen shot to open a full-size view.)

Enter Calculator as the Name for the new
configuration.

Click the Search... button and select
Calculator as the Main class, or simply enter
com.devious.calculator.Calculator in the text entry
box.

(You can click on the screen shot to open a full-size view.)

Click the Run button to save the configuration and
run the application.

Once you've created a launch configuration for the
application, you can run it again using Run->Run History menu
item or the Run button on
the toolbar. If you spend enough time playing with the
calculator, you'll notice that while it works pretty well, it does
seem to have one major flaw: it won't do subtraction! Time to
fire up the Eclipse source-level debugger and find the problem.
If you've been following along with the examples, you should be
able to debug the application using the same launch configuration
defined earlier. Select Run->Debug History->Calculator to
launch the application in the debugger.

When you launch your application for debugging, Eclipse
automatically switches to the Debug perspective:

Debug perspective (You can click on the screen shot to open a full-size view.)

Since our problem seems to center around the subtraction
function, we'll set breakpoints in the event handler for the
minus key and the equals key. First, we need to switch
to the editing tab for the CalcPanel class. (If you
don't have an open tab for CalcPanel, you'll have to
switch back to the Resource or Java perspective, open the file
there, then switch back to the Debug perspective.)

Use the
Outline view to select the actionPerformed
method. Scroll down a few lines until you see the
case statement for the minus key (line 126). If you
double-click in the left margin at this line, you'll see that
Eclipse sets a breakpoint there. Scroll down a bit more and set
another breakpoint on the call to model.calculate()
in the handler for the equals key (line 138).

Breakpoint set (You can click on the screen shot to open a full-size view.)

Next, switch to the calculator window and click some of the
buttons. Something like 2 4 6 - should do the trick.
Once the debugger hits the breakpoint, you can use the buttons
in the toolbar for the Debug view to step into, over, or out of
methods.

If we step into the setOperation method, we see
that it just saves the operation code to the
pendingOp field. Press the Resume button on the Debug toolbar to continue the execution of the program.

Tip: A common mistake for new Eclipse users is to press the Debug
or Run buttons on the main toolbar rather than the Resume button. This will
launch another copy of your application, rather than
continuing the current one.

Now, click a few more buttons (e.g. "1", "2", "3") and then
the equals key. Once we step into the calculate method, the problem is obvious: someone copied the code from the OP_ADD case but didn't edit it to properly perform a subtraction rather than an addition. Problem solved!

Hotswap Bug Fixing

If you happen to be running your application using a 1.4
JVM, there's one final step to our debugging example. Rather
than exiting the app, changing the code, recompiling, and
then starting another debugging session, we can fix the problem
on the fly. With the debugger still running, change
the problem line from:

setDisplay(previousValue + currentValue);

to

setDisplay(previousValue - currentValue);

Save the file, then press the Resume button to get the
application running again. Use the calculator's C button
to reset it, then try the same sequence of operations again.
This time around, it works!

What we've just demonstrated is Eclipse's support for a
new 1.4 feature called "HotSwap." The Java Platform Debugger
Architecture (JPDA) now supports the ability to substitute
modified code in a running application. This is
particularly useful when starting your application, or getting
to the point where it fails, takes a long time.

A Taste of Things to Come

One very attractive feature of Eclipse is the speed with
which product bugs and deficiencies are addressed. While
Eclipse 2.0.2 is the current version of the product, the
Eclipse Group is actively working toward the release of
Eclipse 2.1. Monthly "milestone" builds (M1, M2, M3, etc.)
deliver the latest stable feature set from Eclipse 2.1 to
interested users. Among the features included in the latest
2.1 M3 build:

Customizable key bindings, including a set of Emacs-like
bindings

The ability to automatically turn TODO,
FIXME, and tagged comments in Java code
into items in the Tasks list.

Improved CVS support, including the ability to define
"working sets" that limit the number of projects shown in
the CVS Repositories view.

New "hovers" in the Java editor, which can be used to
show source code, Javadoc, or detailed error messages for
a particular line of code or expression in a pop-up "tooltip"
window.

Support for several new refactorings

A new Threads and Monitors view in the debugger,
which allows you to determine which threads are holding locks,
which threads are waiting, and other information necessary
to track down problems in multi-threaded applications.

It is this last feature which makes Eclipse particularly
well-suited to Java application development and, in particular,
Web application development. Eclipse brings together all of
the tools a developer needs to be successful at Web application
development: an extensible IDE, a standards-based compiler,
remote debugging, Ant-based builds, JUnit-based testing, and
plug-ins for communicating with most application servers and
EJB containers.

Resources

Scott Storkel
is an experienced programmer with over twenty years of experience, including object-oriented systems for the last twelve years and building enterprise-class Java web
applications for the last four years.