Eclipse is turning 10 this fall! My first experience with Eclipse came 8 1/2 years ago when I started building visualization tools on top of GEF. I was an IBM CAS Student while doing my PhD at the University of Victoria. Over the years I’ve attended several demo camps, presented Eclipse content at the local Java User Group, delivered presentations and tutorials at numerous EclipseCons and even attended the occasional Eclipse stammtisch. However, I’ve never attended an Eclipse conference in Europe .

I’m hoping to change that this year so that I can join in the Eclipse 10th anniversary celebrations.  I’ve submitted 3 talks to the conference:

• p2, your savior or your achilles heel? Everything an Eclipse team needs to know about p2: This is re-hash of the talk Pascal and I gave an EclipseCon 2011 (the one in North America). We highlight 10 things that all Eclipse developers need to know about p2, or at least the types of things that will make your life a lot easier.
• It’s Raining Bytes: Scaling p2 Using the Cloud: In this talk I will discuss how we use p2 to build something as complex as the Yoxos distribution. Yoxos contains over 30,000 artifacts, split across dozens of self contained slices and all delivered using the Amazon Cloud services.   Each one of these components has been validated to ensure that it installs and that all dependencies are available. This talk is intended for those looking for practical advice on how to scale p2 (the eclipse provisioning platform).
• Moving from CVS to Git, 10 things I’ve learned: This talk was inspired by a blog post a wrote a while ago, when I was first learning Git. I often find that once someone starts using Git heavily, they forget about the growing pains they went through.  With these pains still fresh in my mind, I hope to use this opportunity to present 10 things I learned along the way.  This talk is geared towards those just starting off with Git.

I hope to see you in Germany this fall.

Lately I’ve been adding Git support to the Yoxos Workspace Provisioning. This should be done in time for Eclipse Indigo SR1 and this will mean you can easily share your Git configurations in your Yoxos profiles.

I wanted to make it easy to share your existing repository settings, but unlike CVS or SVN, sharing your Git repository makes very little sense.  Likely you want to point someone to a remote (say one you have shared on GitHub). This means I needed to read the repository settings, find all the remote repositories and order them (such that the one called ‘origin’ is on top).

This turns out to be very easy with the JGit API.  JGit reads the configuration information and stores it in a properties style object where the values are keyed based on their subsection and name. You can get a list of all the remotes by asking for the remote subsection. From here, you can get each remote URL by asking for the URL to a particular remoteName in the remote subsection.

The following code prints out each remote and its URL.

package com.ianbull;

import java.io.File;
import java.io.IOException;
import java.util.Set;

import org.eclipse.jgit.lib.Config;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.lib.RepositoryBuilder;

public class RemoteReader {

  public static void main(String[] args) throws IOException {
    Repository repository = new RepositoryBuilder().findGitDir(new File("/home/irbull/git/p2")).build();
    Config storedConfig = repository.getConfig();
    Set<String> remotes = storedConfig.getSubsections("remote");

    for (String remoteName : remotes) {
      String url = storedConfig.getString("remote", remoteName, "url");
      System.out.println(remoteName + " " + url);
    }
  }
}

While I’ve been enjoying some time-off in Northern Ontario, many Eclipse committers have been keeping busy.

I hope everyone managed to get their hands on the Eclipse Indigo Release, although the Eclipse team is already hard at work preparing for next summer.  The next release — Eclipse Juno — will ship in late June 2012 but the first milestone is already available.  This milestone includes Java 7 support.  Also, many of the components are now being hosted via Git repositories.  As you can imagine, moving 10 years worth of code from CVS to Git is no easy task.

The complete New and Noteworthy is available:
http://download.eclipse.org/eclipse/downloads/drops/S-3.8M1-201108031800/eclipse-news-M1.html

And you can download the Milestone:
http://download.eclipse.org/eclipse/downloads/drops/S-3.8M1-201108031800/index.php

Enjoy!

A number of people in the Eclipse community have been trying out Google+ and some good Eclipse related discussions are starting to happen there. Since many of us have multiple Google accounts (maybe your company uses google apps, or you have your own google apps for a custom domain), switching between accounts starts to become a real problem.

Of course, you could run multiple browsers (say Firefox for personal mail and Chrome for corporate mail), but this is not an ideal solution.  Last week while struggling with this problem I found this little helpful hint.

Now you can navigate to your Google accounts page and enable multiple sign-in.

This is obviously not Eclipse related, but I hope this helps a few people.

It’s interesting to see how Eclipse projects change over time.  As projects ramp up, hit heavy development and finally start to mature, the flurry of activity changes.  Git makes it very easy to pull out this information. I wrote a small script that shows the number of commits per person, per year (and the total number of commits for that year).  I defined a year to basically be an Eclipse release (July 1 – June 30).

While you shouldn’t read much into any one year (or one person) — and you certainly can’t compare projects with this data — the trends are where the interesting information lies.

Feel free to try it out yourself. Simply put the script in the root of a git repository.  The script goes back as far as Eclipse 3.1 (feel free to add more years).

https://github.com/irbull/gitscripts/blob/master/yearly_stats

Note: This is nothing new. You could also use Dash or look at http://www.ohloh.net/.  These scripts just use git log.

The Eclipse Packaging Project defines pre-configured Eclipse distributions.  If you are develop in C/C++ there’s a package for that. If you need to create RCP applications there’s a package for that. Using p2 or the Eclipse Market Place you can customize your install until your heart’s content.

However, each time you download a new package, you’re most likely downloading the same 80-90M.  You are downloading SWT, JFace and maybe even the JDT over, and over and over again.  These Eclipse installs begin to clutter your machine and remembering which install contains which plug-in becomes practically impossible.  I currently have 17 different Eclipse installs on my machine:

Over the past few months I’ve been working on a solution to this problem, and now you can provision your own tool chain, the way YOU want it, from the cloud — and share all your plug-ins.  All you need to do is download and install the Yoxos Launcher.  When you start Yoxos, you will be prompted to select a pre-configured EPP Package (or you can also select “advanced mode” and create your own package).   You can even share the configurations between team members to help you get up and running faster.

All the artifacts are hosted on Amazon CloudFront, so the download should be pretty quick (I provisioned an entire ‘Eclipse Classic’ in under 5 minutes).  And all your plug-ins are shared between installs, so if you install a second package, Yoxos only downloads the new stuff it needs.

Using the Yoxos Customizer Perspective, you can add new components and craft your own customized Integrated Development Environment. The Yoxos repository holds almost 2,000 components including everything from Indigo.

Finally, you can set your upgrade strategy. That is, you can tell Yoxos that you want to receive all updates as they happen, or you would rather stick to an exact Eclipse version.

So to recap:

• Almost 2,000 components are available
• All the components have been tested to ensure that all required dependencies are available
• All the artifacts are hosted on the Cloud (AWS CloudFront)
• All your plug-ins are bundle-pooled and shared between installs
• You can configure your upgrade strategy
• The service is free, go ahead and try it.

Tags: indigo

As you may know I live on the Canadian west coast (In Victoria British Columbia). We are 3 hours behind Easter Time, which means that the Eclipse release was supposed to happen at 6:00am for me.

I awoke this morning to find this in my inbox:

I would like to challenge you to find another piece of software that has consistently delivered On-Time since 2001.

I would also like to point out that this is no accident.  Eclipse ships because there are very dedicated people working tirelessly behind the scene.  While there is no way I can enumerate all of them, a few special thank-yous are in order. Of course all the committers, project leads, PMC, and council members deserve big thank-you.  There would be nothing to ship without you.  But for a release to ship with such consistency, you need rock solid release plan and outstanding release engineers.  I don’t know all the release engineers personally, but certainly Kim Moir and Nick Boldt have been doing an awesome job for their respective projects.  Markus Knauer gets the shout-out for the great job he does assembling the Eclipse Packages.

Of course, Denis Roy and the entire Eclipse webmaster team deserve the credit for managing the infrastructure behind all of this. I imagine that most software projects would use an excuse like ‘our hardware is on fire‘ to delay the release — not at Eclipse, because remember, ship happens.

But the biggest thank-you goes out to David Williams, whose leadership, (nagging ), and vision has made this entire process possible. Thank-you!

Tags: indigo

After 12 months, 62 projects, 46, 000, 000 lines of code, over 400 committers and 1 Top 10 List: Eclipse Indigo is here (Or use the new Yoxos launcher to install Eclipse from AWS CloudFront).  For the past 10 days I’ve been counting down the 10 most exciting Eclipse Indigo features according to me:

10. Maven and Eclipse
9. Equinox / p2 Improvements
8. PDE Improvements
7. JDT Improvements
6.  Gravatars (and Other Mylyn Improvements)
5. Xtend 2
4. CDT Codan
3. RAP: Bringing Eclipse APIs to Mobile Devices
2. Window Builder

There is a lot of other interesting work happening around Eclipse, such as the Jubula Automated Functional Testing tool, but unfortunately, I haven’t had a chance to work with all this great technology.  I encourage you to try out all these great tools, and if you disagree with my Top 10 List, write your own.

Now, without further ado, my number 1 Eclipse Indigo feature is: EGit/JGit 1.0.

If you haven’t used a distributed version control system — take some time and learn one now.  Distributed version control systems (DVCS), like Git and Mercurial are one of the biggest game changers in software development in the past 10 years and will become the De Facto standard for revision control sometime this decade. GitHub is already dominating the forges, and if you’re a software developer, chances are you will collaborate with someone using a DVCS before the next Eclipse release (which by the way will be called Juno).

EGit is the Eclipse Git project and it’s intended to bring Git tooling to Eclipse.  EGit is built on top of JGit, an implementation of Git in Java.  There are a ton of new features like

Blame Annotations

Staging View

Powerful History View

Commit search and commit explorer (search for past commits)

And my favorite, an Improved Synchronize View

Many of the Eclipse projects will be switching from CVS to Git this year, including the Eclipse SDK.

If you are new to Git, there are several resources available to help you get started. I suggested looking at the book Pro Git, and checkout Alex Blewitt’s Git Tip of the Week. There is also an Eclipse EGit tutorial for beginners.

Thanks to all the EGit / JGit commiters: Chris Aniszczyk, Christian Halstrick, Gunnar Wagenknecht, Mathias Kinzler, Matthias Sohn, Robin Rosenberg, Shawn Pearce, Stefan Lay, Sasa Zivkov, Benjamin Muskalla, Dariusz Luksza, Jens Baumgart, Kevin Sawicki, Mik Kersten, Mykola Nikishov and Remy Suen.

And finally, thank-you to everyone who helped ship Eclipse Indigo on Time and On Budget.  Remember, at Eclipse, Ship Happens.

Tags: indigo

We are one day away from the Eclipse Indigo release, and that means we are into the Top 2 Features On My Eclipse Indigo Top 10 Feature List.  Number 2 on my list has been part of the Eclipse EcoSystem for years, but it’s actually a newcomer on annual release train: Window Builder.

Window Builder is an award winning, bi-directional, Java GUI designer.  The tool supports both Swing and SWT/JFace and is a must-have for anybody designing Graphical User Interfaces in Java.  Not only does the tool allow you to mock-up your UIs, it generates production ready code without any additional run-time dependencies.

The Swing Designer supports JDialogs, JFrames, JPanel, and more.

The SWT Designer supports simple SWT interfaces, JFace dialogs (such as Wizards), Forms, Databinding integration, and support for creating RCP applications.

You can also preview your interface as you develop them:

The bi-directional editing means you can seamlessly move between a Drag n’ Drop designer and the generated code.  Window Builder can be used to get your UI up and running quickly, or to maintain and evolve your UI over the long term.  You can even use window builder on existing UIs — ones that were not originally created with the tool.

Regarded as one of the best GUI design tools available, it’s great to have window builder on this years Eclipse release train.  A special thanks goes out to all the Window Builder committers: Eric Clayberg, Konstantin Scheglov, Alexander Mitin, Andrey Sablin, Jaime Wren, Dan Rubel, Mark Russell, Devon Carew, Rajeev Dayal, Miguel Mendez, David Carlson, Alexander Humesky, Xavier Ducrohet, Raphael Moll, Tor Norbye, Ed Merks, Kenn Hussey, Christian Campo, Neeraj Bhusare, Piotrek Tomiak, and Vadim Ridosh.

Tags: indigo

There is no question that the mobile market is huge and practically growing by the second.  There is some excellent mobile development tools built on top of Eclipse, however, each mobile platform requires Yet Another Language and Yet Another Set of APIs.  Developing an enterprise application with a Web, Android, IPhone and Rich-Client interface requires several dedicated development teams, each one specialized in a different technology stack.  For this reason, most vendors simply choose a subset of platforms to support and hope their clients are too dissatisfied.

The Rich Ajax Platform (RAP) changed all this by supporting a single programming model for both Web and Desktop. With the Eclipse Indigo release, RAP now supports a number of mobile platforms through the mobile browser.  For the past week 1 1/2 weeks I’ve been counting down my top 10 Eclipse Indigo Features and number 3 is: RAP, bringing the Eclipse API to mobile devices.

RAP has nothing to do with putting the Eclipse IDE on the web (or on a mobile platform).  The purpose of RAP is to bring a consistent programming paradigm (language, API and programming model), to a variety of different platforms — this is called single sourcing. With RAP, you can reuse your content providers, JFace viewers, Jobs, Progress Monitors, etc… while targeting the desktop, web, and now, mobile.  Of course, you will likely design a different interaction model for each platform, but the business logic only has to be written once.

In addition to Mobile support, RAP has introduced a number of new features such as a much improved (and long awaited), updated tree widget (Kudos to Tim Buschtöns). The widget supports SWT.VIRTUAL, making it load much faster.  It also supports gridlines, full selection support, item and cell colours / fonts and much more:

There are also a number of theme improvements, so it no longer feels like your “running an IDE in your browser”. Improvements such as drop shadows on a number of widgets, theme-able scroll-bars and gradient backgrounds.

Thanks to everyone on the RAP team for making my life so much easier. Kudos go to: Ivan Furnadjiev, Holger Staudacher, Tim Buschtöns, Ralf Sternberg,  Austin Riddle, Benjamin Muskalla, Frank Appel and Rüdiger Herrmann.

Tags: indigo