GETTING ECLIPSE INTO THE CLASSROOM
Dwight Deugo
Carleton University, 1125 Colonel By Drive, Ottawa ON, K1S 5B6, Canada
Keywords: Eclipse, Teaching, Java, Open Source.
Abstract: In this paper, I describe an approach to integrating Eclipse into the classroom for the purpose of having
students develop assignments using the Java, Scheme and Prolog programming languages. The approach
attempts to overcome three problems. 1) Students wanting to learn about Eclipse have no idea where to
start. 2) Educators wanting to teach Eclipse do not have available the breadth of material required to
introduce students to it. 3) In most institutions, there is no room in the existing curricula to dedicate courses
for explicitly teaching Eclipse.
1 INTRODUCTION
In a survey conducted in November 2006 by BZ
Media (BZ Media, 2006), 66.3% of SD Times
subscribers surveyed reported that developers within
their organizations used Eclipse (Eclipse, 2008).
Their primary reasons for choosing Eclipse were its
low cost (free) and that it is open source. The major
uses of Eclipse reported were for its Java
Development tools, followed by its J2EE Standard
tools, and then its Web Standard tools. These results
are particularly significant to those in computer
science (CS) education. It illustrates industry’s
continued move towards open source software and
Eclipse. There are many reasons for this move, but
at zero cost and better quality, commercial offerings
are having a difficult time competing in the space.
Given the move, it is important for CS educators to
discuss the merits of open source software with their
students and provide them with education on
significant open source offerings, such as Eclipse.
The need is clear: students need to know how to use
Eclipse to be competitive in today’s corporate
software market and CS educators need to teach
students about Eclipse. Industry is demanding it.
While Eclipse has established a large and vibrant
ecosystem of technology vendors, start-ups,
universities, research institutions and individuals, the
availability of focused and organized educational
material on Eclipse is lacking. This situation has
created at least three problems.
The first one is students wanting to learn about
Eclipse have no idea where to start. The second
problem is CS educators wanting to teach Eclipse do
not have available the breadth of material required to
introduce students to Eclipse. The third, and perhaps
the largest problem, is that in most CS institutions
there is no room in their existing curricula to
dedicate courses for explicitly teaching Eclipse.
I believe the simple solution to the last problem
is to have Eclipse used as a common tool for
developing various course concepts, rather than it
being the course concept itself. The benefit is that
students will learn about Eclipse as a side-effect of
developing their assignments. A second benefit is
that they will be able to use their Eclipse knowledge
to work productively in industry. A final benefit is
that by helping students to learn about Eclipse, CS
educators will better understand the joint needs of
their students and the companies they will work for
using Eclipse.
At the recent ITISCE conference, I had a few CS
educators tell me Eclipse was overly complex.
While this is a debatable point, my answer is that
even though Eclipse can be used as an integrated
development environment (IDE) suitable for
commercial development, portions of it can be made
easier to use and tailored towards first year students.
My implementation of the solution to the last
problem noted above and to the complexity issue has
been to develop plug-ins for Eclipse that enable
students to create Java, Scheme, and Prolog
assignments all within the same environment. The
plug-ins add new functionality to Eclipse that, while
not suitable for commercial development, provides
CS educators and their students with a single
388
Deugo D. (2009).
GETTING ECLIPSE INTO THE CLASSROOM.
In Proceedings of the First International Conference on Computer Supported Education, pages 388-393
DOI: 10.5220/0001965303880393
Copyright
c
SciTePress
development environment for teaching and applying
object-oriented, functional and logic programming
concepts. The plug-ins add only the functionality
required to develop language concepts, not the full
blown capabilities of an industrial strength IDE.
In the background section we look at
implementations of different open source and
commercial IDEs. The approach section discusses
how we have integrated the three different languages
into Eclipse and how students interact with them to
develop their assignments. The final chapter
provides a summary.
2 BACKGROUND
Scaled down versions of Eclipse for Java
development have been done in the past. One such
version was produced by the GILD (Gild, 2008)
project. However, it is no longer supported, with its
last release done on January 3, 2006, and intended
for use with Eclipse version 3.1. Another version is
Penumbra. It is plug-in developed at Purdue
University for use in their introductory programming
classes. It was intended to ease the transition to the
use of the full-featured functionality of Eclipse.
Penumbra presents an Eclipse perspective that hides
all but the basic actions of Eclipse's existing Java
perspective, while packaging elements of other
perspectives (e.g., the CVS perspective) into simpler
actions that ease the downloading and turn-in of
programming assignments, and adding new code
views inspired by other environments for
introductory programmers. Although neither version
seems to be currently supported, they provide
direction as to what a light version of Eclipse for
Java development might look like. And, while not
Eclipse based, BlueJ (BlueJ 2008) can also provide
another view of an IDE for teaching object-
orientation to beginners.
Only one Eclipse based Scheme development
environment exists: The SchemeWay (SchemeWay,
2008) project. It provides a set of Eclipse plugins for
the Scheme programming language and features a
powerful, fully extendible S-expression-based editor
that integrates seamlessly with any Scheme
interpreter. However, this environment does not
come with the source code and it is not targeted at
first year students. While not Eclipse based,
DRScheme (DRScheme 2008) provides an
environment that provides an integrated
programming environment designed specifically
with the needs of beginners in mind.
One free Eclipse plug-in for Prolog exists
created by an undergraduate student named Juliana
Barby Simão (Simão, 2004). However, it was
completed in 2004 and was not continued, even
though it was reported that the project would
continue duing 2004 as a graduate project. Not
Eclipse based, JLog (JLog 2008) is an
implementation of a Prolog interpreter, written in
Java. It includes a built-in source editor, query
panels, online help, animation primitives, and a GUI
debugger. It could be easily wrapped within an
Eclipse UI, providing Prolog for Eclipse users. The
only difficulty with this idea is that JLog is under the
GPL license.
Whether for Java, Scheme or Prolog
development, the idea is to provide first year
students with Eclipse-based light IDE. By doing so,
the belief is that as students become more
experienced with the light versions and the language
IDE, they can and will want to transition to the full
versions of the IDE. Having students wanting and
using the different light versions of Eclipse should
also impact faculty making them more likely to
include material on the Eclipse Platform in their
lectures in order to help students use these
environments. Where do they get the material? From
the LCMS outlined in the first part of the approach.
3 APPROACH
Central to our approach is the notion of community.
We wanted to develop a community of users and a
community of developers providing new features
and languages to our IDE for education (IDE4EDU).
To meet these goals the first decision made was to
make the IDE open source. The implication is that
whatever software we use and whatever software we
develop, it must be open source. Since Eclipse is at
the heart of the implementation, the implication is
that, like Eclipse, the code will ship under the
Eclipse Public License (EPL 2008). Using this
license ensures that users are free to download and
use the IDE without needing to pay any fees to
anyone and developers are free to view, modify and
add to the source code. The second decision made
was to create a community project for the IDE. We
have created an Eclipse Summer of Code project at
the Eclipse Foundation (IDE4EDU, 2008). This
subproject is part of the Eclipse Technology family.
Creating this project ensures that the source code
will have a home location, that key members of the
project are identified, and that there is a community
site for others to access to become involved with the
GETTING ECLIPSE INTO THE CLASSROOM
389
project. This project site also ensures that users have
a common place to visit to get software updates and
new versions of the IDE.
Rather than having different versions of the IDE
for each language, another central part of our
approach is to have all languages integrated into one
IDE. The reason for this is simple: there is only one
installation. Educators save class time, by only
needing to describe the install process once, and
students save time by only going through the
download and installation process once. That said,
the installation is very easy: download one zip file,
unzip the file’s contents to a location of choice, click
on the identified IDE executable, and you are done.
Taking this approach also provides a common
environment for students to work with different
programming languages. While there are certainly
many differences between the Java, Scheme, and
Prolog programming languages, students always
work within the confines of the Eclipse workbench,
providing common actions to the edit,
compile/interpret, and execution loop.
The following sections describe how each of the
three languages are integrated into Eclipse, what
other open source software was used in the process
and the key features that are provided for students
working on assignments using the various
languages.
3.1 Java Lite
While Eclipse has been used extensively for Java
development, as I mentioned, I have heard people
say many times, “it is too complex for first year
students”. While part of me believes that we should
expect students to deal with a certain amount of
complexity, I can agree with the argument that when
students are learning a language for the first time,
many things that you would want for commercial
development are not required by students developing
their assignments.
The Java Lite integration into Eclipse simplifies
the approach for student developing Java
assignments. At a minimum, students need to create
a project, create a class and run their code.
Optionally, they can also create a Java package. If
they don’t create a package, all of the source code
goes into the default package. And, to get to this
functionality they have to navigate to the Java-Lite
Eclipse perspective. That’s it. What follows are
these steps in more detail, provided to illustrate that
the level of complexity is something that I believe
we can expect first year students to be able to
manage.
After downloading and installing the IDE4EDU
from its project web site, the next step is to start it up
by clicking on the IDE4EDU application icon. This
will bring up the Eclipse workbench.
Selecting the menu Window -> Open
Perspective -> Other…-> Java Lite opens the Java-
Lite Perspective, shown in Figure 1. From now on,
when a student starts up IDE4EDU they will go
directly to the Java-Lite Perspective. This is a
feature of Eclipse, always returning to the point
where it was last closed from.
Figure 1: Java Lite Perspective.
The perspective has four distinct areas. The left
area contains a Java Lite Project Explore view where
students create their projects, packages, and classes.
The right area provides an Outline view of the
selected class’s methods and variables. The bottom
area is the Console view. The middle/top area is
where the selected class is viewed and edited.
First students need to create a new project. In the
JavaLite Package Explorer. From either the context
menu or the JavaLite Package Explore toolbar menu,
they select New Java Project, as shown in Figure 2.
After entering the project name, as in assignment-1,
students can create a new class. Using corresponding
selection from the context menu or the toolbar, as
shown in Figure 3, they fill in the class name as
shown in Figure 4.
As a course progresses and students become
more Java aware, they can select interfaces and a
different superclass. However, to start with the
defaults are all that is required. Closing the wizard
opens the editor on the class, which has the default
constructor and main method templates already
written. After completing the code, selecting the
class and running it as a Java application, the
corresponding output will appear in the Console
view, as shown in Figure 5.
CSEDU 2009 - International Conference on Computer Supported Education
390
Figure 2: New Project.
Figure 3: New Class Menu.
Figure 4: New Class Wizard.
Students can select their project and export it as
a zip file. Given many schools have electronic
submission of assignments, having an assignment in
a single zip file makes assignment submission
simple, and easy for teaching assistants to unzip,
view, test, and mark the assignments.
As students progress in their Object-Oriented
programming course, they can always switch from
the Java Lite Perspective to the Eclipse’s Java
Perspective, giving them all of the features the Java
perspective provides to developers, such as a
debugger.
Figure 5: Editor and Consol Execution.
3.2 Scheme Lite
The integration of Scheme development into Eclipse
is centered on any file created in Eclipse with the
.scm extension. Since Eclipse does not have a
Scheme interpreter included with it, the approach
also embeds the Second Interpreter of Scheme Code
(SISC, 2008) into Eclipse.
As with the Java-Lite integration, students must
first create a project. In the Scheme integration, any
project will do, even a Java project. However, it is
suggested that students start with building a General
Eclipse project, by selecting File -> New ->
Other…-> General -> Project from the toolbar menu
of any perspective and enter their assignment name,
such as Assignment 2, as the project name. Next
student select File -> New -> File to create the
Scheme file, ending with the .scm extension. These
actions result in what is shown in Figure 6.
The left area in Figure 6 contains the view with
the project and Scheme file. The middle/top area
contains a multi-tabbed editor. The editor lets
students enter their Scheme code and then by
switching tabs they can evaluate it. The other areas
of the workbench contain views relevant to the
corresponding perspective students are working in.
The editor has syntax highlighting and by
clicking before or after any bracket they are shown
the corresponding open or closing bracket, as shown
in Figure 7. Selecting the evaluation tab, brings
students to where they can evaluate the code in their
GETTING ECLIPSE INTO THE CLASSROOM
391
editor and other selected code, as shown in Figure 8.
Hitting the Load Editor Contents button evaluates
the code from the editor. Entering code in the Input
and Eval area and selecting Eval Selection evaluates
the corresponding code. Actions for clearing the
console and resetting the Scheme environment are
also available.
Figure 6: Scheme Multi-Tabbed Editor.
Figure 7: Scheme Edit and Evaluator.
While not full featured, students can work on the
Scheme assignments along side their Java
assignments using our Scheme integration into
Eclipse. Exporting projects as zip files is also
available.
3.3 Prolog Lite
The integration of Prolog development into Eclipse
is centered on any file created in Eclipse with the
.plog extension. Since Eclipse does not have a
Prolog interpreter included with it, the approach also
embeds JLog - Prolog in Java (JLog, 2008) into
Eclipse.
As with the Java-Lite and Scheme-Lite
integrations, students must first create a project.
As in the Scheme integration, any type of project
will do. Next, students select File -> New -> File to
create the prolog file ending with the .plog
extension. These actions result in the multi-tabbed
editor shown in Figure 9.
The left area of Figure 9 contains the view with
the project and prolog file. The middle/top area
contains a multi-tabbed editor. The editor lets
students enter their Prolog code, consult it, and then
by switching tabs execute queries. The other areas of
the workbench contain views relevant to the
corresponding perspective students are working in.
Figure 8: Evaluator.
Figure 9: Prolog Multi-Tabbed Editor.
Selecting the Query tab, brings students to where
they can run queries on the code they have
consulted, as shown in Figure 10. Hitting the
Consult button on the Consult page consults the
code in the editor. Other Prolog related actions are
also available.
While not full featured, students are able to
perform the basic operations of consulting and
querying Prolog code. Debugging is also possible
and exporting projects as ZIP files is available.
CSEDU 2009 - International Conference on Computer Supported Education
392
Figure 10: Query.
4 SUMMARY
While there is no room in CS curriculums to
dedicate courses for explicitly teaching Eclipse,
there is a need for students entering the workforce or
going on co-op work terms to know how to use it.
Our solution is to use Eclipse as a tool in the
classroom for helping students learn how to program
in Java, Scheme and Prolog. At Carleton University
we use the combined IDE4EDU in our first year
object-oriented programming courses and
subsequent courses requiring Java. We also use the
Scheme-Lite and Prolog-Lite integration in our third
year Programming Paradigms course that teaches
student Functional and Logic Programming
concepts.
The three main features of the combined
integration are important to us. First, students need
only learn, and faculty need only teach how to
download and install a single environment. Second,
this is a community effort rather than a home-grown
project. The intent is for the community to produce a
plan and continue the growth of the combined
integration. While there will always be project leads
and committers, the goal is to encourage all
interested parties to contribute to the project. Since it
is important that others contribute to the project,
having the project licensed under an Open Source
License means everyone will have equal access
source code providing them every opportunity to
become involved and make improvements.
REFERENCES
BZ Media. Eclipse Adoption Study. Nov. 2006. 1 Dec.
2008.
http://wiki.eclipse.org/images/d/d4/Eclipse_Adoption_
Study_2006_Full_Version.pdf.
Eclipse, Eclipse.org Home Page. 1 Dec. 2008.
http://www.eclipse.org/
GILD, Gild home page. 1 Dec 2008. http://gild.cs.uvic.ca/.
BlueJ. BlueJ home page, 1 Dec 2008. http://bluej.org/
SchemeWay, SchemeWay home page. 1 Dec 2008.
http://sourceforge.net/projects/Schemeway
DR Scheme. DR Scheme home page. 1 Dec 2008.
http://www.drScheme.org/
Juliana Barby Simão. 28 Mar. 2004. Prolog Plugin. 1 Dec
2008. http://eclipse.ime.usp.br/projetos/grad/plugin-
prolog/index.html
JLog, JLog home page. 1 Dec 2008.
http://jlogic.sourceforge.net/
EPL, Eclipse Public Licensee, 1 Dec. 2008.
http://www.eclipse.org/legal/epl-v10.html
IDE4EDU, IDE4EDU home page. 1 Dec 2008.
http://www.eclipse.org/projects/project_summary.php
?projectid=technology.soc.ide4edu
SISC, SISC home page. 1 Dec 2008. http://sisc-
Scheme.org/
GETTING ECLIPSE INTO THE CLASSROOM
393