The New Age Eclipse

Eclipse traces its origins to a rather modest SDK that grew into a large

monolithic IDE that it is today. It is comprehensive and includes some of the

best features an IDE can offer a modern-day developer for a platform like Java.

Callisto is a positive improvement in the way Eclipse users would use their

development environment and this article will explore some of the major

differences in how you would work with it.

Callisto Discovery Site



The plug-ins and features, that make up Eclipse, after a time led to a state
where there was a huge repository to search within and figure out what exactly

needs to be installed or enabled. If you have ever browsed through the 'projects'

section in Eclipse's web site looking for the right plug-in or feature for

your need you will know exactly what we are talking about here. The Callisto

home page mentions that this is a simultaneous release of ten projects. This

reflects the separation of the code base of Eclipse and its plug ins into the

separate entities they are.

You can now choose your primary usage of Eclipse from amongst different needs

like: Java development, C/C++ development and plug-in development or even choose

a customize installation if the provided options still don't suit your need.

In case you choose the Java/Web applications option, the IDE is then installed

and configured for just that purpose, removing the need to hover around a lot of

plug-ins and spending on deciding what to install and what not to install. The

Callisto Discovery Suite provided in the Update Manager does the trick here. It

finds and prompts for only those extensions required for the choice you made

while installing Eclipse itself.

Platform changes



The first evident difference you will notice is the startup procedure that has
been integrated into the splash screen. But there are more noteworthy features

than this in the platform. For example, the Project Explorer now displays any

Java project as a hierarchy of source folders and packages in contrast to the

folder view that we had earlier. Similarly, while importing a project from

File>Import>Existing projects into a Workspace, you have an optional

feature of copying the project into workspace by checking the 'Copy projects

into workspace' option that is available now. The filtering support that was

earlier in classes, interfaces and other similar features is now integrated into

all the Import, Export and New wizards. A 'Close Unrelated Projects' option

added in the perspective menu in the Project Explorer is a pretty useful

addition that lets you move all the irrelevant projects out of view and lets you

focus only on the items you need to work on. History has been updated to allow

you to view history for specific elements within a class or project and not just

files as was the case earlier.

The Callisto discovery site allows easier upgrade and installation of only those features and plug-ins relevant to the platform

There is also a completely new concept of 'Working Set' introduced into

the platform. A working set basically defines a group of elements for displaying

in views or operations on the given set. It also reduces the complexity

somewhat, by making visible only those resources that are relevant for the given

'Working Set'. Improvements in problem resolution include the ability to add

those problems in the Problem View that have similar resolution. This can

certainly help a lot in reducing resolution effort and time for a developer.

For Java developers



Similarly for Java Development there are quite a few impressive features on
offer most noteworthy being the changes or improvements brought about in

Refactoring options. For example the platform introduces an 'Indirection

Refactoring' that redirects all the methods calling a particular method to a

new method. This is particular is very useful in case of bug-fixing. You can

also use it to add new behavior in your class quickly or in case the method that

was earlier being used is from an API or a library and hence cannot be changed.

The refactoring also brings in an 'Extract Superclass' command to the

platform. You can easily extract a super class out of the existing similar

classes in your application using this feature. There is a whole new 'Clean Up'

wizard added to the 'Source' menu.

This wizard can be invoked on multiple files, packages and the entire

project. The 'Code Style' tab in the wizard edits code styling, organizing

the blocks and even adding 'final' keyword where-ever possible to private

fields, parameters to methods and local variables. There is also a 'Member

Access' tab that provides options for adding 'this' access qualifier for

both field and method access, and has a detailed set of options for static

access as well that include qualifying access for fields and methods, changing

all accesses through subtypes and instances. These features can help in fixing

multiple problems. The 'Unnecessary Code' tab allows you clean up code that

is not used such as unused imports and private members. You can even change your

code from Java 1.4 to Java 5.0 version by using the options in the 'Missing

Code' tab that allow you to add annotations to your code.

Lets look at one of these features in action. We took a simple class

hierarchy where we have a class Matrix that is extended by classes 'IdentityMatrix'

and 'SquareMatrix'.

The constructors for the IdentiyMatrix class are as follows

public void IdentityMatrix(int dim){



rows = columns = dim;


}

public void IdentityMatrix(int rows,int

columns){



this.rows = rows;


this.columns = columns;


}

Now lets look how the Code Style utility works. Select the IdentityMatrix

class in the Editor Pane and go to Source>Clean Up. In the Clean Up dialog

box select the Code Styling tab and then choose the option 'Use Modifier final

where possible' and then select all the three option under this section and

click on Next. The next page shows you the changes that will be made, click

Finish to complete the operation. The Code sTyle option changes the

IdentityMatrix constructors to

public void IdentityMatrix(final int dim){



rows = columns = dim;


}

public void IdentityMatrix(final int rows,final

int columns){



this.rows = rows;


this.columns = columns;


}

This is a trivial example just to show the usage, but in real life these

source code formatting can actually help you ensure a better implementation of

your classes providing a those ideal practices for parameter passing through a

wizard rather than having you keep track of things and editing them manually.

Similarly the other features in the Clean Up wizard help solving common problems

quickly.

In conclusion



The IDE has grown large enough now split into platforms and it is the right
decision allowing developers to manage their extensions and plug-ins more

easily. Features like the Callisto discovery suite bring about much needed

assistance in case you are not sure what all is needed on your IDE for a

particular purpose. So you can be rest assured that upgrading to Callisto will

bring you a more easily manageable platform and in-case its your early days with

Eclipse, well this is a good point to start with.