Using Eclipse Overlays with OI Java Courses

Most of our Java courses offer an optional "overlay" of files that support the use of the Eclipse IDE in the classroom. The instructor must be experienced in Eclipse to use these overlays; they do not teach one how to use Eclipse, but rather facilitate the integration of Eclipse into the process of teaching an OI Java course. Eclipse can improve classroom productivity, and its rich feedback during coding and debugging can aid students in learning the Java language and Core API.

The Eclipse overlay files may be downloaded from the Object Innovations web site.

This document provides an overview of this feature: why we're doing it, what it is and isn't, and how to use it.

Advantages of Eclipse

All our Java courseware is designed originally to be used with simple text editors and command-line tools. This helps us focus on the standards we're trying to teach -- the Java language, the compiler, various J2EE standards and tools -- and keeps the material vendor- and platform-neutral.

Still, many students and instructors are accustomed to more productive integrated development environments, or IDEs. In the Java world, Eclipse has recently emerged as the clearly dominant IDE: it is powerful, standards-based, and free, developed by an open-source model. Some of its most attractive features are:

• Syntax highlighting -- notice how Java keywords, comments and the programmer's own variable and method names are distinguished visually in the editor window shown here
• Proactive error reporting -- the programmer is advised of compiler errors even while typing new code, and with this immediate feedback can write clean code more quickly
• Auto-completion features, allowing the programmer to save some typing and find less familiar field and method names in the Core API more quickly
• Popup windows with API documentation that appear when one hovers the mouse over an identifier
• Integrated testing and debugging
• Code refactoring features that will carry out intelligent, Java-aware global replacements of names for variables, fields, methods, classes, and whole packages of code

Even so, Eclipse is not a universal choice; in fact using any IDE rubs some instructors the wrong way. (See When to Use Eclipse Overlays for more discussion of how much IDE use is appropriate.) At Object Innovations we've chosen to make support for Eclipse available, but not as part of the standard course materials. Rather, we've developed the Eclipse overlay as an add-on to the lab files for a given course: it is installed, optionally, after the main lab image is in place, and it can be used independently of the command-line procedures spelled out in our coursebooks. Instructors and students can even choose to mix and match their use of Eclipse to carry out one exercise but perhaps use a plain-text editor and command-line tools to work through another.

What is an Eclipse Overlay?

An Eclipse overlay is simply a file tree containing an Eclipse workspace and one Eclipse project for each example, demo, or lab exercise in a given course:

With the overlay, an instructor can apply all of Eclipse's power to any or all of the exercises in the course he or she is teaching. Fans of Eclipse will enjoy the productivity boost, and many instructors see the auto-correct and feedback features of IDEs as helping the students learn the Java language more quickly. Instructors and students can code, build, test, and debug most course exercises entirely from within Eclipse.

Limitations

Eclipse, right out of the box, supports basic Java coding, compiling, and testing very well. Many of our courses go beyond these skills to advanced techniques and especially to J2EE technology. This requires more than just compiling source code and running an application: there are steps to package and deploy applications to Web servers or application servers; often some form of code-generation is involved. Without a lot of coaching, Eclipse can't coordinate the packaging and deployment steps; and its eager evaluation of Java source code winds up reporting a number of "false negatives" on perfectly viable Java source files, when it doesn't understand that some code on which a given class depends has yet to be generated -- but will be in place just in time, as part of a complete build of the application.

For these more complex J2EE structures especially, the tool of choice is Ant -- an XML-based make utility. OI's courses in J2EE topics use Ant to assure reliable, repeatable builds so that students can concentrate on coding and testing. Here the usefulness of Eclipse is usually limited to basic coding and compiling -- still worth doing -- and integrated debugging typically falls away as Eclipse's debugger can't interact with the Web server or J2EE server that's hosting the deployed application.

Finally, for some of our courses, Eclipse in its basic form is simply not useful, and so we don't make overlays available. For instance there is no native JSP editor in Eclipse, so we don't bother with an Eclipse overlay for our JSP or JSTL courses; the standard Eclipse SDK will compile J2SE-format class files, and so we don't try to force a fit between this tool and our J2ME (Java 2 Platform, Micro Edition) courseware.

When to Use Eclipse Overlays

As noted above, there is a range of positions on the use of IDEs in general and on the use of IDEs in the classroom. For this reason we leave the choice to use Eclipse along with our courseware to the training client and/or the instructor. Many will prefer to use Eclipse in all training; some believe it is better to learn everything in a "nuts and bolts" style rather than letting a productivity tool such as Eclipse "hide" important details and inner workings; and many are somewhere in the middle.

One common middle-ground approach is to teach introductory courses with more primitive tools first, to expose students to those nuts and bolts, and then to introduce Eclipse and to use it consistently after a certain point in the training.

In any event, if the Eclipse overlays are to be used, it is essential that the instructor be well versed in Eclipse itself, and able to walk students through basic Eclipse tasks such as opening projects, building, running, debugging, etc. These skills are not covered in our courses anywhere! So the instructor must be prepared to teach them informally as part of the classroom experience.

How to Use Eclipse Overlays

For each course that offers an Eclipse overlay, the Setup Guide will provide basic instructions including a download URL for the overlay and how to install it on the instructor's and students' machines. The Instructor's Guide explains how the overlay is organized, and offers course-specific notes on modifications that were made to support course exercises.

In the overlay itself is a ReadMe.html that provides concrete details of what files live where, how to map Eclipse project names to course exercises, and so on. (Here is an example of the read-me file for our Java Programming course.) It is intended for experienced Eclipse users -- presumably including the instructor. So while it is also available directly to students as part of the classroom installation, we expect the instructor to guide students through it as necessary.

Limited Technical Support

It is important to understand that the Eclipse overlays are not considered part of the core product that is an Object Innovations Java course. They are intended to help instructors get the most out of the material from within the Eclipse environment -- if he or she so chooses. It is on the instructor's authority that the Eclipse overlays should be used at all, and, as noted already, the instructor must be sufficiently expert in Eclipse itself to help students use it effectively in the classroom. We can't offer technical support on Eclipse itself.¹

Also, some exercises may work perfectly from the command-line but imperfectly -- or not at all -- from within Eclipse. This can happen for a host of reasons, many of which are mentioned in the Limitations section above. We ask that, if they suspect problems with an exercise, instructors always double-check the project in question by building and testing it from the command-line as described in the coursebook, before reporting it to Object Innovations as a code defect.

With these limitations understood, we are quite happy to hear any and all feedback from instructors and training clients about the Eclipse overlays. No complete consensus has yet emerged about how best to use this very powerful tool, and we're interested to hear how each instructor prefers to use it, and how the Eclipse overlays do or don't support a given approach. Our goal with these products, as with our courses, is to provide the best possible support for effective teaching and learning. Instructor feedback is a critical part of that process.

¹We are however considering developing a course in Eclipse itself -- interested? Please let us know!