Description of the Eclipse IDE for Java Developers

Introduction
The Eclipse IDE for Java Developers is an Integrated Development Environment (IDE) used for
Java development. An IDE is an application that aids in the development of code. It acts as a
toolbox that contains many tools that benefit each stage of the development process. The Eclipse
IDE for Java Developers (EIDE) includes all of the tools a Java developer needs to efficiently
develop a Java program from start to finish. The software development tools contained in the
EIDE are the new project wizard, the project explorer, the new class wizard, the text editor, the
compiler, the console, and the debugger.

Discussion
New Project Wizard
The new project wizard is a wizard that aides the developer in setting up a new Java project. A
wizard is a program that guides a user through a step-by-step process to complete a single task
unique to that wizard. The new project wizard takes a developer's specifications and
automatically creates a project based on them, making the creation process much more efficient.
The first window of the wizard, shown in Figure 1, has inputs for the project name, location the
project will be stored, and other specifications that are rarely modified. The second window,
shown in Figure 2, allows the developer to create a new source folder, link a source folder from
his or her computer, add the project to the build path, and specify the default output folder for the
project. A created Java project can be accessed by selecting it from the package explorer.

Figure 1: First Window of Wizard Figure 2: Second Window of Wizard

Package Explorer
The package explorer is a window that contains a list of projects in the specified working
directory, as well as each project’s components. The working directory is a file on a computer
that the EIDE uses to store all of the project files created with the new project wizard. The
package explorer clearly shows the projects being worked on, as well as the Java classes used in
each project. It is displayed as a tree that includes each level of the project's hierarchy. The

1
hierarchy includes the project, source folder, packages, classes, and methods. Displaying the data
in this fashion makes finding a specific piece of the program simple to find.
The package explorer is located on the left side of the EIDE. As shown in Figure 3, the package
explorer uses different icons to differentiate between each of the different types of elements
shown in the explorer. It also indents each sub-element to clearly show which element it derives
from. Since the package explorer can show multiple projects at a time, it uses collapsing arrows
to stay organized when multiple projects are being shown. This allows projects not currently
being edited to be collapsed down to one line as to not take up excess space in the explorer.

Figure 3: Package Explorer

New Class Wizard

The new class wizard is a wizard that aides the developer in setting up a new Java class. Similar
to the new project wizard, the new class wizard takes a developer’s specifications and
automatically creates a class based on them, making the creation process more efficient.
The new class wizard consists of only one window for the developer to fill out. This window,
shown in Figure 4 on page 3, allows the developer to specify the source folder, package, class
name, inclusion of a main method, and other characteristics of a class. The program created with
the EIDE is made up of multiple classes built with this wizard. Code within individual classes
will be edited by the text editor.

2
 Figure 4: New Class Wizard

Text Editor
A text editor is an application that is used to edit a text file. The text editor within the EIDE is a
tool that allows a developer to view and edit a Java class. This editor is the most utilized tool of
the EIDE because it is used to write every single line of code used in the Java project. It makes
development more efficient because unlike other text editors it is contained within the EIDE and
makes accessing the other tools very simple.
As seen in Figure 5, the text editor makes the Java class more clear by numbering each line of
the code, as well as coloring the code to distinguish different elements such as variables,
functions, and comments. It also includes commands used to format the code currently open in
the editor to make it simpler to follow. The formatting tools save the developer time by
correcting all formatting errors within the class with a single command. The editor also has the
capability of predicting what the developer is about to write, as well as predicting errors that may
occur while compiling. The text editor predicting no errors shows that the code can be compiled
using the compiler.

Figure 5: Text Editor

3
Compiler
A compiler is a program that converts code written by humans into code that a computer can
read and execute. The compiler allows developers to write code that is simple for them to
understand by separating them from the complex and confusing machine code that the computer
can understand. Since translating Java code into machine code is incredibly difficult and time-
consuming for developers, the EIDE contains the Eclipse Compiler for Java (ECJ) which takes
Java code that is written by the developer with the text editor, and translates it into machine code
executable by the computer.
The EIDE accesses the ECJ every time the program that is being written in the text editor is run.
When the program is run, the ECJ will attempt to compile it, and will identify any errors in the
code that stop the program from being compiled successfully. These errors will be displayed in
the console of the EIDE.
The ECJ is hidden within the EIDE and cannot be seen by the developer. The fact that the ECJ
remains hidden fulfills the purpose by keeping the developer separate from the compilation
process. Since the purpose of the EIDE is to make Java development more efficient for
developers, automating the difficult parts of development and separating the developer from
them greatly improves the efficiency of the process. Once successfully compiled with no errors,
the program will utilize the console while executing.
Console
The console is a terminal within the EIDE that allows for communication with the program. A
terminal is a device that can receive inputs into the program and return outputs from the
program. The console allows the program user to communicate with the program whenever the
developer instructed a communication to take place. This could include reading an input from the
program user, or returning the output that the program has computed to the user. In addition,
while running the compiler the console may display errors that caused the compilation to fail.
The console is an initially blank white window at the bottom of the EIDE. It will remain blank
until a program writes to it. It has a scrollbar that allows the developer to see previous lines of
the communication. The console can use different colored fonts to specify different types of
communication. Specifically, errors are often identified by their red color, while outputs are
black and inputs are green, as seen in Figure 6. If the consoles output is not what the developer
expected, the debugger can be used to identify and correct the issue.

Figure 6: Console

4
Debugger
A debugger is a tool that aides in the process of finding and removing bugs from code. A bug is
an imperfection in software that causes a problem while the program is running, whether it be a
runtime error or an unexpected output. A debugger helps to identify bugs in a program by
allowing the developer to view and access the values of variables and data stored in memory for
any given point in a program's code. Once bugs are identified, the developer can edit the program
to achieve the results they expect.
The debugger involves breakpoints, variable inspection, and execution stepping. Breakpoints
give the developer the ability to add stopping points anywhere in the code where the debugger
will halt the program’s execution and expose the values in the program at that point. Based on
the stopping location specified from a breakpoint, all variables that have been initialized prior to
that location can be inspected. Execution stepping allows the developer to slowly move through
the program step-by-step to better understand the exact point at which an error occurs. These
tools can be seen in the debugger shown in Figure 7.

Figure 7: Debugger

Conclusion
The Eclipse IDE for Java Developers is an Integrated Development Environment used for Java
development. The EIDE is made up of seven main parts: the new project wizard, which creates a
project based on the developer's specifications; the package explorer, which displays the files of
all projects in the current directory; the new class wizard, which creates a class based on the
developer’s specifications; the text editor, which allows for the viewing and editing of the code
within individual Java classes; the compiler, which translates Java code into machine code
executable by the computer; the console, which allows the user and the program to
communicate; and the debugger, which identifies bugs to correct errors in the program’s
execution.

The efficiency of developing with the EIDE is a great improvement over traditional development
methods. Using the EIDE allows developers of any skill level efficiently navigate the incredibly
complex but versatile programming language that is Java.