Please see the MDSD report 2010 (sorry, only in German) for details on the results.

Do you make use of MDSD techniques?

• WAVELET_BLIP_CREATED
  Could not produce this event yet.
• WAVELET_BLIP_REMOVED
  Could not produce this event yet.
• WAVELET_PARTICIPANTS_CHANGED
  Participants have been added to and/or removed from a Wave. Access the new/removed participants via Event#getAddedParticipants() / Event#getRemovedParticipants()
• WAVELET_SELF_ADDED
  The robot has been added to a wave.
• WAVELET_SELF_REMOVED
  The robot has been removed from a wave.
• WAVELET_TIMESTAMP_CHANGED
  The modification timestamp of a wave has changed.
• WAVELET_TITLE_CHANGED
  The title of the wave has changed.
• WAVELET_VERSION_CHANGED
  Haven’t figured out what version means exactly.
• BLIP_CONTRIBUTORS_CHANGED
  The contributors for a blip have changed, i.e. added or removed.
• BLIP_DELETED
  A blip was removed.
• BLIP_SUBMITTED
  A new blip was created.
• BLIP_TIMESTAMP_CHANGED
  The timestamp of a blip has changed.
• BLIP_VERSION_CHANGED
  Haven’t figured out what version means exactly.
• DOCUMENT_CHANGED
  The content of a blip was changed.
• FORM_BUTTON_CLICKED
  Haven’t figured out yet what this really means.

As one can see, the description is not complete yet. Feel free to help me out in the comments ;)

package com.martinklinke.eclipse.jfreechart.demo.views;
 
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.ui.part.ViewPart;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.plot.MeterPlot;
import org.jfree.data.general.DefaultValueDataset;
import org.jfree.experimental.chart.swt.ChartComposite;
 
/**
* @author martin
*
*/
public class MeterChartView extends ViewPart {
   public static final String ID = "com.martinklinke.eclipse.jfreechart.demo.views.MeterChartView";
 
   public void createPartControl(Composite parent) {
      JFreeChart chart = createChart();
      final ChartComposite frame = new ChartComposite(parent, SWT.NONE, chart, true);
   }
 
   public void setFocus() {
   }
 
   /**
    * Creates the Chart based on a dataset
    */
   private JFreeChart createChart() {
      DefaultValueDataset data = new DefaultValueDataset(20.0);
      MeterPlot plot = new MeterPlot(data);
      JFreeChart chart = new JFreeChart("Meter Chart",
      JFreeChart.DEFAULT_TITLE_FONT, plot, false);
      plot.setNoDataMessage("No data available");
      return chart;
   }
}

The result should look like the following screenshot:

JFreeChart Speedometer in Eclipse View

Of course, the MeterPlot can be further customized by calling the plot.setXXX(…) methods. However, this exercise is left to the willing reader ;)

The core of this tool is the editor for the textual UML representation that provides many features that developers are used to (syntax highlighting, validation, outline view etc.). Additionally, Graphviz can be integrated to create diagrams from the textual models.

There are detailed instructions for the installation of TextUML and the Graphviz integration and a tutorial to get started with textual modeling.

A huge advantage of textual over graphical notations is in my opinion the possibility to create diffs which means you can easily put those textual models under version control and profit from Eclipse’s compare mechanism. This enables teams of developers to share a common model and to edit it concurrently like any other piece of source code.

According to Rafael Chaves’ (the author of the project) comment on the previously linked article,

[...] the final goal is at some point to submit a proposal to Eclipse.org [...]

I hope that this goal will be reached, because TextUML is a very interesting and promising project. Claiming

• increased modeling productivity
• live graphical visualization of your class diagrams

as two of the key benefits of using TextUML, the goal should not be too far away. Productivity is always welcome and the graphical visualization may be one of the key arguments for your manager ;)

Seriously, even if it’s not the core feature of TextUML, a simple and efficient way to create class diagrams quickly would be a great win for any technical documentation or idea sketching as well.

I have been a member since the beginning of August and was lucky enough to join the private beta. Currently, the site is in public beta status and there have been a lot of interesting questions already.

In my opinion, questions concerning the Microsoft stack still dominate the site. Many have attributed this to the fact that Jeff’s and Joel’s readers are coming from this background. However, the goal of the site was to have resources for any kind of programming language/environment that may exist.

In order to support the achievement of that goal, this is a call to all programmers out there, no matter how weird the language they (must) use:

Join the Stack Overflow and share your rare knowledge!

Or just try to find some answers where Google can’t look (yet?): In the brains of some fellow programmers ;)

The <workspace>/.metadata/.log file contained the following error message many times:

!ENTRY org.eclipse.jst.server.core 4 0 2008-07-11 16:24:46.251
!MESSAGE Error calling delegate RuntimeClasspathProviderWrapper[org.eclipse.jst.server.generic.runtimeTarget]: null

So this must have been a bug in resolving the server classpath. I couldn’t find an equivalent problem description, and after playing around with the project settings, adding and removing the library manually, which didn’t help any further, I tried updating the Java Standard Tools. There was indeed a patch available. My previous version of JST was org.eclipse.jst_2.0.2.v200802150100-7B-7_8dDTOvmuz0di_U5vgUfz0em and I installed the patch org.eclipse.jst.web_core.feature.patch_2.0.2.v200803241913-208i8s733I395D6BA7. My Eclipse SDK version used is 3.3.2, Build id M20080221-1800.

After the installation of the patch and a restart of Eclipse, the JBoss v4.2 entry showed up again and the error message didn’t occur any longer in the log file. As I said, I don’t really know what had happened, but the patch might have resolved the issue for me, so maybe this helps someone out there, who runs into the same problem.

In many cases, Ant is the tool of choice for automating the build process. As far as I know, Netbeans already uses Ant as build tool by default. Eclipse has its own way of describing the project configuration (source/binary folders, required libraries etc.) with files like “.project” and “.classpath”. The naive approach for building an Eclipse project with Ant would be to duplicate all the information and write a separate Ant build file that does all the work and is independent of an Eclipse instance. There are several disadvantages that come along with this approach:

1. Inconsistencies may occur whenever a new library is added or the structure of the project changes in a significant way (e.g. a new source folder is introduced) => the build file has to be updated manually when the build fails.
2. There is no real guarantee that both the Eclipse and the Ant build produce the same output => Problems may not be visible until runtime tests are performed.

So what could be a more elegant solution? Of course, to use the information for the build that is contained in the Eclipse project artifacts already. The only tool I found up to now that does right this is ant4eclipse. Basically, it defines some Ant tasks that enable the following actions (from ant4eclipse’s website):

• Setup classpathes as defined in Eclipse’s .classpath-file
• checkout complete workspaces as it’s possible with the Team Project Set feature of eclipse
• run your Java applications as you have defined them in an Eclipse Launch Configuration

This avoids the redundancy and leverages the information that is already present as soon as the project compiles in Eclipse. To be honest, I haven’t evaluated ant4eclipse yet, but I probably will as soon as the next Continuous Integration project will start. Seriously, who would like to write dozens of Ant files to do the work that Eclipse already does?

Another interesting project that seems to focus solely on Eclipse plugins, features and RCP apps is Pluginbuilder. The tutorial movie looks really impressive. The homepage says that Pluginbuilder consists of two parts:

An Eclipse plug-in allows to configure the build in the project’s workspace and run the build locally

Then the configuration can be uploaded to the server platform where the build can be scheduled

That’s a nice alternative to the manual configuration of the Eclipse headless build and integration with e.g. CruiseControl. Haven’t evaluated that one neither, but this is definitely a very interesting and promising tool for Eclipse plugin and RCP development which I can imagine may be indispensable once you are used to it.

Which other tools for Eclipse build automation do you know?

When you’re in Eclipse (IDE), press Ctrl+3, then enter the name of a view, editor, preference, command, menu etc. or previously opened resource (e.g. a Java class), select the desired match from the list and voilà – Eclipse navigates you there. You can also enter the initials of the words you are looking for, e.g. “pe” for “Package Explorer”. That’s really a cool feature and available since Eclipse 3.3. It brings kind of a “spotlight feeling” to your development work ;)

Good bye, “Show View” and “Open Perspective” ;)

• Comparison of several agile methods (eXtreme Programming, Scrum, Crystal and Feature Driven Development)
• A guide to becoming agile
• Collaboration in Java Projects (IBM Rational’s Jazz)
• Scrum roles and their meaning for agile teams
• Field report of a Product Owner
• Agile project management with contracts for services

I think it is a good start to see the different methods at the beginning of the day to have a better understanding for the following more specialized topics. I hope to get a very good insight into agile methods and agile project management as everybody is talking about it and there are often also very controversial interpretations of what agile really is. Of course, there are and must be always different opinions about such things. After all, it’s not about the name or definition of a method, it’s about the success that the applied strategy is supposed to deliver…