Surprise: Eclipse is me, too!

My last word on the whole e4 thing will not be about e4 at all (since I'm following going through the instructions for the demo, letting the code speak for itself), rather it will be restating what's been said so many times before: Eclipse is me.

Now, I'm not the most active Eclipse committer/contributor (Dave and Doug are doing all the actual work in the XSLT tooling in the WTP incubator), nor am I a prolific, insightful blogger by any standard. Yet, my posting regarding e4 did not go unnoticed within the community. I think that's a sign of good health, and I was pleased to see Mike M following up on it.

What befuddled me a bit however, was finding out Reg Developer linking to the post, essentially using it as a news source, as an exponent of a general sentiment. That was just ... unnerving, out of proportion, and misunderstood. Planet Eclipse is a great medium for following what's going on, but is does not fairly represent the minds of all ~1000 Eclipse committers and the many members doing the hard work. The planet should always be read with that in mind.

Eclipse is you, but take care to express how.

P.S: For a laugh, read the Reg Developer comments, and try not to think of XKCD.

My EclipseCon un-schedule: Day 1

This year, I am also not at EclipseCon.
Rather than four days of Eclipse tutorials, talks, BOFs, and high quality chit-chat, I'm getting what should have been springtime in Denmark. Well, it isn't.
My un-schedule for today went like this:

• 07:00: Why is everybody up now? I'm not running anywhere! Oh, breakfast.
• 08:00: Traffic Ballroom Z: "Model driving gets kids to daycare" 101, and more.
• 10:00: Coffee - I get that.
• 10:30: Managing my small company's general ledger with a cool RCP based ERP (no, that was OOo Calc)
• 12:00: Lunch and Eclipse smalltalk. Minus Eclipse smalltalk.
• 13:00: Improvised BOF meeting with other Eclipse contributors people stuck in line in the hardware store.
• 13:30: Heave 13 sacks (450 kg) of shredded bark mulch into family car. Prepare for contribution as foundation for the coming platform.
• 15:15: Daily General Meeting with kids being picked up from daycare.
  
• 15:30: Check Planet Eclipse for postings on EclipseCon.
• 16:00: "Introduction to PDE/Build", or make that finally updating my XSL workspace for M5. Noticing how "Project > Cleanup..." is still required for combinations of target, project, and CVS changes.
• 16:20: Fight against the snow build-up. It's not supposed to snow now that spring was here.
  
• 16:30: Check Planet Eclipse again. Hmmm.
  
• 18:00: ...

I hope you get the idea... Please enjoy EclipseCon!

"It's the architecture, stupid!"

When I first read the e4 project announcement, I was puzzled as in "Am I misunderstanding something here?". Reading through the early e4 diversity and openness complaints on miscellaneous blogs, I was very relieved to see I wasn't the only one getting (what is now confirmed as) the wrong picture, as to the intentions of the incubation effort (I was even looking forward to Ed Merks' images of unbalanced ecosystems or the proverbial big and small fishes in the pond).

But now we know: OK, e4 is a place to showcase the experimental code and grow ideas about the Eclipse 4.0 platform, not some coup d'etat. OK, the perception is not reality, just unfortunate communication. OK, the platform team wants to solicit feedback from the community. OK, so you would rather show it in code than in colorful diagrams (given the audience, that makes sense).

My day job is in software architecture, and not in Eclipse at all (which makes me a very small fish indeed). However, it also gives me a different perspective in which to view this controversy: It's the architecture, stupid. The future of the Eclipse platform is not just about the code, it's also the scope, the requirements, the stakeholders, the constraints, the APIs, the process, the resources, and it's the dependencies and dependents of the very heart of Eclipse. In that respect, we still don't know anything about e4.
Eclipse is built on a strong architecture, and architecture is all about keeping the stakeholders happy, but it looks as if there's still serious uncertainty with a number of stakeholders:

• What is being worked on here? Are we talking runtime / SWT / RCP - stuff? Is this about the "IDE meat", where a lot of the identified "biggest architectural problems" reside)?
• Why is this going on? Or, which requirements or innovations are going to be driving the effort? Why is this more important than anything else?
  
• When is all this going to happen? (should we expect a 3.5 in 2009?)
• How are you planning to do this without creating adverse effects for stakeholders?
  
• Where will the impact be - will this be a distributed effort? Where will the parts which currently make up the Eclipse Platform end up (in case of a refactoring effort)?
  
• Who gets to decide and prioritize? And implement?
  

(yes, those are Kipling's six honest serving men, inspired by their use in the Zachman EA Framework. Hmmm; Zachman - IBM - conspiracy?)

For humans, a common reaction to change and uncertainty about is to expect the worst, especially if you feel like you are out of the loop. OK, we know now that part of e4 is to find the answers to the questions above, except perhaps the first "who" which I would expect should be the architectural council (whose mailing list is just buzzing with e4 activity right now). There are processes in place to mend this.

But shouldn't we always start with the "why" rather that the "how"?

Think globally, link locally (updated)

Today I attended my first meeting in the local (i.e. Danish) Eclipse users group called Eclipse.dk, today's topic being the use of Eclipse RCP for the primary front-office business-applications in a bank, such as teller systems and in call centers.

In Denmark, banks are rarely among the early technology adopters -- to say the least (I assume this is partly due to the severe regulation in the sector). Not just adopting, but broadly betting on Eclipse RCP for in-house development is thus a bold decision, even when it's warranted and desired by the business users. It goes against the grain of the ten year industry-wide push of browser-based solutions, and didn't happen without some amount of "idea sales"; the architect having to refocusing his/her language to the audiences at hand (easier when you stick to the facts and leave the evangelism behind.)

The meeting featured a presentation, a demo, and lots of discussions about design trade-offs, architecture, etc. amongst the apprx. 25 attendees. Useful, inspiring, and not doable by IRC! This kind of face-to-face meeting around such a focused subject is a rare event indeed.

My message is thus: Find and join your local Eclipse user group - if you can't find one, go start one yourself. Show up, share, discuss, link up with people with similar interests.

Update: The Eclipse Wiki contains a page of local communities.

They grow old so fast...

Two years ago, I initiated the Mule IDE project, an Eclipse plugin for the Mule ESB. It was started as a hobby project back when "Mule UMO" was mostly a (popular!) community effort with a few dedicated developers working on it.

Since then, things have really taken off for the Mule ESB, and it's now the centrepiece of MuleSource, Inc. - arguably an Open Source success story. Meanwhile, Mule IDE hasn't received too much attention since the 1.3 version from February '07 (as I have too many other (offline) things going on)

But that's all changed, since Ted and Moosa joined the Mule IDE project. And now Mule IDE 1.4.3 is out, with none of my doing whatsoever. Congratulations, I'm looking forward to seeing what's coming next!

But at the same time, I can't help feeling that it's a little bit like sending a child off to school...

On diversity and contributors

Much has been blogged recently about diversity in the project members and committer communities, and of the willingness to embrace contributions from the outside.

While I agree with what appears to be a consensus - that diversity is "A Good Thing"(TM), I would like to point out that there are other kinds of diversity than what can be calculated from the host-part of committers' email addresses.

One such diversity is that of contribution patterns. I would guess that most module owners work on their modules to fulfill the plans of both their daytime employers and the OSS project itself. Many contribute to one or more Eclipse projects on a regular basis, some may ONLY work on Eclipse itself.

And then there's people such as myself, who can hardly even qualify as software developers on "the day job". I just contribute minor stuff here and there: The odd bug report, a patch, technical clarification on some unexpected (but correct) behavior. When I get hit by a bug, and I'm able to, I'll gladly dig down to the bottom of the implementation of some plugin or other and fix it. But I rarely stay at the bottom for long - and thus I'm hardly committer material.

At any rate, I'd say that ad-hoc contributions are useful:

• A fixed bug is a good bug, even if you didn't know it was there in the first place.
  
• They sometimes add a missing piece of functionality which all downstream users may benefit from (unplanned).
  
• They serve as a litmus-test for code clarity and quality. If a "total stranger" can find and fix a bug without prior knowledge of the code base, that's a good sign. People giving up after an initial glance is a bad sign.
  
• They sometimes help to cross pollinate, inspiring adoption of useful code from other projects. So many software bugs come from re-inventing the wheel when it could just be imported.
  

The Eclipse projects I've been in contact with (mostly WTP, some EMF) welcome this kind of contribution with open arms, typically respond quickly, and give good, positive feed-back, even for rejected bugs/patches/ideas. That leads me to conclude that this kind of diversity of contribution is definitely appreciated by the projects, even if 95% of the people supporting it come from the same company.

As I see it, while the diversity of committers is crucial for the long-term survival of a project, nurturing the "satelite contributors" helps to keep the project healthy, too.

Monkey see, abe gør

(Abe gør = monkey do, in Danish)

I'm lazy, sure, no denying that. Sometimes I'm a bit too lazy, especially when programming -- and a while ago, I was too lazy to extract all the strings of a web application into a message bundle. Anyway, the application was only going to be in one language, so why bother?

Then, when scope crept in on me, and the inevitable second language had to be added, I suddenly had ~45 JSP/facelet pages to go through and extract all the strings. And, this being a hobby effort, I had no other developers to pass the tedius jobs on to.

The procedure is as follows:
* Go to the target JSP page
* Select the text to externalize
* Cut
* Switch to the resource bundle's text editor
* Enter the desired message key name
* Paste the text
* Copy the chosen message key name
* Switch back to the JSP page
* Enter the text output text boilerplate code and the key name, such as #{messages['LoginPage.label.userName']}

All in all, it added up to about 400 strings! No way I was going to do that by hand. Enter Eclipse Monkey, a "macro" system for Eclipse, where you can run JavaScript scripts (or other engines) within Eclipse without having to deal with making your own plugins and whatnot. But building a "localization macro" with Eclipse Monkey was harder than I thought, but then again it was my first ever script for the Monkey.

First up was the choice of which monkey DOMs I had available. A Monkey DOM makes one or more objects available to the scripting context, serving as an interaction point into Eclipse. You may also reference classes directly, but only in a few select packages (due to the access restrictions managed by OSGi). Although I was tempted to write one myself, I could make do with one of the builtin DOMs (org.eclipse.eclipsemonkey.lang.javascript), since I only needed access to the text editors, as in the variable "editors" below.

Second was the need for configurability. My Monkey script needed to know which file to copy the lozalized string to, but I have yet to find a mechanism for storing user-specific script parameters other than in the script itself. So I put the filename into a variable (destinationFileName), easy to adjust for anyone. The replacement template is specific to JBoss Seam, you can also tailor this to your need.

Third, I chose a viable keyboard shortcut, and out the file into the scripts directory in my project. The rest, as they say, is just code:

--- Came wiffling through the eclipsey wood ---
/*
 * Menu: Localization > Extract String
 * Key: SHIFT+F12
 * Kudos: Jesper Steen Møller, Paul Colton (Aptana, Inc.)
 * License: EPL 1.0
 * DOM: http://download.eclipse.org/technology/dash/update/org.eclipse.eclipsemonkey.lang.javascript
 */

function askKey(oldKey, targetString) {
   dialog = new Packages.org.eclipse.jface.dialogs.InputDialog(
          window.getShell(), 
          "Localization Key",
          "Enter the localization key for string '" + targetString + "' ?",
          oldKey, null)
   result = dialog.open()
   if (result == Packages.org.eclipse.jface.window.Window.OK) {
       return dialog.getValue()
   }
}
// Simple info dialog
function show(text) {
   Packages.org.eclipse.jface.dialogs.MessageDialog.openInformation(
           window.getShell(),
           "Extract String",
           text
       )
}
// Simple error dialog
function showError(text) {
   Packages.org.eclipse.jface.dialogs.MessageDialog.openError(
           window.getShell(),
           "Extract String",
           text
       )
}

function main() {
  // Change this for using a different editor source
    var destinationFileName = "messages_da.properties";
  var destinationEditor = undefined;
  var sourceEditor = editors.activeEditor;
  var valid = false;
    for each( editor in editors.all ) { 
      if (editor.title == destinationFileName) {
         destinationEditor = editor;
         valid = true;
      }
    }
    if (! valid) {
    showError("No editor is open for " + destinationFileName);
    }
  if (valid && (sourceEditor == null)) {
    valid = false;
    showError("No active editor");
  }
  // make sure we have an editor
  if (valid && (sourceEditor === undefined)) {
    valid = false;
    showError("No active editor");
  }
  // insert replacement
  if (valid) {
      var range = sourceEditor.selectionRange;
      var offset = range.startingOffset;
      var deleteLength = range.endingOffset - range.startingOffset;
      var source = sourceEditor.source;
      var replacement = source.substr(range.startingOffset, deleteLength);
      
      replacement = replacement.replace(/(\r)?\n/g, "\\n\\" + destinationEditor.lineDelimiter + " ");
      
      var keyLine = findKeyLineNo(destinationEditor);
      var oldKeyName = "key" + keyLine;
      
      if (keyLine >=0 ) {
        var theLine = lineContents(destinationEditor, keyLine);
        oldKeyName = theLine.substring(0, theLine.indexOf('='));
      }
      
      var key = askKey(oldKeyName, replacement);
      if (! (key === undefined)) {
        var text = "#{messages['" + key + "']}";
        
        // apply edit and reveal in editor
        sourceEditor.applyEdit(offset, deleteLength, text);
        sourceEditor.selectAndReveal(offset, text.length);
        
        // now copy the replacement text into the property file
        var curLine = destinationEditor.getLineAtOffset(destinationEditor.selectionRange.endingOffset);
        var replacementOffset = destinationEditor.getOffsetAtLine(curLine+1);
        if (replacementOffset < 1) replacementOffset = destinationEditor.sourceLength; 
        var replacementText = key + "=" + replacement + destinationEditor.lineDelimiter;   
        destinationEditor.applyEdit(replacementOffset, 0, replacementText);
        destinationEditor.selectAndReveal(replacementOffset, replacementText.length);
      }
  }
}
// Get the string contents of a line
function lineContents(anEditor, lineNo) {
  var firstOffset = anEditor.getOffsetAtLine(lineNo);
  var lastOffset = anEditor.getOffsetAtLine(lineNo + 1);
  var s = anEditor.source.substr(firstOffset, lastOffset - firstOffset);
  //alert("Contents of line " + lineNo + ":" + s + " (" + firstOffset + "," + lastOffset + ")");
  return s;
}
// Finds the nearest line which starts a key=value 
function findKeyLineNo(anEditor) {
  var beginLine = anEditor.getLineAtOffset(anEditor.selectionRange.startingOffset);
  
  // Search up...
  var i = beginLine;
  while (i >= 0) {
    if (lineContents(anEditor, i).indexOf('=') > 0) return i;
    --i;
  }
  var lastLineNo = anEditor.getLineAtOffset(anEditor.sourceLength);
  var i = beginLine + 1;
  while (i < lastLineNo) {
    if (lineContents(anEditor, i).indexOf('=') > 0) return i;
    ++i;
  }
  return -1;
}
--- And burbled as it ran! ---

The funny header and footer makes it easy to paste the script into you Eclipse workspace, just mark everything (including the headers) and choose Scripts > Paste New Script, and you're flying.

The morale is: Look for script that do similar things, and experiment from there.