Web developers should have web-centric tools for development. That seems
like a perfectly logical thesis, but in actual practice web developers are
chained (figuratively) to their desktop with tools meant for standard
development. The Eclipse Project is looking to change that with Orion, a web-based set of tools
for developing web applications. It's still in very early stages, but is showing a lot of promise.
The Eclipse project announced Orion in early January, and pushed out a hosted implementation in March. The initial contribution came from IBM's original Eclipse team as a "seed" to kick things off. The latest release, Orion 0.2 M7 was released at the beginning of May.
Orion is completely separate from the Eclipse IDE that many developers
are already familiar with. Orion is a set of loosely coupled components
Java (using Jetty and Equinox). According to the Orion
architecture overview, the vision for Orion is to feature browser-based
tools that interact with data stored locally or to access data hosted in "the cloud" via REST APIs. The client is dual-licensed under the Eclipse Public License (EPL) and Eclipse Distribution License (EDL). The server is available only under the EPL.
This isn't the first web-centric effort from the Eclipse Foundation. A web-based Eclipse 4.0 prototype was demonstrated at EclipseCon in 2008. That was abandoned, however, and Orion is a new codebase that contains very little from the current Eclipse codebase.
Given that the world already has plenty of IDEs (like Eclipse) and
development tools, you might wonder why it's necessary to create one that
runs in the browser. Eclipse developer Boris Bokowski has a simple answer
to that — Orion isn't meant to be an IDE. According to Bokowski, developers
already use a lot of web-based software as part of development:
Bugzilla, code review tools like Gerrit, reading documentation online, and
code repositories with web-based tools like GitHub. But then they use
desktop tools like a text editor or full-blown
IDEs for actually coding and debugging — which isn't
optimal. Bokowski describes it this way:
So all we are suggesting is that you move the remaining software
development activities to the browser, too. [...]
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.
What's the advantage to that? Generally the same advantages that one
derives from most web-based applications: Developers don't have to install
an IDE, nor maintain one (assuming they're using a hosted instance provided
by someone else). It fits well with web development, since the developer is
already using the browser for testing and debugging. Being developed in
should be able to extend and contribute to the project as well.
Orion is also being designed to be very extensible, with a plugin
architecture that's already working. However, Orion handles plugins a bit
differently than you might be used to. Instead of installing a plugin on
the server where Orion is hosted, Orion
plugin. This eliminates the need for developers to have server access to
install plugins they wish to use. Instead they can simply link to (or
create) plugins and point to them.
The plugins, when installed, are persistent — that is, developers won't have to re-install plugins after pointing Orion to them the first time. One thing that seems to be missing, though, is any kind of vetting of the plugins. At the moment, Orion doesn't seem to have a plan for ensuring plugins are not malicious or providing a repository of known-good plugins. One hopes this will be added if the Orion community grows.
The Orion developer
principles recommend reusing existing tools rather than inventing new
ones whenever possible. Case in point, Orion is working
on Firebug integration, and having Firebug invoke
Orion as an editor.
Getting and using Orion
Developers have a couple of options for using Orion. One is to sign up for the hosted version of Orion, called OrionHub. You might want to hurry, though — according to the beta announcement, the service is open to the first 5,000 developers who sign up. Additional accounts may, or may not, be made available as the Orion community expands — the announcement doesn't make any promises.
Alternately, you can download and install Orion on your own machine. The project offers builds for Windows, Mac OS X, and (of course) Linux. It is a slightly more involved affair than simply signing up for OrionHub, but it does provide more control and is much better for those who would like to hack on Orion as well as make use of it. One note of caution for those running their own instance of Orion — right now there's no upgrade or update functionality in Orion. This means that, as a rapidly developing project, you'll probably want to update it often but you'll be on your own for backing up user accounts and data. There's a little guidance on the wiki about wiping server data for demos of Orion that you can use to figure out how to back up accounts and data, but it's all up to the user at this point.
After spending a bit of time with Orion to see what it has to offer,
I have concluded that it has some growing to do before it's going to be suitable
for many users. And, in fact, the FAQ
for Orion says as much. Orion isn't yet ready for "real work," though
the Orion team is using it themselves.
Orion does have quite a few features for working with Git repositories, and some basic functionality for pushing changes from OrionHub into GitHub projects. But it's still evolving. You need to use another Git client to actually push or pull changes. Orion also lacks any support for other version control systems, so users of Subversion, Mercurial, or any other VCSes are out of luck for the time being.
Orion going forward
The next milestone for Orion
is planned for June 3rd. This release should simplify server configuration,
move to Dojo
1.6, and provide extension points for content assist, keybindings, and
working with different editors. Orion is already attracting some interest from Mozilla, with an eye towards using the Orion editor in the Mozilla codebase. From the looks of the Orion development list the project is fairly active in general.
For now, Orion is not a tool for serious development. It has the beginnings of a competent development environment, but it's not something that one would trust for real projects now, or likely in the next year. If you're hoping to use it to knock out your next web site, you had better have low expectations or be willing to work with relatively primitive tools. However, if the concept of a browser-based web development environment stirs your fancy, then the Orion project is open for contributions. It should be interesting to see how the project develops, and if (or when) the browser-based model overtakes desktop tools.
to post comments)