As I mentioned yesterday, tools such as the Memory Analyzer demonstrates just how dominant Eclipse is in the IDE space. And while Eclipse has many useful tools, nothing has changed the face of the IDE as much as the Mylyn project. Mylyn is more than just a cool plug-in for Eclipse, it completely changes the way developers work, bringing your productivity to a whole new level.

On the way back from EclipseCon, I had the privilege of sitting next to David Green, one of the Mylyn committers and the developer behind the Mylyn WikiText tool, number 4 on my Galileo Top 10 List.

Like all good Eclipse technology, Mylyn WikiText is both an extensible framework and an exemplary tool. The tool provides:

• Editor for wiki files
• Mylyn task editor integration
• Ant Tasks for processing wiki text file
• API

The Task Editor integration is probably the most noticeable use of WikiText. Mylyn users can now use WikiText markup directly in their task editor providing easier to understand bug reports.  For example, you can take a rather bland bug report:

And turn it into:

In addition to the markup, Wikitext supports a number of editing features including spellchecking, and content assist.

David’s Wikitext tool can be used outside Mylyn too to author arbirary text file and generate HTML, Docbook or eve Eclipse help content.

In addition to Wikitext, Mylyn has a whole host of new features. Thank-you David for Wikitext, and congratulations Mik and the rest of the Mylyn team for another successful release.

Tags: galileo

With all the great work going on in the Eclipse Run-time space, like the EMF Runtime, RAP, Birt Charting Engine, ECF, Jetty and of course Equinox, I sometimes forget that Eclipse started as an excellent platform for tools. The Eclipse Memory Analyzer project reminded me just how good Eclipse tools are.

All week I have been counting down the top 10 Galileo features that I’m most excited about. Number 5 on my list is the Eclipse Memory Analyzer (MAT). This project was first released in December 2008 and is now part of the Galileo release train. MAT provides a large selection of features to help you analyze Java heap dumps to understand your memory consumption and help remove leaks.

As you may have noticed, many of my posts focus on the simplicity of the new features. The MAT project is no different. Getting started with the Memory Analyzer is a simple 3 step process:

1. Install the MAT tools (optionally install the charting engine too). (Hint: Use p2 for this)
2. Grab a heap dump:I simply used the JMap tool available with my JDK. 12345 was the PID of my Eclipse process.
   $ jmap -heap:format=b 12345
3. Open the Heap Dump
   JMap generates a file called heap.bin

Some of the notable features include:

The reporting of memory leak suspects:

Calculating Retained Sizes (How much memory is used, rooted at a particular object):

Track the pointers back to the GC (garbage collection) roots:

Thread and Stack information:

SQL-like language for querying the heap:

Shout-outs for this go to Andreas Buchen and the entire Memory Analyzer team. Thank-you for guys for such an awesome (and unbelievably useful) tool!

Note: I got these examples by running the memory analyzer on Eclipse, after analyzing a 670 Meg heap. It’s unbelievable, but the MAT heap was only 21 Megs. 21 Megs used to analyze over 1/2 a Gig. How cool is that?

Tags: galileo

As Elias and Darin already blogged, there was a memorable DemoCamp session in Portland Wednesday night.  Thanks to Instantiations for organizing and hosting.

The ECF slides for this are here.  Some of them I didn’t actually have time to show at the DemoCamp, so there’s a little new information there, even for those that were present.

Tags: ecf, eclipse, OSGi

As readers of my blog are no doubt aware, I have been counting down the Top 10 Galileo features that I’m most excited about. Galileo is the name of this years “Eclipse Release Train”, the simultaneous release of 33 Eclipse projects. Galileo will available for download on June 24th, but “Friends of Eclipse” get it sooner. Friends of Eclipse is a donation program setup by the Eclipse foundation.

Support the tools that support you. The best $35.00 you will ever spend.

Number 6 on my Top 10 list is the new Install Into Self option. While many people view the Eclipse SDK as an excellent Java development environment; it’s the extensible nature of this environment that makes it so powerful. Eclipse is assembled from 100′s of plug-ins, and while you may commonly use other peoples plug-ins, the true power of Eclipse comes when you start to develop your own. Before Galileo, the steps for building / testing / deploying / installing your own plug-in were quite cumbersome. This has all changed in Eclipse 3.5.

Using Eclipse 3.5 you can quickly develop your own plug-in (maybe it’s a new static code analysis view or an awesome new twitter client – All the cool kids are building twitter clients these day), and deploy it directly into your running instance. This makes development / testing / deploying much easier and enables all developers to “eat their own dog food”.

I consider this feature a “game changer” as it completely changes the way I work with Eclipse. Kudos for this feature go to Curtis Windatt with help from John Arthorne for p2 side of things. Thanks guys!

Tags: galileo, pde

This Thursday we had a great Galileo DemoCamp in Portland. Pictures from the event are on Gabe’s blog and Darin has posted a summary of all presentations. Thanks to the nice folks at Instantiations and the Eclipse Foundation Portland for putting this together!

You’ll find the slides of my presentation ‘RAP and the Eclipse Download Wizard’  below:

To learn more about creating apps for RCP and RAP from a single source, register for our free webinar on Eclipse Live:

Single Sourcing: Extend your RCP Application to the Web with RAP
July 9th, 2009 at 9:00 am PDT / 12:00 pm EDT / 4:00 pm GMT

Tags: democamp, galileo, rap

The next feature on the Top 10 Galileo Features (according to me) comes from the Eclipse Modeling Project. The Eclipse Modeling Project is arguably one of the most diverse, yet well focused, top level projects at Eclipse.

Number 7 on my list is the EMF UltraThin Diet. In January, the EMF team changed the way a number of fields and lists were generated. Since there are lots of overlap between classes in a hierarchy, and not all the allocated fields are ever used, the EMF UltraThin Diet enables a lazy memory allocation technique and combines many of the duplicated fields. Some estimates reduce the fields in an EObject from 120 Bytes to 12 Bytes!

While the details of this feature are interesting, the way in which one change can impact so many projects demonstrates the power of Eclipse. Many projects on the Galileo release train are built on-top of EMF, and this change will positively impact all downstream projects.  Beyond Eclipse, all users of EMF can apply this diet to their models too.

Ed Merks (with help from Dave Steinberg) get the kudos for this feature. You guys rock!!!

In addition to this change, there are number of exciting things happening in the modeling world. The XText project – A modeling project for creating domain specific languages, parsers, AST-Meta-models and an editor, from a simple EBNF grammar – is one of the most innovative projects in my mind. Also, the integration between Teneo and EclipseLink was one of the highlights of EclipseCon!

Thanks to the entire Eclipse Modeling Project!

Tags: galileo

Awhile ago, I blogged about PDE API Tools and the usage scans feature. In honor of the Eclipse Galileo release, I decided to run the usage scan tool and generate a report against a good portion of the release to see if anything interesting came up. I was particularly looking at what bundles were accessing internal code. I decided to look at the org.eclipse.compare bundle and noticed that PDT had some internal references:

If we dig deeper and look at a particular set of internal references, we notice org.eclipse.php.ui using various classes:

As an API provider (in this case, org.eclipse.compare) you have a couple questions you can ask yourself based on a report like this. Why are my consumers accessing these particular internal classes? Is there API I can point my consumers too that they can use instead of the internal classes? Should I make these classes API or craft API? And so on…

Does anyone else see interesting internal usage?

Do people want to see this type of report run against Galileo and future release trains?

For those who are interested, here’s the build script that I used to generate the report.

<?xml version="1.0" encoding="UTF-8"?>
<project name="api_use_reporting" default="run" basedir=".">
    <property name="baseline" value="/Users/chrisaniszczyk/eclipses/eclipse-galileo" />
    <property name="report_location" value="${baseline}/api" />
	<property name="html_report_location" value="${baseline}/api-html"/>
 
	<target name="run">
	    <apitooling.apiuse
	      	baseline="${baseline}"
	    	proceedonerror="true"
	      	report="${report_location}"
	      	considerinternal="true"
	      	considerapi="true"
	      	debug="true"
	     />
	    <apitooling.apiuse_reportconversion
	      	htmlfiles="${html_report_location}"
	      	xmlfiles="${report_location}"
	      	debug="true"
	    />
	  </target>
</project>

Enjoy.

Tags: galileo, pde

Just 1 week until the Galileo release, and I’m using this opportunity to count down the top 10 features in Galileo that I’m really excited about. Previously I talked about the improved tooling support in the compare editor, and the enhancements to the Java 2 JavaScript bridge. Number 8 on my top 10 list is the new RAP Look and Feel.

For those of you unfamiliar with RAP — the Rich Ajax Platform — it’s a project that brings Eclipse development models to the web. This means that you can use your eclipse expertise (APIs, programming patterns, and even OSGi bundles) on the web. As developers, we become very familiar with our tools / technologies and are able to focus on the hard business problems and move away from the inane technical details. Doug referred to this as Java is making me dumb, but the truth is Doug is not dumb, he was simply out of practice with some of the finner points of C++.  Fred Brooks would call this accidental complexity, and the more time we spend dealing with accidental complexity, the less time we spend solving the real problem. (In Doug’s case, he spent valuable time focusing on the peculiarities of C++ constructors, when he should have been focusing on matrix multiplication — and how to use matrix multiplication to make him millions). This same phenomenon happens in the web space where developers are forced to continually switch their languages and programming patterns.   By using RAP for web applications, you remove the cognitive burden of switching technologies, a switch that slows productivity.

One of the common complaints about RAP was that it doesn’t look like a web application.  Many developers have realized the benefits of unifying their web and desktop programming models, but in the end there are fundamental differences between how we interact with the web vs. how we interact with the desktop.  For example, you can create a simple mail application (from the same Java code) that runs on the web and in a browser:

But clearly re-sizable shells (and a close button) are not common place on the web.  With the Galileo release, you can now easily change the look for your RAP application simply by including 1 additional bundle in your launch configuration.

Holger Staudacher gets the shout-out for this new Galileo feature.  Great work Holger!  In addition to this, there are a whole bunch of new features in RAP this year.   Check out the new and noteworthy from the Milestones:

• New for RAP 1.2 M7 (May 11, 2009)
• New for RAP 1.2 M6 (March 23, 2009)
• New for RAP 1.2 M5 (February 16, 2009)
• New for RAP 1.2 M4 (January 12, 2009)
• New for RAP 1.2 M3 (November 19, 2008)
• New for RAP 1.2 M2 (October 8, 2008)

I also have to give kudos to Benjamin Muskalla, Rudiger Hermann, Elias Volanakis, Ivan Furnadjiev, Frank Appel and Ralf Sternberg for all their great work on RAP this year.

Tags: galileo, rap

With Eclipse 3.5 — Galileo — just around the corner, I am counting down the top 10 features I’m most excited about.  Number 9 on my list is the improved Java 2 Javascript bridge available in the SWT Browser widget.  The SWT Browser now supports both calling Javascript from Java and calling Java from Javascript.  Leveraging the growing number of “Web Widgets” (Google maps for example) in your rich client applications is now very easy.

By tightly integrating the contents of the browser with the application, you can properly respond to events and update the UI accordingly.  For example, if you resize the window, the map can be resized and Google Maps updates the controls automatically.  Also, when you click Where Am I, the location at the center of the map is recorded in an SWT List widget.

The code for this is quite simple and the SWT team has even provided snippet 307 and 308 to help you get started.

Kudos for this feature goes out to Grant Gayed.

The code for my example is below:

package org.eclipse.swt.snippets;
 
import java.io.File;
import java.io.IOException;
 
import org.eclipse.swt.SWT;
import org.eclipse.swt.SWTError;
import org.eclipse.swt.browser.Browser;
import org.eclipse.swt.browser.BrowserFunction;
import org.eclipse.swt.custom.SashForm;
import org.eclipse.swt.events.ControlEvent;
import org.eclipse.swt.events.ControlListener;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.List;
import org.eclipse.swt.widgets.Shell;
 
public class Snippet308 {
 
 static List list;
 static Browser browser;
 public static void main(String [] args) throws IOException {
    File f = new File("map.html");
    Display display = new Display();
    final Shell shell = new Shell(display);
    shell.setLayout(new FillLayout());
    SashForm sash = new SashForm(shell, SWT.HORIZONTAL);
 
    try {
        browser = new Browser(sash, SWT.MOZILLA);
        browser.addControlListener(new ControlListener() {
 
          public void controlResized(ControlEvent e) {
              browser.execute("document.getElementById('map_canvas').style.width= "+ (browser.getSize().x - 20) + ";");
              browser.execute("document.getElementById('map_canvas').style.height= "+ (browser.getSize().y - 20) + ";");
          }
 
          public void controlMoved(ControlEvent e) {
          }
	});
    } catch (SWTError e) {
        System.out.println("Could not instantiate Browser: " + e.getMessage());
        display.dispose();
        return;
    }
 
    new CustomFunction (browser, "theJavaFunction");
 
    Composite c = new Composite(sash, SWT.BORDER);
    c.setLayout(new GridLayout(1, true));
    Button b = new Button(c, SWT.PUSH);
    list = new List(c, SWT.BORDER | SWT.V_SCROLL | SWT.H_SCROLL);
    list.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
    b.setText("Where Am I ?");
    b.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            double lat = ((Double) browser.evaluate("return map.getCenter().lat();")).doubleValue();
            double lng = ((Double) browser.evaluate("return map.getCenter().lng();")).doubleValue();
            list.add(lat + " : " + lng);
        }
    });
 
    browser.setUrl(f.toURI().toString());
    sash.setWeights(new int[] {4,1});
    shell.open();
 
    while (!shell.isDisposed()) {
        if (!display.readAndDispatch())
            display.sleep();
    }
    display.dispose();
 }
 
 static class CustomFunction extends BrowserFunction {
    Browser browser = null;
    CustomFunction (Browser browser, String name) {
        super (browser, name);
        this.browser = browser;
    }
    public Object function (Object[] arguments) {
        double lat = ((Double) arguments[0]).doubleValue();
        double lng = ((Double) arguments[1]).doubleValue();
        list.add(lat + " : " + lng);
        browser.execute("document.getElementById('map_canvas').style.width= "+ (browser.getSize().x - 20) + ";");
        browser.execute("document.getElementById('map_canvas').style.height= "+ (browser.getSize().y - 20) + ";");
        return null;
    }
 }
}

The map.html file is here:

 
    <script src="http://maps.google.com/maps?file=api&amp;v=2&amp;key=abcdefg&amp;sensor=false" type="text/javascript"><!--mce:0--></script>
    <script type="text/javascript"><!--mce:1--></script>

Tags: galileo

The Eclipse 2009 Release — codename Galileo – will be available in about 10  days. To help countdown the final push, I have decided to review my Top 10 Galileo features. I need to stress that these are my top 10 features. On a daily basis I make heavy use of the Eclipse SDK, Mylyn, Modeling and RAP, so my top 10 comes from these projects.

Number 10 on my list is the enhancements to the Java Compare editor.  I spend a great deal of time creating and submitting patches. With the compare editor, can can check — and double check — exactly what I’m submitting. However, in the past when I found a problem (or needed to review the code), I had to switch back to the Java editor. Once I had fixed the problem, I then created a new comparison and continued the process.

With the enhancements to the compare editor, my patch management process is more streamlined. Now I can do all my review / fixes in one editor without constantly switching tools. The Compare editor now supports:

Shout-outs for this go to Tomasz with help from Dani. Thanks guys!!

Tags: galileo