It seems that I’ve been reading a lot of “Ubuntu Experience” blog entries lately. I decided that, with the arrival of my new laptop, I’d do the same.

I recently acquired a brand spanking new Dell Latitude D820 laptop. It’s quite nice and is seriously loaded. The installation of Ubuntu was painless. I quite like their concept: the Ubuntu CD boots your machine into a more-or-less complete working Ubuntu desktop; from there you can install. This is nice, because it gives you a chance to determine how much trouble you should plan on dealing with (if, after booting the CD, your monitor isn’t quite right, for example, you know that you’re going to have to spend a little time sorting that part out). In my case, the initial boot and the installation process was very smooth. It even properly detected and configured my super deluxe GL-6000 widescreen LCD.

I initially installed Ubuntu 6.10 because I happened to have that handy on a disc. After installing, I was prompted to upgrade to 7.04 (Feisty Fawn) and did so. The upgrade process worked flawlessly.

I installed Eclipse 3.3M6 along with Mylar and Web Tools from the Europa update site, and the latest version of the PHP Development Tools (PDT). I also setup the XAMPP LAMPP stack. I use this combination of software to work on the eclipse.org website. Aside from some bizarre configuration issues getting a small collection of virtual hosts working on Apache, everything went very well.

I recall reading somewhere that it’s probably not a good idea to move an Eclipse workspace from one workstation to another. I can’t remember where I read that, but I decided to try it anyway. All of the workspaces that I’ve copied from my old Windows laptop appear to work fine on Ubuntu. My first project with the new configuration—to finally automate the population of a test resources database for local testing (available in the phoenix project under “resources”)‐was successful.

Ubuntu’s “Synaptic Package Manager” has a package for Eclipse 3.2.2 that I haven’t checked out yet, but I’ll probably add that to my list of things to try at some point in the future. It’s nice to see that the forward-thinking folks at Ubuntu have chosen to include such highly-regarded world-class software.

I also installed Eclipse 3.3RC2 and have started migrating my projects over to it. Again, everything is running without problems.

Not everything has been perfect. At first, I had trouble getting Skype to hear me. It turned out to be PEBKAC that was easily resolved once I found the “Capture Mux” setting in the volume controls. I had some trouble finding a driver specific to my laser printer; I solved that one by using a generic PCL5e driver that my friend Google helped me find. I haven’t yet sorted out the wireless access since my hardware doesn’t seem to support 802.11b (which is all I have running in my home). I’m a little worried about this last part as I’m pretty sure that a lot of places that I visit haven’t moved on to later versions of the standard. Based on some cursory searches, I’m pretty sure that I’ll be able to sort out the wireless (I’m sure that I can pick up an 802.11b PCMCIA card for cheap). I also have to sort out the process of connecting this beast to an external projector.

Probably the biggest roadblock was email. At the start of this little experiment, I had about two years worth of email stored in Outlook. I installed Thunderbird 2.0 on my old laptop (still running Windows) and used Thunderbird’s import function to copy all my messages and addresses from Outlook. I then copied the resulting folders over to my home directory in Ubuntu. It worked flawlessly.

All-in-all, the experience has been positive. I’ve been noticing a bunch of little things that bother me. Windows still has way better polish, but Ubuntu is catching up. I find Ubuntu very usable.

A few weeks ago, at Eclipse Forum Europe (EFE), I presented a talk titled “Test First Development Using Eclipse”. I’m doing the talk again, only this time in a webinar format. The webinar runs tomorrow (Wednesday) at 11h00 EDT (15h00 GMT). Register now!

I’m not planning on changing any of the materials I presented at EFE, but I do expect to get through more of the demonstrations. The talk was very well-received at EFE; I hope that you’ll be able to make it.

Qi Liang has authored an excellent article titled “Using the BIRT Chart Engine in Your Plug-in” that discusses how you can incorporate BIRT charts into your own applications. This article introduces the basic concepts of BIRT Chart Engine, explains what BIRT Chart Engine is composed of, and illustrates how to create a chart and use it as widget.

A few days ago, I added a link on the Eclipse Resources to a new article on Eclipse RCP written in Arabic (the title translates into something like “The establishment of professional programs through Java / RCP”) by Bashir Storm. I have to say that I think the article looks really cool, despite the fact that I can’t understand a word of it without help from Google Language Tools. The beta support for Arabic to English translation does what I think is a pretty good job.

Frankly, I think that it’s very cool that folks like Bashir and Qi are doing great stuff with Eclipse in far off lands that I dream one day of visiting…

Fairly frequently, I get questions from people asking me just what the heck Eclipse is. It’s difficult to understand what Eclipse is by looking at our website (though that’s something that’s changing—slowly). The problem is that Eclipse is actually pretty hard to define.

Most people know Eclipse as a Java Integrated Development Environment (IDE). This is pretty natural, since that’s the thing that you download when you click on the “Download Eclipse” button on the Eclipse home page. The Java Development Tools (JDT) provide very advanced features for Java developers (a discussion of these features is out of the scope of this posting).

Of course, it’d be great if only it were that simple. The odd thing about how most people know Eclipse as an IDE is that we don’t actually produce one. The “Eclipse” you download by clicking that horrendous orange button is actually the Eclipse Software Development Kit (SDK). This is quite a lot more than just an IDE, it’s an SDK for developing Eclipse products. It includes tools for building extensions to the environment, heaps of documentation, and all the source code. While this does technically include a great Java IDE, the SDK is far more than the average Java developer needs.

Eclipse was originally intended to solve an integration problem. In the past, a developer’s arsenal of tools was typically a mixed bag of applications from different sources that did not tend to work together. Eclipse fixes this problem by providing a base “platform” upon which tools can be built. With Eclipse, that entire arsenal of tools can be loaded into a single application that brings all the necessary functionality to the developer’s fingertips. Eclipse doesn’t ship with all that functionality, but it can be extended through with bundles (traditionally referred to as plug-ins) that provide that functionality. To date, thousands of bundles exist that provide all sorts of functionality.

Eclipse is a platform for building IDEs. The JDT is what we refer to as an “exemplary product” built on the platform. It is “exemplary” in two senses of the word: it is an example, and it provides a pattern for building IDEs that deserves imitation. You can quite easily remove the Java development tools (JDT) from Eclipse and add C/C++ development tools (CDT). In fact, you can have the JDT and the CDT in Eclipse at the same time. Then you can add PHP Development Tools (PDT), Ajax development support, and more. The idea is that all these languages are supported by the same IDE. The Eclipse “platform” provides the base upon which the support for the various languages are added. The platform includes support for basic file editing, refactoring, debugging, accessing source code repositories, and more. Language support is provided by various bundles.

It’s more general than that though. Eclipse is a platform for building tools. Other tools, like database access tools (DTP), reporting tools (BIRT, Crystal Reports for Eclipse), project management tools, network management, and more can be added to the platform.

It’s still more general than that. Eclipse is a Rich Client Platform. If you strip away the bits that make Eclipse an IDE platform, you’re left with what we call the “Eclipse Rich Client Platform” (RCP). In effect, RCP is an application framework. You can think of it as being a higher level of abstraction over a widget tool kit. It provides things like window and menu management, a real component model, pervasive extensibility, an update mechanism, and more. Organizations are using RCP to deliver end-user applications. NASA uses Eclipse RCP as the basis of the applications their mission controllers use to control space craft. JPMorgan uses Ecilpse as the basis for their One Bench application platform.

More fundamentally, Eclipse is an open source project. There are currently (as of May 2007) ten “top level” projects and numerous “subprojects” building open source software. Many of these projects are concerned with building APIs and frameworks that can be used as a basis for building products. Only one of the ten top level projects is concerned with producing the Eclipse SDK. Many of the projects also produce “exemplary products” that—like the JDT—serve as examples and patterns worthy of emulation. There are many more examples.

This leads to the final bits (hopefully you aren’t snoring too loudly at this point). Eclipse is a community and an eco-system. The community is composed of numerous committers, contributors, and users. Some folks write code, other author articles, some teach. Everybody benefits. The eco-system is composed of numerous member and non-member companies who base their open-source and commercial products on Eclipse technology. These companies tend to also contribute to the open source projects. You can get a hint of how large the community is by spending a few minutes minutes browsing Eclipse Plug-in Central.

There are many examples of companies basing their commercial product offerings on Eclipse technology; companies like BEA, Business Objects, IBM, QNX, WindRiver, and many, many others are using as a foundation for their products. Some of these companies, as well as some others, provide distributions of Eclipse. If you’re a little frustrated that you have to pull all the different pieces together yourself, you should look at the distros. Here you can find pre-packaged (and even dynamically assembled) Eclipse packages containing everything you need to get the job done.

Of course, Eclipse is also a foundation. The foundation makes sure that the developers and other participants have the resources that they need, that all the code contributed to Eclipse projects can safely be used by adopters, that inter-project communication is occuring, that Eclipse is properly represented on the world stage, and more (”and more” seems to be a pretty common theme).

I apologise for the long story. But maybe you can see our problem (and it’s a good problem to have): it’s hard to concisely state what Eclipse is.

A good place to start for more information is the FAQ on the Eclipse Wiki. You might also find some useful information on the resources page. EclipseLive also has some content that will help you understand more about Eclipse.

I arrived earlier today at JavaOne and I have to admit that I’m more confused than ever. Just what the heck is Duke anyway? He/it looks a lot like a tooth with a disturbing amount of decay below the gumline. I got a picture of me chatting briefly with Duke earlier today. I’ll post it later after I get access to a scanner. It did get me thinking about what an Eclipse mascot might look like. Any thoughts?

The Eclipse booth was packed today. When I arrived, there must have been fifty people lined up for SWAG. Folks just can’t get enough of the Eclipse t-shirts and hats. Unfortunately, we can’t seem to bring enough supply to meet the demand. I haven’t spotted them on eBay yet, but it’s only a matter of time.

I spent a lot of time talking with folks about In Harmony With Eclipse today. We’re giving out disks which feature Windows and Linux versions Eclipse 3.2.2 combined with Apache Harmony. Harmony, which recently released their first milestone build and is working toward a release, provides the engine upon with Eclipse runs. With Harmony, you don’t need to install a JRE, everything you need to run Eclipse is there. We’re offering the disk as an example of two great projects working together. We’re still at least a few months away from Harmony being ready for production, so this disk is a glimpse of the future.

My talk, TS-3774 Anatomy of an Eclipse RCP Application ended up being added to the programme (after previously being accepted as an “alternate” talk). I deliver the beauty tomorrow at 16h10 in Room 301. Room 301 is a little out of the way, so if you’re planning to attend, starting making your way over early.

If you’ve found the “Colors and Fonts” page in the Eclipse Workspace Preferences, then you already know that you can customize Eclipse to look as awful as you’d like. Or maybe you went different route and changed the colors and fonts to better suit your personal tastes.

Many aspects of the workbench can be tuned. When you change a value, it’s stuffed into a preferences store and kept on your disc so that those preferences come back the next time you start. More specifically, those preferences are stored in files found in the [workspace]‌/.metadata‌/.plugins‌/org.eclipse.core.runtime‌/.settings directory.

You can override the default preferences in your Eclipse product (or RCP application) without making the user play around in the preferences dialog. This is done by providing preferences overrides. You do this by adding a property to your product declaration in the plugin.xml file like this:

<extension id="product" point="org.eclipse.core.runtime.products">
    <product application="PlayingWithPrefs.application" name="RCP Product">
        <property name=”preferenceCustomization” value=”preferences.ini”/>
    </product>
</extension>

With this addition in place, the preferences.ini file—located in the plug-in’s root—is defined. Here’s an example:

# Use curvy tabs
org.eclipse.ui/SHOW_TRADITIONAL_STYLE_TABS=false

# Tabs display in a large italicized font.
org.eclipse.ui.workbench/org.eclipse.ui.workbench.TAB_TEXT_FONT=1|Tahoma|15.75|2|WINDOWS|1|-21|0|0|0|400|1|0|0|0|3|2|1|34|Tahoma;

# The active tab displays as red to green gradient with blue text (yuck)
org.eclipse.ui.workbench/org.eclipse.ui.workbench.ACTIVE_TAB_BG_END=255,0,0
org.eclipse.ui.workbench/org.eclipse.ui.workbench.ACTIVE_TAB_BG_START=0,255,0
org.eclipse.ui.workbench/org.eclipse.ui.workbench.ACTIVE_TAB_TEXT_COLOR=0,0,255

# The inactive tab displays as blue to green gradient with red text (yuckers)
org.eclipse.ui.workbench/org.eclipse.ui.workbench.INACTIVE_TAB_BG_END=0,0,255
org.eclipse.ui.workbench/org.eclipse.ui.workbench.INACTIVE_TAB_BG_START=0,255,0
org.eclipse.ui.workbench/org.eclipse.ui.workbench.INACTIVE_TAB_TEXT_COLOR=255,0,0

And here’s what the RCP Mail sample application looks like with these customizations applied:

You can set more than just look and feel preferences as well. You can override any value that’s stored in preferences. If you look through the .settings directory, you can get a sense for the kinds of preferences you can override in your Eclipse product.

Aaron Farr is an Eclipse RCP expert who has worked on numerous Eclipse RCP applications for various organizations around the world. In this podcast, he discusses some of his experiences with Eclipse RCP.

You can listen the podcast here. The podcast feed on the Eclipse Resources page has also been updated.

Aaron maintains a blog. You can read about Aarons experiences at Cubical Muses.

I just love saying “TPTP”. Of all the projects we have here at Eclipse, TPTP is the one that has the the most entertaining title. Probably my second favourite project name is “Buckminster” (though “Higgins” is also pretty entertaining and conjures up images from Magnum PI).

But anyway…

A new article, titled “Using TPTP to Automate Functional Testing” has recently been published on Eclipse Corner. This article provides an overview and some details of the design of a functional test automation solution that was built using testing frameworks available within the TPTP Testing Tools Project.

If you like automated testing—and I know that you do—have a look through this article.