Here are a few more tips / tricks with which you can save time when you use the eclipse IDE.

Assign Key bindings:

Navigate to Window -> Preferences -> General -> Keys

You will find that there are many key bindings that are not assigned to actions that you might do on a daily basis. For example, when I start up on a new project, it is highly likely that I will introduce a lot of Value Objects (or Transfer / Data object, whatever you like to call them). A slick feature is to generate the ‘Getters and Setters’ for them using the ‘Source -> Generate getter and setter’ command from the Main menu.

You can either do that or you can assign a shortcut key to this action and get it done quickly. I use Alt+Shift+Q, +G (Yeah not the easiest combination. I know ). To restart eclipse I use Ctrl + F12. You might want to look at other bindings like

• Generate hashCode
• Generate toString()
• New package
• New class

And so on…

Reduce number of code suggestions:

The shortcut I use the most in eclipse is perhaps ctrl+space. Code completion is a real time saver. It can however be annoying when you press ctrl+space more than once by mistake. This by default, brings about suggestions for SWT templates among other things. You can turn this off by navigating to Window -> Preferences -> Java -> Edtior -> Code Assist.

Import preferences:

If you are like me, your hard disk probably has more than 100 eclipse Workspaces. Developers usually customize their workspaces and it can take a while to do this. When you switch to the new workspace, some of the customization is lost because they were workspace specific. You can get them back easily by exporting your preferences in the old workspace and importing them again in the new one. Use the File -> Export / Import option to do this. Preferences like code formatting, code templates, default compiler settings etc will be readily available.

Remember more workspaces: (Works on myeclipse)

Use this technique to allow eclipse to give you more drop down choices when you startup. By default eclipse remembers the last 5 workspaces used. You can increase / decrease this number by navigating to Window -> Preferences -> General -> Startup and Shutdown -> Workspaces.

Associate eclipse with an external browser like firefox :

Eclipse uses the system default browser. In most cases this is IE (gulp). You can change that by defining an external browser by navigating to Window -> Preferences -> General -> Web Browser.. This is great when you combine it with a plugin like Firebug. You get to code and debug HTML / CSS / Javascript all at once.

Work with local history:

Screwed up your java file and then saved it ? Yikes. Local history comes to your rescue. Every edit and save that you make in a file is saved as a local history in eclipse. Make use of this to revert changes when necessary.

To use this feature, right click on the file of your choice and click Compare With -> Local hisory. That should open up the entries in the ‘History’ view.

Clicking on any of the history entries will open a diff window telling you the difference between the current entry and the previous edits. Ah ! time is saved.

This is a 3 part article. If you would like to browse through the other tips, you can find them here

Eclipse tips and tricks – Part 1

Eclipse tips and tricks – Part 2

I moved all development activities to linux recently. Part of the migration process involved getting used to some new apps like Kopete / Pidgin / KDE Snapshot etc. It was a breeze until I started debugging my code in eclipse.

I frequently use the eclipse keyboard shortcuts to cut down the time I spend coding / debugging. One of my favorite is Ctrl + Shift + i , which will open up the inspection box for a particular variable. This shortcut just did not work. For quite a few days I did not understand why. The other shortcuts like fix imports ( ctrl + shift + o ) seemed to be working fine. That’s when I stumbled across a kopete shortcut.

The shortcut Ctrl + Shift + i was also used by kopete to read messages. According to the documentation this was a global short cut that was valid in any KDE application. I closed kopete just to confirm that it was contributing to the problem and voila, Ctrl + Shift + i started to work inside eclipse once again. So the next time a shortcut does not work in eclipse you might want to

1. Look at the Wondow -> Preferences -> Keys and ensure that the key is bound.
2. If it is bound, check other applications and make sure this is not a global shortcut used elsewhere.
3. If it is a global shortcut, change the key binding in eclipse or the other application.
4. Relax

Eclipse can be used to debug your java applications. Here are a few tips that can help you debug better

Remote debugging:

The eclipse IDE can remote debug your web application. Imagine being able to debug your development server from your local machine. Eclipse can help you do this. First you need to instruct your application / server to listen on a port for debug messages. That can be done using the -Xdebug flag

java -Xdebug -Xrunjdwp:transport=dt_socket,server=y,address=8787,suspend=n

This tells the JVM to listen for specific debug messages on port 8787. In eclipse open Bug Icon -> Debug configurations and select “Remote java application”. Mention the port and server address and you should now be able to remote debug the application. Make sure that the classes and source sync with each other. On a network where the bandwidth is poor, this technique will not work.

Remote java application:

Use the display view:

The debug perspective in eclipse can open up a “Display” view that allows you to dynamically enter some code for execution when you hit a breakpoint. This view is priceless. You can dynamically execute code related to the variables that are in scope. Use the icons available on the top right hand corner of the view to do this.

Display view:

Set breakpoints at different levels:

You can set class level, method level or line level breakpoints. Nothing special but once again it can save you time. Just set a breakpoint corresponding to a class declaration a method declaration or a specific line.

Set conditional breakpoints:

Breakpoints can be triggered conditionally.  Simple right click on a breakpoint and select ‘Breakpoint properties” There are 3 settings that you can tweak.

1. Hit count – Break only when code flow passes over this breakpoint N times.
2. Condition – Break when a specific programmatic condition is reached.
3. Suspend VM Vs Suspend Thread – This is useful when debugging multithreaded application. If you want to suspend only the current thread and not all threads that are running through this code flow, you can use this drop down.

Breakpoint properties:

Tweak the breakpoint:

Specify a detail formatter of your own:

Use the Variables view to mention a detailed formatter for an object type. This will display the object in question in a different format when you look it up under Variables or in an inspection window.

Open the detail formatter:

Type a detail format:

See the results in the variable window (among other places):

Use inspection windows:

Inspection windows can reveal the detailed object graph of the instance in question. Simply highlight the variable and type the shortcut ctrl+shift+i

Inspect:

Traverse the object graph:

Use all instances / references:

Use the all instances / all references option in the Variables view to determine the usage of a particular Object type at runtime. Arguably a profiler might be better suited for this sort of work, but hey, you never know when you might need it.

View all instances of an object type:

Change variable values dynamically:

You can use the Variables view to change the value of a variable dynamically. This helps to determine code flow control if you have conditional statements. You could also do the same using the Display view but the GUI helps.

Change value:

Use the drop to frame feature:

The “drop to frame” feature allows you to retrace your path after making a minor code change. The code flow goes back to the line of code you have dropped to and executes once again. You could even, say, change a database variable and drop back a few call stacks behind to retrace your steps.

Drop frame:

Thats about the list of debugging tips I know. Do you have one that could help other developers ? Drop a comment. There is one more article on eclipse productivity coming down the line. Subscribe to the RSS feed if you would like to keep up to date.

Eclipse is a pretty good IDE to develop java apps on. However there are some features that you might not be using every day that can save you a lot of time.

Writing your own code templates is one of them. To write your own code template do the following

Go to Window -> Preferences. Select Java -> Editor -> Templates. You can add your own templates here. Templates are nothing but the code that auto completes when you press ctrl+space. For example type syso and ctrl+space. This will automatically fill in System.out.println() into the editor.

Eclipse code templates:

Code template variables:

Eclipse can automatically fill out dynamic code by sniffing out variables in a template. Here are a few you should make yourself aware of

${cursor} - Place the cursor here after code completion
${enclosing_method} – Replace this with the method name where the code completion was called.
${enclosing_method_arguments} – Replace this with the enclosing method arguments
${enclosing_type} – The enclosing class name
${import} – Dynamically import some classes
${importStatic} – Same as above but with static imports
${time} – Current time
${todo} - The //TODO eclipse task

We can now go ahead and define some useful templates. When you type the name of any of these templates and press ctrl+space your custom code will be auto completed. Click on the New button to add a template

Name:call
Description:Log once inside a method. When you type call and ctrl+space a small snippet is auto completed that will print out to the console the method name that is being called and its arguments.

1

System.out.println("Called: Class: ${enclosing_type} Method: ${enclosing_method} Args: ${enclosing_method_arguments}");

Name:go
Description:Write a program with a main method real quick. Just type go and ctrl+space and be on your way to writing a small program.

1
2
3
4
5
6
7
8
9

public static void main (String... args)
{
    new ${enclosing_type}().go();
}
 
public void go()
{
    ${cursor}
}

Name:log
Description:Automatically instantiate a log4j static variable for this class. Also import the necessary classes that we need for log4j. Of course we assume that log4j is in the classpath

1
2
3
4

private static Logger s_logger = LogManager
.getLogger(${enclosing_type}.class.getName());
${imp:import(org.apache.log4j.LogManager,
org.apache.log4j.Logger)}

Name:deb
Description:Log4j debug statement (Do the same for info,warn)

1

s_logger.debug("${cursor}");

Name:err
Description:Log4j error. Print an error message and print the stack trace on the console.

1

s_logger.error("An error occurred: ${cursor}", e);

Name:tryf
Description: A variation of the try catch code completion. This one includes finally also

1
2
3
4
5
6
7
8
9

try {
    ${line_selection}${cursor}
} catch (${Exception} ${exception_variable_name}) {
    ${exception_variable_name}.printStackTrace();
}
finally
{
    // ${todo}: Clean up
}

There are many more examples you can think of by yourself. Explore the existing code completions that come with eclipse too. I hope that saves you as much time as it has for me. I will be writing 2 more follow up articles on eclipse. Subscribe to the RSS feed if you would like to keep up to date.