Moving to Germany

After six years in Ottawa, working for IBM, I have decided to move back to Germany with my family. Today was my last day in the office, and on Saturday we will be embarking on a longer vacation, driving from Ottawa all the way to Vancouver, before we board our one-way flight to Germany.

We'll try to pass by Orion, AB :-)

I may be able to remain an Eclipse committer, but it will definitely no longer be my main job. I decided to join Google at their Munich office at the end of the summer, and expect to be working on web-based tools there.

Over the last year or so, I spent most of my time getting the Orion project off the ground, which is about web-based tools and how tools from various servers can work together. We are code complete for our first tech preview release, which will be announced in a few days. The goal for this first release was to get to the point where we can self-host, and the team will from now on use Orion itself to develop Orion. I've been doing this for the last few weeks already, and it's a lot of fun to never leave the browser, from filing a bug, fixing and testing it, committing and pushing the fix, and closing the bug. There is a lot of potential for Orion, and I will be closely watching its progress.

I will also try this chocolate (thank you, Steve!)

It's been a blast. I've been very fortunate to work with some of the smartest people in the industry, both here at IBM as well as in the Eclipse community.  I have learned so much. Thank you!

Don't forget to vote!

If you are an Eclipse committer, please take a few minutes of your scarce time to vote in the Eclipse Board elections. There are only three days left, voting ends on Friday March 11th at 3pm Eastern time!

If you are an individual (not employed by a member company) committer: Please click here, and sign and send the membership agreement to the Eclipse Foundation. This will enable you to vote in the upcoming board member elections. There is no cost, and as an added bonus, the Eclipse Foundation is now sending really nice thank-you e-mails to those individual committers who become members.

Why should you do that? Let me try to explain with a diagram:

(thanks, diagrammr!)

Here is the same information in text form, copied from the election process web page:

• Each Committer Member gets one vote. Note that committers who are employees of Member companies have all the rights and privileges (including voting) of a Committer Member.

• Individual committers must join the Eclipse Foundation as Committer Members by signing the Membership Agreement in order to be allowed to vote.

• All committers who are employees of a single company have their votes collapsed into a single vote in the committer elections.

That's right: every vote from an individual committer member (someone who signed the individual membership agreement) is worth exactly the same as the votes from all EclipseSource committers combined, or all Oracle committers combined, or all itemis committers combined, ... you get the idea.

That seems a little bit weird, but it sort of makes sense considering the situation back when the rules were made: IBM had way more Eclipse committers than everybody else, and there was a risk that they would determine the committer representatives, who then could be seen as voting in favour of IBM - leading to an imbalance at the board of directors. So when you think about it, the rules ensure that the committer representatives election is truly independent of any potential company interests.

So, to repeat, if you are an individual (not employed by a member company) committer: Please click here, and sign and send the membership agreement to the Eclipse Foundation. It's free (of charge), it will enable you to vote in the upcoming board member elections, and as an added bonus, the Eclipse Foundation is now sending really nice thank-you e-mails to those individual committers who become members.

More votes mean more weight for the committer representatives on the Eclipse Board of Directors. And if you are an individual committer, your vote weighs a lot.

Thank you!

New features in Orion M5

We shipped a new milestone of Orion yesterday. For those who haven't heard about Orion yet, its goal is to build developer tooling that works in the browser, at web scale. The idea is to exploit internet design principles throughout, instead of trying to bring existing desktop IDE concepts to the browser.

There are two new features in this new milestone (download) that I would like to highlight:

• the ability to install, as a user, editor actions supplied by third-party web sites, and
• a very early integration with Firebug.

Editor Actions

In any decent editor, you'd want the ability to customize - adding new key bindings, new functionality, and changing its look. We have a first implementation that covers the first two of these, with an interesting twist: Editor actions can come from anywhere on the Internet!

Here is our favourite example, code formatting functionality for JavaScript files: Have a look at http://jsbeautifier.org, which hosts a JavaScript formatter that is implemented in JavaScript, and has been developed independently of Orion. It was astonishingly easy to add a little bit of glue code around it to make it available as a command in the Orion editor. Thanks to Einar Lielmanis, the author of this JavaScript code formatter, the resulting code is even hosted at jsbeautifier.org!

To make the command available in your local installation of Orion, you would go to http://localhost:8080/view-registry.html, which is a special page showing your installed plugins. Enter http://jsbeautifier.org/orion/jsbeautify.html in the text box and click on Install. The new plug-in should now be listed in the tree. Now navigate back to the Orion code editor, or hit reload on an existing Orion code editor in another tab, and enjoy the new action available in your editor's toolbar. You can read more about this in Simon's blog - he implemented a lot of the frameworky stuff to make this possible.

This is a humble start of being able to pull functionality from all over the web into your development environment, which itself is web-based. Note that the server wasn't involved at all!

One of the next steps will be to add this extensibility to our navigator as well, and to expand what's possible from an editor action. Currently, editor actions see the selected text, the complete editor buffer, and the start and end of the current selection. They can change just the selection, or the complete buffer and the current selection. With just this minimal API, there is already a lot you can do - implement traditional editor actions, but also navigate within the editor buffer, change the contents of the entire buffer, or even contact a server for more heavy-duty processing.

If you have interesting ideas for what you could do with this, contact me (on Twitter, the #eclipse-orion channel on IRC, or the Orion development mailing list) and I'll give you an account on our demo server at http://orion.eclipse.org - we are slowly adding users there - so far it's by invitation only.

Firebug Integration

If you are doing web development, Firebug is one of the indispensable tools these days. It does much more than the usual code debugger: yes, it lets you set breakpoints, single-step, and inspect variables visible from your stack, but it also supports monitoring HTTPS requests, inspecting the browser's DOM, looking at CSS styles, and more.

So instead of implementing some kind of debugger inside of Orion, it would be much better to integrate with existing debuggers that already exist. The question of course is, what does it mean to integrate? We have two main "integration points" in mind: being able to open the Orion editor on a file you see in Firebug, and synchronizing breakpoints between Firebug and Orion.

So far, we've worked on the first one only, as a start. It involved a little bit of code on the Orion side, and a little bit of code on the Firebug side. Thanks a lot to John J. Barton, the Firebug lead, for working with us on this! To try it out, you need to install a Firebug 1.7 alpha version as well as a Firebug extension called Dyne. The detailed instructions are on the Firebug wiki. Once installed, you should be able to open http://orion.eclipse.org/file/org.eclipse.orion.client.core/static/view-registry.html while Firebug is active. Open the script panel, you will see a new button "Edit". Clicking on this button opens the Orion code editor in a new browser tab.

Clearly, there is still ways to go before this flows nicely, but it's a great start. What I like in particular is that this is all based on an extra header Orion is sending, from which Firebug can construct the URL which contains the editor. This means that any web-editable resource could be edited in this way, just by adding custom headers - there is nothing Orion-specific that had to be put into the Firebug code base!

Looking Ahead

Both of these features illustrate the direction we want to take with Orion, and they align perfectly with our development principles. I'll quote two of them here:

Reuse existing technologies - Don't re-invent the wheel if one already exists that we can integrate (through HTTP, or as open source that we consume), even if we could build a better wheel ourselves.

Low barrier of entry for adopters - We don't want to force people to have to re-write code just so that it fits into Orion, nor do we want them to have to re-write just so they can use one of our components.

Looking ahead, here is our list of ideas for additional integrations with existing web-based services:

• Paste selected text to pastebin.com.
• Create a new Gist from the current editor buffer.
• In the navigator, add an action to smush (remove unnecessary bytes from) an image.
• Multi-select a few files and click on an action to generate a CSS sprite.
• Upload the current editor buffer to codepad, and insert the result from running the code at the bottom of the editor buffer.
• Send files to the W3C validator.
• Look up a word in a thesaurus and display alternative names.

I'd love to hear your suggestions. What should we add to the list? What should we work on first? Would you be interested to work with us on a similar integration? You can contact me on Twitter, the #eclipse-orion channel on IRC, or the Orion development mailing list.

Orion

Today, the Eclipse project is embarking on a journey towards web-based development tooling. We don't have too much to show except some initial code written by members of the original Eclipse team from IBM (including myself), a new name "Orion", and a gleam in our eyes.

The initial code is meant to be a seed. What we have today is a fast and scalable code editor that runs in all major browsers, plus some code around it for navigating files and folders, and doing full-text search. This is a humble start, something to kick things off. Longer term, our vision is to enable integration between all kinds of open web-based tools. Have a look at our wiki pages if you want to learn more about Orion.

But wait... "Why would I want to run an IDE in a browser?"

You probably wouldn't. IDEs are big honking applications that take a while to load, use up all your computer's resources, and come loaded with features that you don't even know existed. Believe me, I helped build one of them. Although the Platform is not to blame really, it's the hundreds of plugins that use up all the resources ;-). Anyway, you wouldn't want to jam all that into a single web page or browser tab.

What you would do is use a web browser to access functionality that is important to you as a software developer. Chances are you're already doing this today! For example:

• using a web-based bug tracking system like Bugzilla
• monitoring your build using a web-based tool like Hudson
• reviewing code changes using a tool like Gerrit
• reading documentation and searching for code snippets using a browser
• browsing other people's code repositories using services like GitHub.

So all we are suggesting is that you move the remaining software development activities to the browser, too. Long term. Very long term if you want. Those who get a lot of value out of the current desktop based IDEs should probably continue to use them for a while, or forever. In the case of Eclipse, the past ten years have seen a tremendous amount of investment in tools that run as plugins in Eclipse, and I wouldn't recommend throwing all that out of the window.

But if you don't get a lot of value, for example if you are doing client-side web development, all you need in addition to the above browser-based tools is:

• a decent code editor,
• a way to navigate your files and folders,
• a way to version-control your files,
• and a debugger.

This is exactly what we're trying to build first. We have a code editor and a way to navigate files and folders, we started working on a Git integration, and for the debugger we plan to integrate well with Firebug.

For this to make sense as a way to develop software, you'd want all those browser-based tools to work together. Ideally, you'd want something similar to the tight integration you typically get from a classic IDE, but without building another IDE. We want to build something that works well with existing tools out there on the web, and we cannot ask others to buy into a new programming model that we may come up with. Therefore, our approach has to be based on well-proven web architectures - using hyperlinks to navigate between different tools and resources, making data accessible in a RESTful way, and using web technologies like HTTP, JSON, OAuth, OpenID, and others.

Over the next few weeks and months, we hope to sign up others who would like to work with us on the vision, the development principles, the architecture, and the code. The intent is to start a new project at eclipse.org soon - see also Mike Milinkovich's blog post on Orion for more information on the project creation aspect. Until then, the code is going to be developed in the e4 incubator project, which is pretty open to contributions from anyone. If you are interested in participating, let me know.

If you've read this far, you might just be the person we've been waiting for. Read our wiki pages, download the code and try it out, or join us on IRC, we're using #eclipse-orion on irc.freenode.net.