Planet Eclipse

Rafael Chaves: Eclipse Modeling Day in Toronto

Sat, 21 Nov 2009 03:32:07 +0000

Last Wednesday I attended the Eclipse Modeling Day in Toronto. Coming all the way from Victoria, I must have been the participant that came from farthest. Except, of course, those folks from SAP AG and Itemis that were presenting. But I was really glad to be there. I finally had the chance to chat and discuss about Eclipse and Modeling face to face with people like Simon Kaegi (server-side OSGi), Kenn Hussey (MDT UML2), Eike Stepper (CDO), Ed Merks and (fellow Brazilian) Marcelo Paternostro (EMF), Lynn Gayowski and Ian Skerret (Eclipse Foundation). It’s weird: I have been part of the Eclipse Modeling community since 2006 (and the larger Eclipse community since 2002), but had never actually met any of those folks before. Also amusing was that even though I worked for IBM Ottawa for quite a few years, my first time at the Toronto Lab was many years later as an ex-IBMer living on the West Coast.

The presentations I attended were in general very good. I had seen Ed Merks’ opening presentation on the web before, but this time I could ask questions. I got a better understanding of Xtext (great presentation!), CDO, and the Query, Validation and Transaction frameworks, some technologies I am considering adopting in the near future. I had a first time contact with the Papyrus 2.0 vision, which might provide an opportunity for increasing adoption of the TextUML notation by integrating the TextUML Toolkit into a larger modeling environment. And I liked the idea of a discussion panel at the end.

I had to catch a flight back home that same night, so I could not attend the Eclipse RT Day on the following day nor could I see any of the demos at the DemoCamp. Speaking of which, I did manage to stay long enough to have a beer on the Foundation (thanks!), and chat with Christopher Nagy from Dexterra/Antenna Software, who made a quick ad hoc demo to Ian and myself of their Eclipse/GEF-based tool for authoring multiplatform mobile applications. Very impressive!

As constructive criticism, I do agree with Bjorn that the format could use some tweaking. I sure had to miss some very promising presentations. Maybe with two presentation formats, a longer (for instance, 40-50 mins) and a shorter one (20-25 mins), we wouldn’t need two tracks. I am not sure presenters who came from Europe would have come had they had a shorter slot though. That being said, I was very satisfied with the event overall and am sincerely thankful to IBM Toronto for hosting the event, the Eclipse Foundation for organizing it, all the folks presenting and the companies sponsoring them. Thank you very much! As Lawrence wrote, hope we will see more events like this in the future!

Birt World: Accessing Spring Beans from the BIRT Designer

noreply@blogger.com (Jason Weathersby) — Sat, 21 Nov 2009 00:09:16 +0000

Recently I have described methods that can be used to access Spring Beans from the BIRT Engine. These examples are intended to be illustrative and not comprehensive.

More on BIRT and Spring

Calling Spring Objects from BIRT Expressions and Event Handlers

In both of these examples I used the BIRT engine to retrieve Spring objects within the scripting environment. In this post I am supplying an example that illustrates how to implement your own menu in the expression builder, so Spring objects can be called within the BIRT Designer. This will allow you to test your report prior to deployment.

In this post:
BIRT 2.3.1 - Adding Functions to the Expression Builder
I described how to implement the org.eclipse.birt.core.ScriptFunctionService. The attached example is an implementation of this extension point. When using this example the expression builder will appear as follows.

Notice that there is now a SpringFunctions sub-category, which provides one method callBean. This method takes a bean name and a method name and expects a returned string. To keep the example simple no arguments are supported and the method must return a string. The plugin.xml looks like the following:

Provided with the example is a deployable J2EE application and the plugin that implements the ScriptFunctionService. See the readme for details on setting up the example. Also note that the deployable plugin is also attached in the example. You will need to add this to your designer and your runtime. This example works with both the Open Source BIRT designer and the Actuate BIRT designer.

Also included is an example report with the following output.

This example is available at Birt-Exchange.

Chris Aniszczyk: Movember – Day 20

Fri, 20 Nov 2009 23:15:22 +0000

I am on day 20 of growing a moustache for Movember. I have decided to go against my stylist’s best wishes and help raise money for prostate cancer research with my fellow Eclipse committers. We have raised over $2300 dollars so far! This week’s update includes a new splash screen for Eclipse (thank you Ian Bull).

As for my ’stache, here it is on day 20.

Solid progress. Please donate!

Ankur Sharma: source. and output.

noreply@blogger.com (Ankur Sharma) — Fri, 20 Nov 2009 22:22:28 +0000

The source and output properties in build.properties control the folders to be compiled and where to place the resulting output. The eclipse help briefly talks about it.

    * source.<library> - lists source folders that will be compiled (e.g. source.xyz.jar=src/, src-ant/). If the library is specified in your plug-in.xml or manifest.mf, the value should match it;
    * output.<library> - lists the output folder receiving the result of the compilation;

Source Folders and Output Folders

Source and Output folder have already been discussed in this post. Only the source folders gets compiled and the generated class files get stored in the corresponding output folder. A project can have one or more source folder. If a source folder does not have a output folder attached to it explicitly, its output will go to the default output folder. The .classpath file stores all this information.

source.. and output..

The real syntax is source.<library> and output.<library> where <library> is generally the name of the jar. Here the second dot signifies the default library. Any source folder assigned to it gets it output reside in the root when the plug-in is build. The output.. entry tells the PDE Build where to pick the classes for source.. from.

Typical entries look like this

source.. = src/
output.. = bin/

When a plug-in with above entries is build the structure of the plug-in jar will look like this

org.example.sample_1.0.0
│   plugin.xml
│
├───icons
│       sample.gif
│
├───META-INF
│       MANIFEST.MF
│
└───org
    └───example
        └───sample
            │   Activator.class
            │
            └───actions
                    SampleAction.class

More complex plug-ins have more than one source folder. org.eclipse.pde.core is one such plug-in. It is good practice to assign separate output folder for separate source folders. This is not mandatory.
Lets assume src and src_an are the two source folders and their corresponding output folders are bin and bin_ant. Then a build.properties like

source.. = src/
output.. = bin/
source.ant_tasks/anttasks.jar = src_ant/
output.ant_tasks/anttasks.jar = bin_ant/

will create a plug-in which will look something like this

org.example.sample_1.0.0
│   plugin.xml
│
├───ant_tasks
│       anttasks.jar
│
├───icons
│       sample.gif
│
├───META-INF
│       MANIFEST.MF
│
└───org
    └───example
        └───sample
            │   Activator.class
            │
            └───actions
                    SampleAction.class

The contents of the src_ant folder will get compiled and jared in to anttasks.jar inside ant_tasks folder because of the source.ant_tasks/anttasks.jar = src_ant/ entry.

Classpath vs source/output entries

The source folder and output folder information is already available in class path then why source/output entries are needed? The classpath entries are used to compile source code. But the PDE Build relies on the source/output entries while building (or exporting) the plug-ins. Suppose a plug-in A refers to a class C in plug-in B. Then while building the plug-in A PDE Build will look into build.properties of plug-in B to locate the C.class.

Rules of using source. and output. entries

Every source folder should appear in a source. entry.
A source folder can appear in one and only one source. entry.
The source and output folders are specified as their path relative to the root of the project.
All source folders whose output folder is same should belong to same source. entry.
The corresponding output folders should be mentioned in the corresponding output.entry.

Note that should in above rules means that rule is a good practice and not an obligation but if not followed the result of PDE Build might be unexpected.

Jeff McAffer: 20 days of Mommitting

Fri, 20 Nov 2009 21:53:47 +0000

We’ve reached the 20th of Movember and its time for a progress report from this Eclipse Mommitter.

Shaved in the ’stache earlier in the week
Kids just could not stop laughing
Wife would not look at me or kiss me
After a week there has been some progress.
The kids have finally stopped laughing (though now “pull the ’stache is the game of the day)
Wife will kiss me but still can’t really look at me

Here, judge for yourself.

Its a little strange to be out in public with the new look. I spent much of the week on the road for the EclipseRT days in Austin and Toronto. Great events with lots of good people around. I particularly enjoyed that there were ample breaks between sessions and lots of good conversations. And it turns out that the whole Movember thing is a good ice-breaker. Even got a donation out of it! Valentin Baciu, another Mommitter of similar moustache design donated more to the cause. Thanks! The Eclipse Mommitter team is up to $2200 now. Pretty good effort but we could always use more donations.

Chris Aniszczyk: Eclipse Project Proposal – Gemini

Fri, 20 Nov 2009 21:00:39 +0000

A fan of OSGi?

A fan of all things enterprise?

Check this project proposal out at Eclipse…

This proposal recommends the creation of a new project called “Enterprise Modules”, nicknamed Gemini, to provide a home for subprojects that integrate existing Java enterprise technologies into module-based platforms, and/or that implement enterprise specifications on module-based platforms. Gemini will be a parent (”container project” as defined by the Eclipse Development Process) for several subprojects (”operating projects” as defined by the Eclipse Development Process) that provide the specific implementations/integrations. Gemini will itself be a subproject of the Eclipse Runtime Project and will strive to leverage functionality of existing projects. We encourage and request additional participation and input from any and all interested parties in the Eclipse community.

The future looks bright for EclipseRT and OSGi.

Lynn Gayowski: The Ottawa “Beer & ‘Staches” DemoCamp - Nov. 24

Fri, 20 Nov 2009 20:23:29 +0000

After hosting a lively DemoCamp in Toronto this past Wednesday, it’s time to prepare for the hometown event in Ottawa. For those that have not signed up yet, we’re meeting Tuesday, November 24 at 7:00 pm. Join fellow Eclipsers at Pub 101, 101 York St. (York & Dalhousie) for a steady stream of beverages, compliments of the Eclipse Foundation. To register, just add your name to the DemoCamp wiki or send me a message.

There will be a demo on EclipseRT by Jeff McAffer and one on OpenSocial Gadgets in Eclipse by Boris Bokoski. Also, we can still add 2 to 3 more demos if you have something cool to present.

If any added incentive is needed, at least 3 participants from the Eclipse Mommitters team - Kevin Barnes, Kenn Hussey and Jeff McAffer - will be in attendance and you can check out the spectacular progress of their moustache-growing for charity. Spoiler alert: By some weird synergy, they all seem to have selected “trucker” style. Photo ops are sure to abound.

Lawrence Mandel: Eclipse RT Day Toronto

noreply@blogger.com (Lawrence Mandel) — Fri, 20 Nov 2009 19:32:55 +0000

Yesterday was Eclipse RT Day Toronto at the IBM Toronto Lab. For those who missed it, there is quite a lot going on the runtime space. (A number of the presentation slides are available on the Eclipse RT Day page.) My interest is currently in server side equinox. I've first started playing with this technology about two years ago and my current product, Rational Insight, recently released v1.0, which includes a server side equinox based component. The runtimes are really coming along nicely and have been stable and usable for some time. For me the big takeaways from the day are:

1. The required ancillary features, like filter support for server side equinox, security, and provisioning have now been or are currently being addressed.
2. Tool support is growing for Eclipse RT.

This one day event was really great. The two tracks kept everyone together for most of the day, there was low overhead for me as this was in Toronto (and where I work no less), and there was only a single day commitment, which is much easier on my schedule than a multi-day conference. Thanks to everyone who came down from Ottawa and other places to present and participate. I hope to see more of these events in the future.

EclipseLive: Upcoming Event: Reminder - Overview of the Eclipse Development Process for Committers

lynn.gayowski@eclipse.org (EclipseLive) — Fri, 20 Nov 2009 18:44:07 +0000

Event Date: November 24, 2009 5:00 pm GMT-8

Register Now

Wayne Beaton (Eclipse Foundation)

Abstract:

The Eclipse Development Process (EDP) is a process that exists to help you and your project be successful. We start with a discussion of the principles that underlie the EDP and why they are important to you as a committer. We then discuss the various processes that are in place to ensure that principles are maintained. More specifically, this talk discusses how the EDP will help you reach out to your community of users and adopters. It includes heavy discussion of community development, openness, transparency, IP cleanliness and more.

Total running time will be approximately 1 hour

9:00 am PST / 12:00 pm EST / 5:00 pm GMT - Convert to other time zones

Thanks to Adobe for contributing their Adobe Acrobat Connect product to host this webinar.

delicious | digg | dzone

Doug Schaefer: Chrome OS, it is what it is

noreply@blogger.com (Doug Schaefer) — Fri, 20 Nov 2009 18:43:16 +0000

I guess I got caught up in all the hype over Chrome OS. It's an idea I've bounced around for years as I mucked around learning about embedded Linux. Replace the standard Linux desktop UI with only a browser and throw it on a mobile device. With everything on the web these days, or at least a minimal amount to do something useful, why not?

But I could never escape the idea that you had to have at least some local applications to do things when disconnected, or to take advantage of the CPU and graphics power using native tools for things like games and multimedia.

So I downloaded a build of Chrome OS from gdgt.com to give it a try under VirtualBox. And, BTW, you got to love the tech community and how quickly they get activated when something cool comes along. While the release is about a year away, and the build shows it, you do get a sense of what Chrome OS, or Chromium OS which is it's proper name, is.

You log in with your Google account and, bang, you're in the Chrome browser looking at your Google stuff.

But it is what it is. There's no application menu, no app market, or anything like that. Everything you do is over the web. I did notice an extensions mechanism, and maybe that's how you take advantage of the native environment, maybe not.

When I had thought of a Web OS, this summer, my thoughts turned to the Eclipse Run-Time and using that in conjunction with the browser to have local apps written for the Eclipse platform. I would also think you'd want to launch 3D and multimedia content full screen, or something. But that's not what Chromium OS is. It's web or bust.

So while Chromium OS is interesting, I'm way less excited about it. I think the door is still open for a netbook Linux platform that combines local native apps with the Web experience. Moblin is certainly making strides there for the consumer space. And I've been trying out the GNOME Shell which offers an experience much like Windows 7 for the power users. This story isn't finished yet.

Bjorn Freeman-Benson: How to Improve Eclipse X Day

noreply@blogger.com (Bjorn Freeman-Benson) — Fri, 20 Nov 2009 16:45:30 +0000

Some people thought my previous post was too negative, so I am trying again: same ideas, different wording.

I attended and spoke at Eclipse Modeling Day in New York. The speakers were all knowledgeable and sincere: my favorite was "Building DSLs with XText" by Heiko Behrens of itemis.

I think these Eclipse X Days and Eclipse Demo Camps and other smaller, frequent, regional events are the way to go - I think the pendulum is swinging away from expensive centralized annual conferences.¹

Along with the shift to local conferences is the shift away from powerpoint bullet presentations: in this era of ubiquitous information, there's no reason to go to a single location to watch presentations. You can watch presentations at your desk, you can read presentations on your iphone, ..., there's no shortage of great information available. People are going to a live presentation to do something other than what they can do at their computer.

Thus the sole purpose of gathering people together at a Day or a Camp or a Conference is for people to meet people and therefore the entire Day/Camp/Conference must be designed for maximal people meeting. Organizing for people meeting means that you wouldn't spread ten talks over two rooms because that splits the (already smallish) crowd into two. Two smaller sub-groups reduces the common experience base and thus reduces the hallway conversations... Etc. It's all about designing an experience for people to meet people.

Shorter talks, single track, inducements to start conversations, ... that's what makes a great Day.

¹ With the recent price increase and travel and hotel costs, EclipseCon will cost more than $3,000 to attend whereas New Yorkers could attend Modeling Day for $4 in subway fare.

Lars Vogel: Poll – Default launch configuration for Eclipse plugin / RCP development

Fri, 20 Nov 2009 14:50:12 +0000

Eclipse shows errors during a launch via the log views in both the host and the target system and on the file system. In addition the developer can specify the flag “-consoleLog” in the launch configuration so see potential error messages in the console view.

Bug 284704 had been opened asking if the “-consoleLog” flag could be included by default in a new launch configuration.

What do you think? If you are a plugin or RCP developer please participate in the following survey:

Link to Survey

——————————
Please note that this is my first attempt using SurveyMonkey, I hope this works well. I believe the survey will close after the first 100 answers. If this number has not reached I’m planning to close the survey next week 27. Nov. 2009.

Holger Staudacher: Advanced Rich Ajax Platform Theming

Fri, 20 Nov 2009 13:08:24 +0000

As you may read in previous blogs we have adressed the RAP styling. Therefore we presented you the “big blocks” in form of the new RAP designs. But there is still a difference between RAP and other cool RIA technologies i.e. like ExtJS, Flex or qooxdoo. When you take a look at the demos of these frameworks they all come along with cool styled widgets out of the box. Take a look at the screenshots below to see what I mean.

ExtJS Combobox

Flex buttons

qooxdoo buttons

Now lets take a look at the RAP widgets and how they are styled out of the box:

RAP default widgets

As you may see, there is a little difference between the Flex, ExtJS, qooxdoo and the RAP widgets. RAP looks almost like Windows 95. This cannot be the way RAP presents itself to the world because RAP is a modern and cool technology for building full featured RIAs. For that reason we spent some effort to show you how RAP can look like:

Modern RAP theming

From my point of view these widgets have a really fresh look and are fully competitive against all the Flex, ExtJS and qooxdoo widgets. This styling is done via theming and by using the new theming features like gradients and rounded corners heavily. We plan to set this theme as the default theme for RAP 1.3 which will be released within the Helios release train.

But there is no reason to wait. You can use the theme right now. All you have to do is:

Check out the latest and hottest RAP Milestone.
Edit your branding to use the new themes. Set the theme id to org.eclipse.rap.design.example.business.theme for the business theme or to org.eclipse.rap.design.example.fancy.theme for the fancy theme.
Start your application and enjoy the fresh and modern look of you widgets.

Please note that not all widgets are themed right now, but more than 80% of the widgets have the new look allready. If you have feedback for the theme please let us know by using the newsgroup or by leaving a comment.

Eclipse Enthusiasts Poznań: Eclipse Demo Camp in Poznań

noreply@blogger.com (Christopher Daniel) — Fri, 20 Nov 2009 09:47:25 +0000

This year Eclipse DemoCamp will be hosted at Poznan University of Technology.

Please refer to details .

Check out our special guest!

Sven Efftinge: Xtext in the automotive industry

noreply@blogger.com (Sven Efftinge) — Fri, 20 Nov 2009 09:03:54 +0000

At this year's Eclipse Summit Europe there was a very nice Xtext-related talk given by Sebastian Benz who is working at BMW Car IT.
The talk was about how they used Xtext in order to develop a textual syntax and corresponding IDE for the AUTOSAR standard. The name of the project is ARText and it is freely available to all AUTOSAR members as part of the Artop project.

One of the biggest challenges when implementing the AUTOSAR standard is to create scalable solutions. AUTOSAR projects might become very, very big and in order to work with such huge projects the tools need to perform very well. In the modeling world people usually strife for repository-based (i.e. database-based) solutions as soon as projects get really big. However, the folks at BMW Car IT wanted to develop AUTOSAR projects in a traditional text-based manner and given all the good experiences with tools like JDT or IntelliJ, it's clear that text-based IDEs can scale very well.

In order to implement the language they first had tried the old Xtext version from oAW, which was way too slow. Then, later, when the new TMF Xtext came around they gave it another try and saw that the performance had been improved significantly. Sebastian showed the following slide in his talk:
After that he explained how they have solved a couple of other problems, such as supporting different releases of the standard or making the language extendable. All the solutions looked very nice, they must have some very skilled people at BMW Car IT.

He compared working with the state-of-the-art commercial graphical modeling tool (What's the name of it?) and the ARText IDE and found that the use of ARText reduces development time by about 40%.

In the end there was this nice summary slide I don't want to withhold:

It was a very nice talk and of course a pleasure to see that Xtext is used by such smart people in such an interesting environment. And even better it seems that they've had as much fun using Xtext as we had and still have when developing (and using) it. :-)

Btw.: If you have other interesting applications of Xtext or Eclipse Modeling in general, please contact me. (Even if you don't want me to blog about it ;-))

Dave Carver: Individuals 149, IBM 132

noreply@blogger.com (David Carver) — Fri, 20 Nov 2009 01:57:49 +0000

Dash Company Committer Stats

Note: As Nick rightly points out in the comments, Dash is really a suite of related projects to help the community. The stats shown above are only a small part of that suite.

It looks like for the first time in a while that IBM may not have the most active committers at eclipse. It looks like the Individuals will over take them this year. Unfortunately I can't compare this to prior years numbers as the site is very slow, but it is a good sign that we have so many individuals committing at eclipse. Personally, I take the DASH stats with a grain of salt. Mainly because it is very easy to manipulate the total Lines of Code metric. My own stats for the STAR Organization are probably over blown. I know I haven't written that many lines of code. Most of that has to come from the work with the PsychoPath processor, and creating the necessary test suite based on the W3C test suite for XQuery. Much of that test suite code though I generated using XSLT and then tweaked as necessary.

DASH is one of those projects I don't think the community takes advantage of enough. You can use DASH for all sorts of things.

Who is a commiter on what project
Is a person really a committer.
How active of a committer are they from a code stand point.
What projects do they have commit rights to.
What companies are contributing committers.
How active are those committers.

All of this is available through DASH.

Stats and Metrics are interesting, depending on how you sort and play with the numbers, they can either back up your stance, or be used against you. What does DASH say about you and your company? Or what can you make it say?

Scott Lewis: ECF provides some additional REST

noreply@blogger.com (Scott Lewis) — Thu, 19 Nov 2009 18:10:34 +0000

ECF was very fortunate to have 4 Google Summer of Code projects coming out of the summer of 2009. All of these innovative codebases will make it into ECF itself...and more importantly we have gained several excellent new committers.

Coming out of the GSOC project, we've just finished a major refactoring of the REST API, to make it simpler, smaller, as well as better integrated with ECF remote services.

The integration with ECF remote services is particularly interesting, because it provides both proxy-based/synchronous invocation, as well as full support for asynchronous invocation patterns (i.e. asynchronous-with-listener-callback and futures). With the integration with ECF remote services, the choice of synchronous/asynchronous invocation comes for free for all REST-based remote services. See here to get the REST projects and use the API.

We are working on example code, and invite contributions from community members to this effort...so that we can continuously improve/simplify the API through community feedback, as well as get a wide range of example code and documentation from existing and new REST-based services. See the ecf-dev mailing list for feedback/discussion/coordination.

The current test code uses the popular Twitter REST API...as an example of using the API to interoperate with non-OSGi, non-Eclipse, perhaps non-Java web service (I don't know/care how the Twitter service is actually implemented...which is what protocol-level interoperability is about).

Chris Aniszczyk: EclipseRT Day Austin 2009

Thu, 19 Nov 2009 17:57:05 +0000

A couple days ago, I had the pleasure of attending and speaking at EclipseRT Day in sunny Austin, Texas. The day started off with Jeff McAffer speaking about building component based applications using OSGi and EclipseRT.

From my point of view, the audience took a liking to the Toast example that Jeff used to describe EclipseRT. There’s something to be said about a consistent example that people can grab the source and build upon themselves.

The next talk I attended was by Austin Riddle and Cole Markham from the Texas Center for Applied Technology.

I was blown away by what these folks were doing with EclipseRT technology. From bio-surveillance tracking, preventing and managing the spread of animal disease to monitoring coastal waters off the United States. On top of that, they created a platform for building simulation and information dashboards using the Eclipse Rich Ajax Platform (RAP). Their story of Eclipse technology usage was oh so familiar. At first, they started as humble Eclipse IDE users. Then they started to create some useful applications on top of Eclipse RCP. Then they started to use other technologies from the Eclipse stack. Then they noticed that they could build a platform for their domain using Eclipse technologies.

Afterward, I had the opportunity to talk about the Rich Ajax Platform (RAP) and the topic of single-sourcing. It seems people were very receptive about the idea to develop rich and web clients from a single code base. It’s an attractive proposition when you can reuse your existing set of skills and tools to build applications for different runtime environments. There were some concerns about scalability, but the RAP team is actively working on improving performance issues and making performance results available.

Brett Hackleman from Band XI presented about how they were leveraging EclipseRT and OSGi in the embedded device world over the course of a dozen projects in the defense, heavy equipment, industrial automation and automotive domains. It’s cool to see OSGi used in the embedded space along with the custom SWT widgets they came up with for their domain.

Mike Masterson from IBM spoke about how Lotus had to reinvest in their portfolio, including the 20-year young Notes platform. Lotus decided to use EclipseRT as the base of their Notes platform which unified their client strategy and allows them to foster a rich partner ecosystem through the extensibility that EclipseRT provides. Lotus users can easily extend their Notes experience via widgets that developers can write using EclipseRT technology.

On the whole, I thought the event was fantastic. The talks were great and having the opportunity to meet new people that are building on Eclipse technologies is always fun. I can only hope the Eclipse Foundation puts on more events like this in the future. The more opportunity we have for everyone to interact with each other in person within the Eclipse community is a great thing.

Chris Aniszczyk: Software Versioning is Ridiculous

Thu, 19 Nov 2009 17:25:01 +0000

Alright, I have to vent and go on a diatribe as its been awhile.

I was in the process of updating my iPhone and was greeted with these updates.

1.34? 1.7f? Why does Apple even bother showing the version number. I don’t even know what version of the software was previously installed. As a user, I only really care if there’s an update and what is included in that update. That’s it.

The way software engineers treat version numbers is sad. Since the inception of software, we haven’t been able to come up with a reasonable versioning scheme that can be shared across technologies. Even worse, versions really mean nothing. On top of that, we confuse marketing version numbers with internal software version numbers. Here are some examples of what I’ve come across.

Let’s start with Java. 1.0.3, 1.1.2, 1.4.2, 1.5.0, 1.6.0? Why both with the “1″ in the version number?

Next up we have is Windows… 3.1, 2000, XP, ME and 7. Awesome.

I remember when Netscape magically went from version 4 to 6. You know, we didn’t really need a version 5 because IE was already at version 6. We can’t let our competitors out version us.

In Linux… 2.3, 2.4.0, 2.6.8, 2.6.8.1… it’s cool when you can start adding version segments. Linux also seems to suffer the Java problem where the first digit is meaningless… maybe Linus’ favorite number is 2. On the bright side, the second segment in the version number at least signifies whether the code is considered stable or not. I’ll give bonus points to Linux for that.

SmallEiffel… -0.87, -0.79, -0.74… nice… software versions that start on the negative scale and apparently count down to zero.

In areas where modules exist and there’s a goal of reusable components (think OSGi and Maven), there’s a standard version scheme with a recommended policy on how to handle version changes. The only problem is that not everyone follows the scheme given their experience where version numbers mean nothing. It also doesn’t help that version schemes may be different amongst similar component technologies.

In the end, there really needs to be two types of versions, one for the marketing department and one for the development department. Confusing the two types is bad. It’s good to see that I’m not the only one that feels like this, there’s some funny commentary by Jeff Atwood on versioning.

Shame on us in the software industry for letting this crap continue.

Andrew Eisenberg: Getting AspectJ Pointcut matching timer information in AJDT

noreply@blogger.com (Andrew Eisenberg) — Thu, 19 Nov 2009 16:35:26 +0000

Andy Clement has just added pointcut match timing information to AspectJ. A number of people have been asking to have this included in AJDT, and so I did a little work and made it available in the latest dev builds of AJDT for 3.4 and 3.5.

Here's how to display timing information:

Select Verbose and Pointcut matching timers from the AspectJ compiler preferences page (this can be either globally from Eclipse preferences or for a specific project from the project properties page):

In the AJDT Event Trace View, ensure that you have Compiler / Task list messages selected:

And now on every project build (incremental or full), you will see pointcut matching times spit out to the event trace:

Enjoy! Questions can be sent to the AJDT developer's mailing list.

Bjorn Freeman-Benson: Another Way Not To Do XYZ Day

noreply@blogger.com (Bjorn Freeman-Benson) — Thu, 19 Nov 2009 14:00:08 +0000

As you know from my previous post, I believe that XYZ Days (or ABC Camps, or PQR Conferences) are all about people meeting people. So when I received an email advert for the "Gov 2.0 Online Conference", I just cringed - it's basically a live webcast with an IRC back channel.

I understand the desire to eliminate travel costs, but an IRC chat room is not a good way for people to meet. You need something more, something like Telepresence. I know there have been dozens and dozens of research projects (and some products) over the years towards building a virtual conference room that provides the full range of communication bandwidth (including live video and the ability to drift in and out of conversations)... maybe the time is ripe and the bandwidth is available for a people meeting people virtual conference technology to finally emerge.

Gorkem Ercan: Help for MIDP friends

noreply@blogger.com (gorkem) — Thu, 19 Nov 2009 10:23:44 +0000

eSWT developers usually come from two different backgrounds. Those who are familiar with desktop Java GUIs especially SWT that are starting to do mobile development or seasoned MIDP developers who are looking for advanced UI features for their applications. Looking at the questions coming from the later group of developers on forums, a common theme is about how to implement something that they could do with MIDP UI with eSWT. Here is some help for two cases that are asked often.

How to fix the screen orientation to landscape or portrait? This feature is implemented on MIDP UIs using a Nokia specific Midlet Jad attribute Nokia-MIDlet-App-Orientation. eSWT does not make use of the any of the Jad attributes that are present on the MIDP platform. Instead it provides APIs that enables developers to achieve the same results. This also allows eSWT applications to be easily portable between runtimes. eSWT’s way for achieving fixed screen orientation is using the Screen API. Here is a short snippet that fixes the orientation to portrait for all available screens.

1:     Screen[] screens = MobileDevice.getMobileDevice().getScreens();
2:     for (int i = 0; i < screens.length; i++) {
3:       screens[i].setOrientation(Screen.PORTRAIT);
4:     }

A good thing to remember is some devices may actually plug new screens, for the best results it is a good idea to listen for Screen changes using the listeners from MobileDevice APIs.

How to put an eSWT application to background? On mobile platforms that support background applications MIDP developers achieve sending the application to background by removing the current Displayable. Here is an entry that explains how it is done on MIDP LCDUI. The same can be achieved for eSWT applications by setting the active Shell to minimized. Here is how.

1:         Shell activeShell = display.getActiveShell();
2:         while(activeShell != null ){
3:           activeShell.setMinimized(true);
4:           activeShell = display.getActiveShell();
5:         }

The example snippet takes into account that you may actually have more than one top-level Shell, which the second one may get active once the currently active one is minimized.

I will try to make more of similar kind of posts in the future. Please do comment if you have any suggestions for content. And of course. I continue to keep an eye on the Nokia forums and Eclipse discussion boards.

Manuel Selva: SWT FileDialog and Windows Hide Extensions For Known File Types

Thu, 19 Nov 2009 09:41:42 +0000

This morning we encountered a strange difference while running the following code on two Windows workstations and directly clicking the OK button of the dialog.

 FileDialog dialog = new FileDialog(window.getShell(), SWT.SAVE);
 dialog.setText("Save as...");
 dialog.setFileName("C:\\Test\\toSave.test");
 dialog.setFilterPath("C:\\Test\\");
 dialog.setFilterExtensions(new String[]{"*.sav"});
 String path = dialog.open();
 System.out.println(path);

The first workstation printed C:\Test\toSave.test while the second one printed C:\Test\toSave.test.sav

Of course the wanted behaviour is the second one !!!

After investigations we identified the difference on the workstations causing this “SWT” difference: the first workstation HAS the windows folder option called Hide Extensions For Known File Types checked while the second one HASN’T !!!

To fix the issue we had to modify the setFileName method call as following:

 dialog.setFileName("C:\\Test\\toSave.test.sav");

Conclusion: Looking back to the initial code, it seems logic to have to set a file name matching the specified filter extensions.

Lars Vogel: Fresh (and free) icons for Eclipse applications

Thu, 19 Nov 2009 05:17:20 +0000

I always use the Eclipse icons for my applicatons. Recently one of my users complainted that my icons look “oldisch”….

I quick call for help via twitter returned the following sites which provide free and fantastic looking icons.

http://commons.wikimedia.org/wiki/Crystal_Clear
http://www.famfamfam.com
http://iconlet.com
http://www.iconfinder.net/browse

Thanks to everyone for the links. Hope this helps also others to spice up their applications.

(Disclaimer: Of course these icons are not specific to Eclipse and could be used in other applications as well)

Wayne Beaton: Get your IP Log in Order

Wed, 18 Nov 2009 19:44:26 +0000

Having a up-to-date (and correct) IP Log is important for projects and we’re trying to provide as much help as we can to make sure that they’re in order.

I’ve been working with a couple of projects to help them get their IP Logs in order. In the process, I’ve managed to generalize a “review” script that run queries against the Eclipse Bugzilla instance to help identify bugs and attachments that should potentially be referenced as contributions in a project’s IP Log. I’ve already used this script to identify a couple of contributions that I neglected to record for the Examples and Eclipse IDE for Education (ide4edu) projects.

The script is currently pretty rough. I haven’t made any linkage to it from any other eclipse.org page, so you have to manually modify the URL to make it work for your project. It could probably also stand to have a little more prose added to better describe what it provides. You can see the results of running the script for Mylyn, and Examples. To try other projects, change the id parameter value to the id of the project (e.g. tools.mylyn, or technology.examples). FWIW, it doesn’t work on eclipse.platform as it requires too much server memory and it bails out. Close to a decade’s worth of bug reports will do that for you.

Using this script to poke around a bit, I’ve noticed a few projects that still don’t quite get the iplog+ thing. Clearly, I need to do a better job of working with projects to get this right.

The main benefit of using the Bugzilla iplog flag is that we can use this information to automatically generate an IP Log for the project. However, the generation process is only as good as the data it’s provided with. Here are a few pointers:

Only actual code contributions need to be included in the IP Log.
Only contributions from non-committers need to be included in the IP Log
Contributions that come from a developer before they become a committer do need to be included in the IP Log; the tools are smart enough to handle this time-sensitivity (so committer-provided contributions erroneously flagged as iplog+ are ignored).
Ideally, attachments should be flagged as iplog+ rather than bugs (if an attachment is flagged, the bug itself almost certainly should not be).
A bug might be flagged as iplog+ if the summary or one of the comments contains code that’s been rolled into the project’s source code repository.
Marking the bug iplog+ means that the summary and every comment are potential contributions that will need to be manually filtered when the IP Log is generated.

The page that results from the “review” script is read-only. You can’t actually change the iplog flag’s value from the page. But there are handy links that take you right to where you need to be if you decide that you do need to flag something. Hopefully this makes it easier.

As always, I invite your feedback. If this page turns out to be useful, I’ll sort out how to better incorporate it into eclipse.org.

Mik Kersten: Growing open source ecosystems: the install story

Wed, 18 Nov 2009 19:43:19 +0000

At the Symbian Exchange & Expo conference, I presented a talk called Coordinating contributions: lessons learned growing an OSS community, sharing my lessons learned from the AspectJ and Eclipse Mylyn communities. The Symbian Foundation has adopted the EPL, Bugzilla, and an open development model. What makes the Mylyn project an interesting data point is that with the same infrastructure, it has seen over 800 bug and enhancement reports resolved by patches from a very active contributor community. That’s around 1/7 of our bugs resolved, and falls within the top two Eclipse projects for total contribution count. While Tasktop Technologies has provided the resources for maintaining, supporting and evolving the Mylyn frameworks, we have managed to create a very permeable and successful ecosystem for contributors.

The talk broke the contribution problem up into three pillars: the modular platform that defines the landscape of interesting contributions, the incentive structure needed to drive contributors, and the collaboration tools that support the open development process. While responding questions after the presentation, I was struck by how important the extension install story is to the first two pillars.

Open platforms need easy extension install

If you release a cool tool and nobody can find or install it, does it still make a sound? Not if the sound that you’re after is the roar of broad adoption. One ingredient of an install story is the dependency management technology, which defines the modularity of extensions. In Eclipse, this is a solved problem thanks to OSGi and the Equinox P2 provisioning system.

Another ingredient is incentive structure. The Eclipse Plug-in Central site provided a web portal for listing extensions, but was disconnected from an install story. In contrast, consider the success of the market-driven incentives of Apple’s app store. Or the seamless install process of iPhone apps and Firefox add-ons. Incredible ecosystem growth can result when install technology, modularity mechanisms, and incentive structure line up. While Eclipse provides a great generic install and dependency management mechanism, as the number of Mylyn integrations grew, we realized that a limiting factor of adoption was the discovery of integrations and ease of their installation. In order to continue to support our growth and not overly bias our ecosystem to those extensions that were hosted on Eclipse.org, we needed to streamline Eclipse’s install experience for Mylyn connectors. So we created the Mylyn Connector Discovery tool.

Generalizing Mylyn Connector Discovery

Since the release of Connector Discovery release with Eclipse Galileo, the listing has grown and received consistent praise from users and integrators. We’ve since seen many requests to generalize the mechanism to other install use cases ranging from Eclipse Pulsar SDK installs to the exciting new Eclipse Marketplace effort. The SpringSource Tool Suite is a great example of how the Discovery UI can be leveraged for targeted extension install.

In response to this interest, we have generalized the code and are proposing to move it to the the Equinox P2 project, home of Eclipse install. For details on that proposal see Eclipse bug 295273. What I hope we see in the Eclipse Helios release time frame is the Discovery mechanism as P2 API for special-purpose install workflows, with extensions for Mylyn Connectors, Eclipse Marketplace and more. This Discovery install story is additionally relevant to Eclipse Rich Client Platform (RCP) install scenarios, which often need a simplified and tailored install experience.

While serving on the Eclipse board of directors, a concern I repeatedly raised was the repeated problems that arose from an incomplete install story. The great thing about being part of a meritocratic ecosystem like Eclipse, which rewards participation, is the ability to put code and resources where your mouth is.

The economics of extension listings

A tension that surfaces around shared resources is the Tragedy of the Commons. This gets discussed repeatedly in Eclipse, and can happen in vendor neutral open source ecosystems when organizations attempt to derive value from common frameworks and tools without contributing enough back. As a result, those ecosystems tend to be lead by organizations that understand commercial open source enough to act with enlightened self-interest. But with the continually growing number of Mylyn integrations, we also needed to consider companies with a shorter-term outlook. For example, like other projects, we see the pattern of vendors leveraging our frameworks in ways where they impose a significant support burden on the committers, and not contributing back in terms of patches or resources to help grow those frameworks. While I believe that an open source project like Mylyn should welcome all integrations, an indefinitely increasing support burden is not scalable and can reduce the time available for innovation. We need to avoid the Easter Island effect where everyone builds themselves self-serving heads without prioritizing the long-term health of the ecosystem within which they operate (see Easter Island/Collapse of the Ecosystem).

Discovery style extension listings provide a great opportunity to encourage meritocracy, one of the driving principles of a vendor-neutral development process like Eclipse’s, and help align the interests of a project with those leveraging on it. For good references on meritocracy see Chris Aniszczyk’s recent post. In preparation for last June’s release of the Mylyn Connector Discovery, we worked with our community to create listing criteria that achieve this balance. To paraphrase here, committers can vote you into the listing if you contribute enough to the project to offset the additional burden that you impose on the committers. If you are a vendor and are pulling your weight on the project by growing the frameworks and tools for all integrators to leverage, you can get your own section. If you have a community-oriented open source integration, committers go an extra mile and offer you UI and API reviews in order to help encourage cross-ecosystem collaborations, which can yield a long-term benefit, as evidenced by our collaborations with Mozilla. The listing criteria are open to feedback and input on Eclipse bug 279709.

To date, this meritocratic listing approach has worked extremely well for promoting high-quality extensions and contributions. It has encouraged the growth and adoption of independent efforts such as the Mantis connector, reduced the adoption bias we had of connectors that were hosted on Eclipse.org, and provided a mechanism for promoting the latest round of commercial integrations needed to grow the Mylyn user base.

With a generalized Discovery mechanism in place, I hope that we see a similar trend for other special-purpose Eclipse extensions. For example, the Eclipse Marketplace can use ranking in the Discovery listings for promoting members’ solutions. Projects like Eclipse Pulsar can make their key contributors’ mobile SDKs trivial to install. And the next round of innovative Eclipse projects can use this mechanism to help grow their ecosystem of extensions by promoting meritocracy.

Be more productive. Guaranteed.

Bob Balfe: Facebook has Easter Eggs!

Wed, 18 Nov 2009 18:19:37 +0000

From my buddy Mark:

“Go to any Facebook page and click once in a white area just to get a blank timeline to do this with. Press up arrow, up arrow, down arrow, down arrow, left arrow, right arrow, left arrow, right arrow, B, A, then the Return key. If you left-click or right-click, scroll or push any keyboard key after that, a strange shining set of circular rings will appear on your screen.”

technorati tags: Facebook

Maarten Meijer: Industrial SQL Connector versatility

noreply@blogger.com (Maarten Meijer) — Wed, 18 Nov 2009 14:01:51 +0000

I just created a quick solution for https://bugs.eclipse.org/150174 Eventum Mylyn connector using the Industrial SQL Mylyn connector toolkit in under 60 minutes! Screenshots @ bug, details to follow here.

A ZIP with basic code is available here

Maarten Meijer: Industrial SQL Connector and Eventum

noreply@blogger.com (Maarten Meijer) — Wed, 18 Nov 2009 14:01:33 +0000

When looking at the Mylyn connector Most Wanted List you'll see many issue tracker that do not have a dedicated connector to the Mylyn Eclipse Task based UI.

Many of these are backed by databases to store all the complex relations and workflow. In the next several blogs I'm going to demonstrate how easy it is to connect Mylyn to any database backed issue tracker using the Industrial SQL Connector.
For the example I will be using Eventum, created and used by MySQL, number 4 on the list. It is also OSS, so we can easily get it to play around with.
This will not be a full fledged connector, but a quick start to get the task change notification directly from email into Eclipse as first step in making you more productive.

Install Industrial SQL Connector

This connector can be installed from http://bugs.industrial-tsi.com/mylyndb/

Download empty MySQL connector Fragment

You can download a ready made empty MySQL connector Fragment as described here and unzip it and rename some files, so we get this structure:

I want to make this easier but need code from PDE, please vote for bug 288547: Add a NewFragmentFromTemplateWizard with API to make Fragments from templates

Install Eventum 2.2

Install this on you local machine following instructions provided here, so you can inspect the database tables, create and test the queries.
Then when you are completely satisfied that it works, do you change and connect to the production database!
Once the default install is completed use a database inspection tool like phpMyAdmin or soemthing else to familiarize yourself with the database structure. Luckily the Eventum designers used a very consistent naming scheme for TABLES and COLUMNS!

Once completed you can log into the system and start creating some initial users, projects and issues.

While creating a user, a project and a test issue in the web interface, make notes of what backend database tables change and get filled, because the Industrial SQL Connector is all about mapping database tables to task fields. Databases are usually constructed with record ID's for the machine and record names or titles for us, the users. As Mylyn is about making us more productive, we will as a matter of policy retrieve the human-readable formats from the database and map those back into records using JOIN statements. The preliminary mapping is as follows:

Task Side	Eventum Table
Tasks	eventum_issue
Products	eventum_project
Issue Status	eventum_status, eventum_resolution
Issue Priority	eventum_project_priority
Comments	eventum_issue_history
People	eventum_user, eventum_issue_user

Creating the Connector: step 1 creating extension

Open the fragment.xml and create extension org.eclipse.mylyn.industrial.core.persistor and create a persistor-config, add an ibatis-config. Fill in the fields as below:

Creating the Connector: step 2 retrieving repository elements

Edit the file maps/eventum-direct-db/RepositoryMapEventum.xml as follows.


<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMap
    PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN"
    "http://ibatis.apache.org/dtd/sql-map-2.dtd" >
<!-- 
    licensed under ECL, to connect Mylyn to SQL databases
    Copyright 2009 Maarten Meijer, all right reserved.
    http://eclipsophy.blogger.com
   
--> 
<sqlMap namespace="Repository">
<!--
Legal issue owners and other legal values for fields are taken here
from DISTINCT values in the database. An alternative would be a
SELECT from any table containing legal users.
-->
<!-- return a list of legal issue owners. -->
<select id="legalOwners" resultClass="string">
    SELECT DISTINCT usr_full_name FROM eventum_user
</select>
<!-- return a list of legal products. -->
<select id="legalProducts" resultClass="string">
    SELECT DISTINCT prj_title FROM eventum_project
</select>
<!-- return a list of legal issue status values. -->
<select id="legalIssueStatus" resultClass="string">
    SELECT DISTINCT sta_title FROM eventum_status
</select>
<!-- return a legal list of priority values.
    Note that in Mylyn these all need to be mapped to one of
    "P1", "P2", "P3", "P4" or "P5". -->
<select id="legalPriority" resultClass="string">
    SELECT DISTINCT concat('P',pri_rank) FROM eventum_project_priority
</select>
<!-- this query will be executed when pressing the Validate Connection in
the Repository Settings dialog -->
<statement id="validate" resultClass="boolean">SELECT TRUE </statement>
<!-- this query will be executed when pressing the Validate Connection in
    the Repository Settings dialog -->
<statement id="authenticate" resultClass="boolean">
    SELECT TRUE
</statement>
<!-- This query will be executed when validation fails and the repository
can be initialized or updated based on version (like local Derby) -->
<statement id="initialize" resultClass="string" parameterClass="string">
    $value$
</statement>
</sqlMap>

This will give us a nice prefilled dialog in of the Form Based Query:

Creating the Connector: step 3 mapping the task

Open the file maps/eventum-direct-db/TaskMapEventum.xml and locate the query getForKey. This query retrieves all mappable issue attributes give an issue ID to use as key.


<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMap
PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN"
"http://ibatis.apache.org/dtd/sql-map-2.dtd" >
<!-- 
licensed under ECL, to connect Mylyn to SQL databases
Copyright 2009 Maarten Meijer, all right reserved.
http://eclipsophy.blogger.com
--> 
<sqlMap namespace="Tasks">

<select id="getForKey" resultClass="ibatisTask">
 SELECT
 iss_id as taskId,
 concat('P',pri_rank) AS priority,
 usr_full_name AS owner,
 iss_summary AS summary,
 iss_description as notes,
 prj_title AS product,
 sta_title AS issueStatus,
 iss_created_date AS creationDate,
 iss_closed_date AS completionDateDate,
 iss_expected_resolution_date AS dueDateDate
 FROM eventum_issue
  INNER JOIN eventum_issue_user ON isu_iss_id = iss_id 
  INNER JOIN eventum_user ON isu_usr_id = usr_id 
  INNER JOIN eventum_project ON iss_prj_id = prj_id 
  INNER JOIN eventum_status ON iss_sta_id = sta_id 
  INNER JOIN eventum_project_priority ON iss_pri_id = pri_id 
        WHERE iss_id LIKE #value#
</select>
[...]
</sqlMap>

Creating the Connector: step 4 adding dynamic search

We also need to edit the statement in searchForKey for the Form Based Query to make its selection:


<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMap
PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN"
"http://ibatis.apache.org/dtd/sql-map-2.dtd" >
<!-- 
licensed under ECL, to connect Mylyn to SQL databases
Copyright 2009 Maarten Meijer, all right reserved.
http://eclipsophy.blogger.com

--> 
<sqlMap namespace="Tasks">
[...]
<select id="searchForKey" parameterClass="ibatisCriteria" resultClass="string">
 SELECT DISTINCT iss_id as taskId FROM eventum_issue
 <dynamic> 
 <isNotEmpty property="product">
  INNER JOIN eventum_project  ON iss_prj_id = prj_id
 </isNotEmpty>
 <isNotEmpty property="priority">
  INNER JOIN eventum_project_priority ON iss_pri_id = pri_id
 </isNotEmpty>
 <isNotEmpty property="issueStatus">
  INNER JOIN eventum_status  ON iss_sta_id = sta_id
 </isNotEmpty>
 </dynamic>
 <dynamic prepend="WHERE">
  <isNotEmpty property="summary" prepend="AND"
   removeFirstPrepend="true"> iss_summary LIKE '%$summary$%'
  </isNotEmpty>
  <isNotEmpty property="creationDateBefore" prepend="AND"
   removeFirstPrepend="true"> iss_created_date <= #creationDateBefore#
  </isNotEmpty>
  <isNotEmpty property="creationDateAfter" prepend="AND"
   removeFirstPrepend="true"> iss_created_date gt;= #creationDateBefore#
  </isNotEmpty>
  <isNotEmpty property="product">
   <iterate property="product" conjunction="OR" open="(" close=")"
    prepend="AND" removeFirstPrepend="true">
    prj_title = #product[]#</iterate>
  </isNotEmpty>
  <isNotEmpty property="priority">
   <iterate property="priority" conjunction="OR" open="(" close=")"
    prepend="AND" removeFirstPrepend="true">
    pri_rank = right(#priority[]#,1)</iterate>
  </isNotEmpty>
  <isNotEmpty property="issueStatus">
   <iterate property="issueStatus" conjunction="OR" open="(" close=")"
    prepend="AND" removeFirstPrepend="true">
    sta_title = #issueStatus[]# </iterate>
  </isNotEmpty>
 </dynamic>        
</select>
[...]
</sqlMap>

Using the <dynamic> tag in the SqlMaps query language, you can specify fully dynamic queries, that will do this:

Creating the Connector: step 5 adding comments

When we have the basic task and attributes, we will not notice all activity that happens around a task. A Task or Issue usually has some sort of history associated with it, and this can be done by editing the file maps/eventum-direct-db/CommentsMapEventum.xml as follows:


<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMap
PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN"
"http://ibatis.apache.org/dtd/sql-map-2.dtd" >
<!-- 
licensed under ECL, to connect Mylyn to SQL databases
Copyright 2009 Maarten Meijer, all right reserved.
http://eclipsophy.blogger.com

--> 
<sqlMap namespace="Comments">
[...]
<!--
 groupKey use : when you want Mylyn to concatenate strings in different
 records into one comment you can force that to happen by giving these
 strings the same groupKey.

 Leaving the the groupKey set to null, will concatenate all records into
 one Mylyn comment. This is counterintuitive!!
-->
<select id="getForKey"  resultClass="ibatisComment">
 SELECT
 his_created_date as groupKey,
 usr_email as author,
 usr_full_name as authorName,
 his_created_date as date,
 his_summary as text
 FROM eventum_issue_history
  INNER JOIN eventum_user ON his_usr_id = usr_id
 WHERE his_iss_id = #value#
 ORDER BY his_id
 </select>
[...]
</sqlMap>

Note the use of groupKey in the statement. This construct will force all comments from the same date to be listed into one comment. Eventum issue edits result in multiple items being entered into the history using the same timestamp. Using groupKey allows you to define or alter the grouping of comments.

Creating the Connector: step 6 adding additional attributes

Sometimes we have additional attributes that can be mapped to the Mylyn common attributes listed in TaskAttributeMapper.java. Open the file maps/eventum-direct-db/TaskMapEventum.xml and go to query additionalForKey.


<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMap
PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN"
"http://ibatis.apache.org/dtd/sql-map-2.dtd" >
<!-- 
licensed under ECL, to connect Mylyn to SQL databases
Copyright 2009 Maarten Meijer, all right reserved.
http://eclipsophy.blogger.com

--> 
<sqlMap namespace="Tasks">
[...]
<!--
 Keys for TaskData attributes used by Mylyn in the RepositoryTaskData structure

 listed in file /org.eclipse.mylyn.tasks.core/src/org/eclipse/mylyn/tasks/core/data/TaskAttributeMapper.java

 There is a problem in ibatis where dot notation fields returned in a Map are parsed as bean properties.
-->
<select id="additionalForKey" resultClass="java.util.HashMap">
 SELECT
  res_title as task_common_resolution,
  usr_full_name as task_common_user_reporter
 FROM eventum_issue
  INNER JOIN eventum_resolution ON res_id = iss_res_id 
  INNER JOIN eventum_user ON usr_id = iss_usr_id 
 WHERE iss_id LIKE #value#
</select>
[...]
</sqlMap>

Conclusion

By following the simple steps outlined above, it is very easy to create a read-only connector to any database backed issue tracker. The Tasks in Mylyn are filled using a direct mapping of database columns to task elements and is not very complicated. Not a single line of Java code was needed! There is a usable UI to queries, and the results are displayed in the Task Editor, allowing a local context to be attached to it.

Connecting to database is easy when it is on the same LAN, slightly more involved when it is remote. My experience using a SSH tunnels using Putty (under Windows) or similar is that it can make a relatively secure connection easy to setup.
The connector fragment including source project can be downloaded in a ZIP from here.

Maarten Meijer: Industrial SQL connector and Eventum: adding attachments

noreply@blogger.com (Maarten Meijer) — Wed, 18 Nov 2009 14:00:59 +0000

Last time we covered Eventum task and comments, this time we'll make the attachments show up in Mylyn.

Eventum attachments

We create an attachment in our Eventum test installation and see what happens. Two tables are involved in the handling of attachments: eventum_issue_attachment containing the meta information like date created and creator, and eventum_issue_attachment_file containing actual data, filename, mime type and filesize.

Modifying the repository-config settings

We must edit fragment.xml and set the can-get-attachments property to true.

Creating the attachment data query

To return the attachment meta-data we must edit CommentsMapEventum.xml and set the getAttachmentForKey query as follows:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMap
   PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN"
   "http://ibatis.apache.org/dtd/sql-map-2.dtd" >
<!--
   licensed under ECL, to connect Mylyn to SQL databases
   Copyright 2009 Maarten Meijer, all right reserved.
   http://eclipsophy.blogger.com
-->
<sqlMap namespace="Comments">
...
<select id="getAttachmentForKey"  resultClass="ibatisAttachment">
<!-- meta data only, return the blob data separately -->
SELECT
 usr_email as author,
 iaf_filetype as ctype,
 iat_created_date as date,
 iat_description as description,
 iaf_filename as filename,
 iaf_id as id,
 iaf_filesize as size,
 iat_iss_id as taskId,
 '' as url
FROM eventum_issue_attachment
 INNER JOIN eventum_user ON iat_usr_id = usr_id
 INNER JOIN eventum_issue_attachment_file ON iat_id = iaf_iat_id
WHERE iat_iss_id = #value#
</select>
...
</sqlMap>

Creating the attachment BLOB query

To return the attachment binary BLOB we must edit CommentsMapEventum.xml and set the getAttachmentDataForKey query as follows:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMap
   PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN"
   "http://ibatis.apache.org/dtd/sql-map-2.dtd" >
<!--
   licensed under ECL, to connect Mylyn to SQL databases
   Copyright 2009 Maarten Meijer, all right reserved.
   http://eclipsophy.blogger.com
-->
<sqlMap namespace="Comments">
...
<resultMap id="attachmentDataMap" class="ibatisAttachment">
<result property="blob" column="iaf_file" jdbcType="BLOB" javaType="[B"/>
</resultMap>

<select id="getAttachmentDataForKey" resultMap="attachmentDataMap">
<!-- return the blob data -->
SELECT iaf_file
FROM eventum_issue_attachment_file
WHERE iaf_id = #value#
</select>
...
</sqlMap>

The attachment displays nicely but...

We can see the attachments in the Task Editor, an image uploaded using the web interface, but when we right-click we see several actions that do not work.

Open With Browser will not work, as the Eventum attachments are stored in a database, so they have no web url and cannot be shown in the browser. This is reported under bug 249021. This action should be dimmed when no URL is present.

Open With/Default EditorThis functionality was recently added, but does not take into account the case where no URL is present. This is in the works under bug 220314 and should be dimmed when no URL is present.

Make Local Copy and Open in Browser this is Industrial Connector functionality present to remedy the problems above, but is not a really neat solution.

Bjorn Freeman-Benson: How Not To Do XYZ Day

noreply@blogger.com (Bjorn Freeman-Benson) — Wed, 18 Nov 2009 14:00:02 +0000

I attend and spoke at Eclipse Modeling Day in New York on Monday. The speakers were earnest and knowledgeable (my favorite was "Building DSLs with XText"), but overall it was underwhelming. It didn't have to be that way, so the engineer in me asks "why was it a dud?". The conference organizer in me knows the answer: these XYZ Days should be all about getting people to talk to each other, but this one was not.

I've said this before, and here I'm saying it again: people do not attend XYZ Day to watch presentations. They can watch presentations on the internet (webcasts) or they can download presentations (slideshare) or they can read white papers, or they can ... etc and so on. No, people do not attend XYZ Day to watch presentations: they attend XYZ Day to meet other people interested in XYZ; they attend to meet the presenters and ask hard questions that are not answered by the slide decks; they attend to meet other users and pick up usage tips; they attend because the organizers will introduce them to interesting community rock stars; they attend ... to meet other people.

So when you put on an XYZ Day, you optimize the entire thing for the attendees. Force them to interact in various ways - I can think of a dozen different ways to do this (e.g. my EclipseCons). Force the presenters to cater to the attendees: show a demo, poll the audience, present alternate opinions, ...

And for gosh sakes don't spread a mere eight talks over two parallel sessions! That splits the crowd, thereby reducing the opportunity for the attendees to talk to each other. And it results in long boring talks instead of short, precise, information-filled talks. And those two factors cause a lack of critical mass to ignite a discussion after the talk in the hallway.

And... and... I could go on and on but I won't. My point is that XYZ Days are a great way to continue evangelizing Eclipse technologies and expanding the community. And I think in this post-business-travel world, the community should be thinking about more XYZ Days. But they have to be exciting and interesting and cutting-edge, and they have to be all about people meeting people.

David Bosschaert: Altering OSGi Service Lookups with Service Registry Hooks

david.bosschaert@gmail.com (davidb) — Wed, 18 Nov 2009 13:58:42 +0000

OSGi Services are great. They can solve many problems very elegantly. Take for instance SPI patterns. SPI patterns are used to make implementations pluggable. This type of pattern outside OSGi often comes with a bunch of external configuration (e.g. in META-INF/services) that makes it hard to manage and gives you a once-off chance to choose your implementation that you're stuck with for the rest of the VM lifecycle. OSGi Services provide a much more elegant way to solve this.

In many cases clients simply want to use some functionality and don't particularly care how that functionality was created. When using OSGi Services the functionality is looked up in the OSGi Service Registry which is a directory of these. Services can be looked up by implemented interface (like a phone book) or by provided attribute (like the yellow pages). How the service got there is not interesting to the client and he's not involved in that. What if the service gets replaced while the client is active? No problem, the OSGi Service Programming model is actually built around this dynamicity. You don't need to stop service consumers when you are replacing or updating the service, they are automatically rebound.

The Service Registry also provides us with an attribute based selection mechanism which is very nice if there are multiple implementations to choose from. As an example, take a system where every available printer is represented in the Service Registry as a Service that implements the org.acme.Printer interface. Each printer will have additional properties registered that help with the selection:

When looking for a Printer OSGi allows you to use an LDAP-style filter to select the printer you want. So if you want a printer that can do A3 you would use this LDAP filter:

(&(objectClass=org.acme.Printer)(paper-size=A3))

or if you want a printer in a location that starts with 'b' you do this:

(&(objectClass=org.acme.Printer)(location=b*))

This is all great and you can build your system on this using either plain OSGi code or component frameworks such as OSGi Blueprint or OSGi Declarative Services. However sometimes you may want to tweak the properties at a later date without having to rewrite your system. Assume that in your organisation all of a sudden the office numbering has changed, which would really mean that you'd have to update the 'location' attribute of all the printers. Or maybe you want to add some additional metadata to existing printers that influence the selection process, like their energy rating.

Service Registry Hooks provide the building blocks that make this possible. I wrote a little bundle called ServiceJockey that uses these to manipulate service registrations and how they are looked up. BTW you can find details at the end of this posting about getting ServiceJockey, which is open source and available freely under the Apache License.

Service Registry Hooks: what are they?

One of the driving factors for Service Registry Hooks (an OSGi standard introduced in the 4.2 Core specification) was the Remote Services (Distributed OSGi) work done in the OSGi Alliance. One of the things that implementations of the Remote Service spec need to know is what kind of services consumers are looking for so that they can go out to a discovery system to see if it might be available remotely. Eagerly registering all available remote services is clearly not scalable so we need a smarter mechanism to allow for transparent on demand discovery of remote services. This is what the ListenerHook and FindHook provide us. Together they allow us to find out what service consumers are requesting making us to only look in a remote Discovery system for those that are relevant to the current framework.

Another problem was frequently brought up. What if you have an existing bundle that doesn't know anything about Remote Services? What is the default behaviour? Should all service lookups all of a sudden always include remote services? The Remote Services spec does include a special property that you can add to your filter to influence this (service.imported) but you clearly don't want to break up all your existing service consumers to add this extra property to their lookup filters.

It turned out that there wasn't really a valid answer to that question applicable to all cases. If you're working on a system only using Remote Services for a select set of services it may make sense to default all other services consumers to not use Remote Services. On the other hand, maybe if you're building a Cloud-based infrastructure where services can move freely from one container to another the default behaviour could be that you do allow remote services for just about anything.

Since there isn't really a one-size fits-all here the Service Registry Hooks make it possible to provide a policy for this problem in a separate bundle. You can create EventHooks and FindHooks to influence what services consumers can see. This effectively allows you to add extra conditions to the lookup of service consumers without the need to modify those consumers.

Finally, EventHooks and FindHooks, together with the a ServiceListener, allow you to proxy Service Registrations, where you provide a second registration of the same object with modified properties, hiding the original.

The ability to provide an alternate registration on the fly and the possibility to impose extra conditions on existing service consumer lookups is what I built ServiceJockey around.

ServiceJockey doesn't replace the Service Object, it only effectively replaces the registration in the Service Registry plus it can put additional constraints on client lookups. But you could go further. If you wanted to actually replace or shadow the real service object and do some work when somebody uses it (maybe log it or something) you could put an additional object between the consumer and the original service object.

Because the Service Registry Hooks effectively modify some basic behaviour of the framework (the visibility of Services) they should really be started early in the Framework lifecycle. You can achieve that by giving them a low start level.

The Service Registry Hooks are available in Felix 1.8.0 and Equinox 3.5 and newer versions of these.

Altering Service Registrations

Let's start with a bundle that consumes (uses) a Printer. It isn't interested in which printer, as long as it can print A4:

BundleContext context = ... // from Activator.start()

Filter filter = context.createFilter(

"(&(objectClass=org.acme.Printer)(paper-size=A4))");

st = new ServiceTracker(context, filter, null) {

public Object addingService(ServiceReference ref) {

// print out some information on the printer

// or use the printer

return super.addingService(ref);

}

};

st.open();

When I run this it's reporting both printers that I have in my system:

Printer:

objectClass: [org.acme.Printer]

service.id: 27

location: b283

capabilities: [Double-sided]

paper-size: [A3, A4]

Printer:

objectClass: [org.acme.Printer]

service.id: 28

location: a12

capabilities: [Colour, Staple]

paper-size: [A4, Letter]

So the client has arbitrary access to both of them. Now lets see if you can modify the client behaviour so that it only uses a printer with an Energy Rating < 50.

But hold on, we don't even know about energy ratings yet! We need to add this information to the Printer registration without changing the bundle(s) that register the Printers. Let's user Service Jockey to do this.

Service Jockey uses the OSGi Extender Model. This means that it is driven from a data file in a bundle.

So I've got a bundle (called PrinterJockey) that contains META-INF/sj.xml:

<service-jockey xmlns="http://www.coderthoughts.org/schemas/sj/v1.0.0">

<proxy-registration>

<rule>

<service-filter>(&(objectClass=org.acme.Printer)(name=p1))</service-filter>

<add-property key="energy-rating">75</add-property>

</rule>

<rule>

<service-filter>(&(objectClass=org.acme.Printer)(name=p7))</service-filter>

<add-property key="energy-rating">50</add-property>

</rule>

</proxy-registration>

</service-jockey>

I will have to tell the Service-Jockey that my bundle contains configuration for it, for that I'm adding a header to the Manifest:

Service-Jockey: META-INF/sj.xml

Lets run the Printer Consumer bundle together with Service Jockey and my 'Printer Jockey' configuration bundle that contains the sj.xml file:

id State Level Bundle

0 ACTIVE 0 org.eclipse.osgi_3.5.1.R35x_v20090827

1 ACTIVE 1 org.coderthoughts.servicejockey_0.0.1

2 ACTIVE 1 PrinterJockey_1.0.0

3 ACTIVE 10 Printers_1.0.0

In my case the Printers bundle both registers and consumes the Printers, but that's because its a little test bundle. It's not really relevant. Note that the Printers bundle has a higher start level than the Jockey ones and therefore starts later.

When I run my system again I can see that it's doing some work. Now my client reports these services:

Printer:

objectClass: [org.acme.Printer]

service.id: 30

location: b283

capabilities: [Double-sided]

paper-size: [A3, A4]

energy-rating: 75

.ServiceJockey: Proxied

Printer:

objectClass: [org.acme.Printer]

service.id: 32

location: a12

capabilities: [Colour, Staple]

paper-size: [A4, Letter]

energy-rating: 50

.ServiceJockey: Proxied

Aha! I've got my energy rating in there! That's good. Remember that these are alternative registrations. The original ones haven't changed, they're just hidden.

Altering Client Side Lookups

Now I want my client to only use the one that is rated <= 50.

That's done by adding another rule to the Service Jockey configuration. A rule that adds an extra filter to any matching lookup in a consumer.

<service-jockey xmlns="http://www.coderthoughts.org/schemas/sj/v1.0.0">

<restrict-visibility>

<rule>

<bsn>.*</bsn>

<service-filter>(objectClass=org.acme.Printer)</service-filter>

<add-filter>(energy-rating<=50)</add-filter>

</rule>

</restrict-visibility>

<proxy-registration>

...

</proxy-registration>

</service-jockey>

You can specify a regular expression to say what the Bundle Symbolic Name of the consumer bundle(s) is that the rule applies to. In my case .* matches anything. So it applies to any bundle that has OSGi Service consumers. By the way, there's also a tag.

You specify to what services the additional filter applies with the tag and you specify the additional filter in . In my case I'm adding the (energy-rating<=50) condition to any Printer Service returned to a consumer (the condition looks a bit dodgy because of the XML escaping of the '<' sign - you could use a CDATA section instead...).

Note that the Service Filter applies to any service returned to a service consumer, regardless of the filter used by the client itself looks like.

Let's run the client again:

Printer:

objectClass: [org.acme.Printer]

service.id: 32

capabilities: [Colour, Staple]

location: a12

paper-size: [A4, Letter]

energy-rating: 50

.ServiceJockey: Proxied

Bingo - it only selects the service I wanted it to select. Based on additional properties and criteria listed in my Service Jockey configuration file. I did not have to modify the Printer Service registration bundle or the Consumer bundle...

Is it overkill?

Seems like a lot of work for just adding a service property, is there not a lighter way to at least add values to Service Registrations? Well at least that was my initial impression. However looking at the ServiceJockey bundle, it's only 14kb. Besides that there is currently no other way to achieve this...

Service Jockey - ride your service interactions

I didn't show any of the code to actually use the EventHook and the FindHook. Have a look at the HidingEventHook and HidingFindHook source code for that.

You can check out the source (Apache License) as an Eclipse Project from SVN here. If you fancy modifying the code, I would recommend you also get the tests project and add new ones. The test bundle depend on the Mockito bundle for its mock objects...

I'm sure the Service Jockey isn't perfect, because I only wrote it during an airplane flight so feel free to send patches :)

I also put a binary download of ServiceJockey here.

Also in the source tree, Eclipse projects for the Printers and PrinterJockey example bundles.

Lars Vogel: Profiling Eclipse RCP applications with Eclipse TPTP

Wed, 18 Nov 2009 04:36:12 +0000

I believe approx. one or two years ago I tried to profile an Eclipse RCP application with the Eclipse TPTP project. I believe at this point in time profiling an RCP application with TPTP was not possible.

I learned from Eugene Chan that the TPTP release which is part of Eclipse Galileo allows to profile Eclipse RCP applications.

I suggest you give it a try, it is as easy as profiling a standard Java application.

You find an updated description here: Eclipse TPTP Tutorial.

Thanks to Eugene Chan, Paul Slauenwhite and Kathy Chan from the TPTP team for feedback on the article.

Karsten Thoms: Eclipse DemoCamp November 26th in Frankfurt

Tue, 17 Nov 2009 21:05:40 +0000

Next week, Thursday Nov. 26th, there will be an Eclipse DemoCamp in Frankfurt, starting 05:30 PM until 09:00 PM at Saalbau Gallus. I am happy that my current project schedule allows me being in Frankfurt at this time. There are already over 40 registered attendees, this is quite impressing. There are 6 interesting talks presented at this DemoCamp:

Using Eclipse TMF in a large scale modeling and implementation project from Dr. Nikolai Busse (Deutsche Börse Systems AG). The project Nikolai is talking about is the one I am working on most of this year. I already had the opportunity to talk about this project at the CodeGeneration 2009 and W-JAX 09 conference. Nikolai will no doubt give an really interesting talk about an extraordinary project.
redView – dynamische Views für Business Applications from Ekkehard Gentz. Ekke has created a fascinating project using technologies like EMF, CDO, openArchitectureWare, UML2. Ekke is also a member on the openArchitectureWare team and it is always a pleasure to talk with him. Last time we met was last week at the W-JAX, but unfortunately I had to leave on thursday before his talk. Now I have the chance to see it finally.
JPA (EclipseLink) in OSGI Anwendungen from Karsten Voigt (IBM Global Business Services). EclipseLink will be the reference implementation of the JPA 2.0 standard. This framework has already a long history and many experience was put into it. Although Hibernate is most widely spreaded I think that EclipseLink will play a bigger role in the future. EclipseLink has smooth integration with EMF with Teneo, which makes Domain Driven Design with JPA persistence really easy.
Eclipse Code Recommenders – How much can the IDE predict what you will write in the next seconds? from Marcel Bruch (TU Darmstadt). Marcel presents his research project where a more intelligent way for producing IDE proposals is developed. Sounds interesting.
Das ist hier Usus… from Leif Frenzel and Stefan Schürle (adrena objects). They will present projectusus, which aims to provide Eclipse plugins that derive settings for Eclipse and code quality plugins like Checkstyle and EclEmma. The clue is that the settings try to match automatically what’s a project’s usus.
RCP goes Web 2.0 – Eclipse Rich Ajax Platform from Benjamin Muskalla (EclipseSource). Let’s see what RAP has new…

6 talks are really a lot for a DemoCamp. Besides presentations also networking is important at a DemoCamp. Let’s hope there is enough space for talking. Ralph Müller from the Eclipse Foundation will be there (where on the world is he not?), some people from SAP, Heidelberger Services AG, some of my colleagues from itemis, and several others. And it will be the first time I meet Attila Bak in person, who I now from the Fornax Project since some years already, but until now just via email.

Maybe I can met YOU also there? Registering is easy, and the event is free of charge. To register, just enter yourself to the DemoCamp’s Wiki page. To edit it, you’ll just need an account there. If you don’t want to open account just for that, just send me a mail and I’ll add you.

Eclipse4SL: Windows Azure Tools for Eclipse version 1.0 released

Tue, 17 Nov 2009 20:01:33 +0000

Aligning with the general availability of the release candidate of Windows Azure SDK that was unveiled at the Professional Developer Conference today, we are pleased to release version 1.0 of the version 1.0 of the Windows Azure Tools for Eclipse & SDK for Java.

The Eclipse tooling & SDKs are fully compatible with the new version of Windows Azure that has just been released today. We have also included new features that are described on the Microsoft Interoperability Blog:
http://blogs.msdn.com/interoperability/

Bob Balfe: Randall C. Kennedy: Why I hate Microsoft Office 2010

Tue, 17 Nov 2009 17:46:40 +0000

This article is a very interesting read. “Office 2010 is clunky” - that is not a good start for an evaluation. Randall continues the article with comparisons to Outlook and Office 2007 - makes you wonder if MS did any kind of performance modeling against previous releases? He ends with a brief description of the “Back Stage” feature and how it causes pain because it is not consistent from option to option.

“The idea well has finally run dry in Redmond. Maybe they can borrow a cup or two from their contemporaries down in Cupertino.”

technorati tags: lotus, Microsoft

Eugene Ostroukhov: Release names

Tue, 17 Nov 2009 15:56:41 +0000

I wonder if I’m the only one who can’t remember fancy names for Eclipse releases – Europa, Ganymede, Galileo, Helios. I think it’s not really good that there’s no easy way to memorize them (I wonder if they were meant to be in alphabetical order – if not for “Ganymede” and “Galileo”). Eclipse releases annually – so why doesn’t it has name like “Eclipse 2007″?

So:

Name	Platform/JDT/PDE	CDT	WTP	BIRT	Site
Callisto	3.2	3.1	1.5	2.1	link
Europa	3.3	4.0	2.0	2.2	link
Ganymede	3.4	5.0	3.0	2.3	link
Galileo	3.5	6.0	3.1	2.5	link
Helios	3.6				link

OpenNTF: New Release: File Explorer with Support for Favorites and Comp Apps

Tue, 17 Nov 2009 05:45:18 +0000

Manfred Lenz has contributed a Lotus Notes sidebar plugin to OpenNTF. This plugin is another file explorer with some differences to the File Navigator which was implemented at the same time.

1. It handles favorites of files and directories which are handled at Eclipse level (not operating system level)
2. It allows to hide certain drives
3. It can be used in a composite applications supporting property broker

As always you can install the plugin via drag and drop from the Apache catalog. Or download the zip file directly. Here is the documentation.

Andrew Eisenberg: How type inferencing for Groovy in Eclipse is leading to all sorts of Groovy goodness

noreply@blogger.com (Andrew Eisenberg) — Mon, 16 Nov 2009 23:46:00 +0000

Of all of the recent improvements of Groovy-Eclipse since M1 has been released, the groovy type inferencing engine is the most pervasive and powerful. This inferencing engine is able to take a groovy file or code snippet and infer the type of any or all of its expressions. It now forms the core of several of the most prominent features of Groovy-Eclipse. Everything that I describe here is currently available in the latest snapshot release of Groovy-Eclipse for Eclipse 3.5 and the update site is here:

http://dist.codehaus.org/groovy/distributions/greclipse/snapshot/e3.5

In this post, I am going to describe how the inferencing engine is currently used in Groovy-Eclipse and then I will dive a deep and describe how it is implemented. I'll end the post by describing our plans for immediate the future.

What type inferencing is used for

Underlining statically indeterminate references

The Groovy editor now underlines all references that cannot be determined while editing. This happens in a background thread while you type. So, the following code (notice the mispelling of asImmutable):


def aList = []
def otherList = aList.asImmutabl()
otherList.asImmutable()

...will appear in the editor like this...

...and when the typo is fixed, the underlines go away...

Code is re-analyzed after every keystroke (well, actually, it is after every keystroke that is followed by 500ms of no keystrokes). The type of every reference in the file is looked up using the inferencing engine. Every reference that cannot be found is considered to be unknown and will be underlined.

Of course, Groovy being a dynamic language, not all references can be statically linked to a type (other than Object). This is especially the case when working with DSLs (such as Grails) that use metaprogramming to add new methods and fields to existing types. Later, I'll describe our plans for extensibility.

Search

Inferencing is used for Java Search as well. Using the search short cut (CTRL-Shift-G or CMD-Shift-G on Mac) or running search from the Java Search dialog, references from and to Groovy code snippets can be located. However, there are some difficulties here. Compared to Java, Groovy is quite a bit more flexible in the ways that fields and methods can be referenced. For example, this field is assigned a closure and referenced as if it were a method:


class Foo {
  def x = { print it }
}

x("Hello!")

And this method is referenced in a way that is statically indistinguishable from a field:


class Foo {
  def x() {  print "Hello!" }
}

x

Furthermore, the spread operator and the use of default parameters makes the Java way of determining which method or field is referenced impossible. So, Groovy search is significantly more liberal than Java search in what it considers a search match. If a reference corresponds to any field, method, or property in the declaring type (regardless of parameter count and whether it is accessed as a field or method), then the match is considered successful. This leads to the following scenarios.

1. Performing search on the field declaration finds field references here:

2. Performing search on the method declaration finds exactly the same references:

And, notice that references attached to the wrong type are not considered a match.

Content Assist

Most of the internals of Groovy-Eclipse has been rewritten since the previous 1.5.7 release. The most recent rewrite is of content assist. Although the previous version worked (usually), there was always a noticeable lag while waiting for the content assist window to appear. This previous implementation of content assist used a combination of Java classloading and Groovy AST matching in order to find all completion proposals available at a given location, which was both messy and slow. Now, we have hooked into the inferencing engine and have completely rewritten proposal generation with extensibility in mind. And we have made some remarkable improvements in performance.

Using the following code snippet I performed content assist 5 times under the old implementation and the new and took the average of the last 3 of each:


def x
x.hasProperty("foo").

Old implementation	2315 milliseconds
New implementation	8 milliseconds

That's right...there is a 3 orders of magnitude speed up under the new implementation, making content assist a much more pleasant feature to use. But please note that this is just the time for calculation of the proposals and it does not include the time required to actually pop up the window.

Open declaration

The implementation of open declaration (or code select as it is called in JDT because it is a general mechanism to determine what the current selection refers to and is also used for things like calculating hovers) also uses inferencing. Pressing F3 whenever the selection is any form of "navigateToMe" in the following code, the expected declaration will open:

--->

Although Groovy-Eclipse M1 used type inferencing for code select, it was using the inferencing from content assist and was subject to the same mistakes, duplicate answers, and slowness that content assist had.

How it works

The inferencing engine has unified the implementation of several of Groovy-Eclipse's most widely used features. With this unification, we have been able to significantly reduce the amount of duplicated code, improve performance, and plan for extensibility.

There are four interacting components of the inferencing engine:

The Abstract Syntax Tree (or AST): this is an abstract representation of the syntax of a groovy file expressed hierarchically. The code to work on can be obtained either from the disk, or it can be the latest in memory. The AST is generated by the Groovy compiler based on the current state of the editor whenever Eclipse is otherwise idle.

The type inferencing visitor: this visitor walks the AST (i.e., uses a visitor pattern to visit every AST node) and delegates to the type lookups and the requestor described below. A new visitor is created for each call to the inferencing engine.

The type lookups: these objects lookup the type information of a particular expression using whatever mechanism they require. They can store and retrieve information about types in a way that all other lookups can use. In this way, each lookup can do what it can and coordinate with other lookups where required. Several default lookups are provided including a simple lookup, an inferencing lookup (that stores information about types via assignment expressions), and a category lookup (that looks up types in Groovy categories). Type lookups are created from a registry on each call to the inferencing engine.

The requestor: this is the object that collects the type information determined by the lookups. The requestor is general and can be used as a way to store the types of all expressions, lookup the type of a particular expression, or look for expressions with unknown types (just to name a few uses). The requestor is created by client code and past to the visitor to start the inferencing process.

The following diagram shows process and how the different pieces work together:

The visitor visits an AST expression node

The visitor sends this expression to the type lookups.
- each lookup responds with a type and its confidence in that type (ie, exact, potential, inferred...), or null, if it cannot find a type
- a lookup may additionally store information in a scope object that is passed around to other lookups so that information can be shared between them

The result of the lookup is sent to the requestor

The requestor processes the result and may choose to end the visit or continue.

If required, the visitor will continue to visit the rest of the abstract syntax of the Groovy file

What's next

One of the core design goals of the inferencing engine is extensibility. The inferencing engine must be extensible in two ways. First, it must be usable to help support new features such as quick fixes and refactoring. Also, DSLs, (most notably Grails) must be able to extend inferencing with their own type lookups. It should be apparent through the description of the variety of ways that the engine is currently used that it versatile and can become the core implementation of any number of new Groovy-Eclipse features. As for DSL extensibility, that has not yet been implemented, but the stubs are available. Other DSLs will need to implement their own type lookup, but there is currently no way for these new lookups to be plugged in. Fortunately, it will be possible to use Eclipse's plugin architecture here and this will be the subject of my next blog post (after it gets implemented).

Chris Aniszczyk: The Bookshelf: Building Open Communities

Mon, 16 Nov 2009 21:36:29 +0000

One of my big interests is building and analyzing communities, especially in the open source space. I’ve learned a lot from my experience in the Gentoo Linux and Eclipse communities and take joy in the experience. There are so many interesting topics within community building from effective communication mechanisms to development processes to governance. I see a future where a lot of software is developed in the open and building a community around that will be vital to the success of that piece of software. As I was writing this post, Microsoft just announced that they are open sourcing the .NET micro framework and attempting to build a open community around the technology…

Microsoft is also in the process of forming a community of interested and involved members to help shape the future direction of the product. There will be a core technology team that is composed of Microsoft and external partners, and people will be encouraged to propose projects, which will be vetted before they are accepted…. The site will also support people building extensions that exist alongside the platform rather than being integrated into it…

You know when Microsoft is releasing stuff under the Apache 2.0 license and attempting to build communities there’s a shift in the industry happening. Good for them!

Ok, on to the point of this post now. My reading list went empty recently and I needed to fill it with some interesting books. In particular, I was looking for books related to open source and community building. The good news is that I found a couple of interesting books, the bad news is that I wish there were more books on these topics. I’ve been devouring the Art of Community book by Jono Bacon (Ubuntu’s Community Manager).

It’s a fascinating book which outlines some of the aspects of community building and share’s many of Jono’s experiences in developing the Ubuntu community. A lot of the things he discusses can be mapped to what is going on within the Eclipse community. Jono’s coverage of the importance of meritocracy and governance pleases me.

Anyone else have a chance to read the book yet?

Another book that I’m looking to devour is the Groundswell by a couple of Forrester Research’s analysts.

I’m always a fan of case studies around social technology and how it can impact your business. My favorite recent example is the United Breaks Guitars debacle… how much heartache did that cost United? I’ll let people know what I think of Groundswell when I finish it.

Anyone else reading anything good around open source of community building lately? Any recommendations?

Karsten Thoms: Misleading error message for JavaBeautifier dependencies

Mon, 16 Nov 2009 21:34:55 +0000

The postprocessor org.eclipse.xpand2.output.JavaBeautifier comes with the plugin org.eclipse.xpand, but needs additional dependencies to work. Under the hood the beautifier leverages JDT, so the dependency to JDT is obvious. Normally the missing plugin dependencies can be easily derived from the error messages, since the package name of some missing class usually maps to the plugin identifier where the class resides. However, you might recognize the error message
java.lang.NoClassDefFoundError: org/eclipse/jface/text/BadLocationException
and think that the class must be in plugin org.eclipse.jface.text. But that’s not true, although there is of course a plugin org.eclipse.jface.text. Actually, class BadLocationException is in the plugin org.eclipse.text and is reexported from the JFace plugin.

The actual dependencies that have to be added when using the JavaBeautifiers are:

org.eclipse.jdt.core
org.eclipse.text
org.eclipse.core.resources

Martin Lippert: OSGi for Eclipse Developers Webinar

noreply@blogger.com (Martin Lippert) — Mon, 16 Nov 2009 19:58:00 +0000

Today I gave an Eclipse webinar on "OSGi for Eclipse Developers" together with Chris Aniszczyk and Bernd Kolb. We talked about various OSGi things that might sound strange and/or unfamiliar to you if you come from the Eclipse way of developing applications. We talked about the relationship of Eclipse and OSGi, dependency management and why you should use Import-Package instead of Require-Bundle, dynamics with OSGi, services vs. extensions, versioning, some compendium services and tooling for OSGi. If you missed the live broadcast, you can watch the entire webinar from here again. Enjoy!

Andy Clement: AspectJ: How much faster is AspectJ 1.6.7?

noreply@blogger.com (Andy Clement) — Mon, 16 Nov 2009 19:49:10 +0000

In the previous post I talked about the new timing infrastructure that is now in place for determining which pointcuts are proving expensive to match. Since getting that going I've been actively working on some systems that are load-time weaving aspects and attempting to optimize the matching process. The system I was working on used many of what I could call 'typical' pointcuts and so as well as performing some general optimizations that will affect any kind of pointcut, I've put in some specific optimizations for these typical/common pointcuts.

What is a common pointcut?

I see this all the time: 'execution(* Foo.*(..))'. An execution pointcut with an exact typename used for the declaring type in execution (Foo in this example). By exact, I mean no wildcards are used. AspectJ 1.6.7 supports fast match now if the type name is an exact name ( fast match is discussed in the previous article). The exact name may or may not be fully qualified, but the key thing is if there are no wildcards. What difference does that make? Here is a simple aspect:

aspect SimpleAspect {
before(): execution(* CharSequence+.*e*(..)) {}
}

Let's weave that into rt.jar (which contains 16,000 or so classes). The aspect above will actually hit 380 join points in that jar. The command I'm running:

ajc -timers -inpath rt.jar SimpleAspect.aj -outjar wovenrt.jar

AspectJ1.6.6: 21728ms
AspectJ1.6.7: 11954ms

Almost 10seconds faster due to optimized matching!

Related to that, I see a lot of users exploiting the ability to recognize join points by their annotations and in execution I see this all the time: 'execution(* (@Bar *).*(..))' - execution of any method in any type annotated by @Bar. For the case of an exact annotation and wildcarded type name (just '*'), fast match will now kick in. What difference does it make? Similar kind of improvement:

AspectJ1.6.6: 21944ms
AspectJ1.6.7: 11417ms

Of course a pattern like that doesn't actually match anything in rt.jar but that means the numbers here are showing purely the improvement in match speed, because no weaving occurs.

WATCH OUT: This close variant does not get fast matched: 'execution(* (@Bar *..*).*(..))' - this variation is choosing types not in the default package that happen to be annotated. It could be optimized for, but so far I've found all users are happy to switch to '(@Bar *)' so have not invested time in optimizing this pattern.

Optimizations have also been made for all pointcuts containing signatures with these characteristics, because I often see them occur in the wild:
- using an ellipsis for method arguments - '* *(..)'
- using a single star for method arguments - '* *(*)'
- specifying no arguments - '* *()'
- specifying void or !void as the return type - 'void *(..)' '!void *(..)'
- a declaring type of simply one wildcard - '* *(..)'

How much faster? For these improvements I created a micro benchmark that attempted to match these patterns a million times against a method.

AspectJ1.6.6:
Signature pattern [* *(..))] took 1375ms for 1,000,000
Signature pattern [* *(*))] took 949ms for 1,000,000
Signature pattern [* *())] took 908ms for 1,000,000
Signature pattern [!void *(..))] took 1279ms for 1,000,000
Signature pattern [void *(..))] took 1120ms for 1,000,000
Signature pattern [* *a*b*()] took 570ms for 1,000,000

AspectJ1.6.7:
Signature pattern [* *(..))] took 357ms for 1,000,000
Signature pattern [* *(*))] took 293ms for 1,000,000
Signature pattern [* *())] took 285ms for 1,000,000
Signature pattern [!void *(..))] took 364ms for 1,000,000
Signature pattern [void *(..))] took 362ms for 1,000,000
Signature pattern [* *a*b*()] took 309ms for 1,000,000

Fast match is also now supported for the initialization pointcut too - so that will see similar benefits to execution.

Beyond these improvements, other general optimizations include:

1) avoiding type resolution unless absolutely necessary. This involves doing more examination of patterns up front to ensure the types really need to be loaded.

2) avoiding repeated type resolution. Rather than resolving a type, then passing the signature to a downstream method where it needs to be re-resolved, AspectJ will now pass the resolved entity to save that extra resolve call.

3) faster binary weaving for jars. Changed the algorithm for processing jar entries, it now does far less work with collections.

4) Altered type walking mechanism to be iterator based. Previously it calculated the entire hierarchy before looking through it and often found the type it was looking for early. Switching to iterators AspectJ now only explores as far as necessary and if the required type is found early, it walks (and resolves!) no further.

5) Reduced collection usage in the join point creation code. Join point creation code runs *a lot* so even tiny improvements here manifest as big savings.

6) Moved to an iterator approach when searching for methods - rather than determining them all then searching through. AspectJ now only searches as far as necessary.

How to show these improvements? I've collected full tracing yourkit profiles and compared them. This is for a load-time weaving system involving tomcat plus some aspects. Startup time (when not profiled) of the server with these improvements has gone from 9seconds with AspectJ 1.6.6 to 6 seconds with AspectJ 1.6.7.

Demonstrating improvements: type resolution

Type resolution calls all funnel through World.resolve(). Here is the comparison run for 1.6.6 (old) versus 1.6.7 (new):

441,922 less calls to resolve. Due to a combination of avoiding repeated resolution and just more pointcut analysis so types are not chased down unnecessarily. To reinforce that AspectJ is really chasing down fewer types, here is a look at the calls to lookupClass() which is how .class files are loaded by the weaver:

3,068 less calls to locate and load class files.

Demonstrating improvements: fast match

Obviously because fast match is now implemented for more pointcuts, the time spent in fast match has increased:

Up from 2seconds to 12seconds. But that 10seconds is more than offset by the reduction in time spent in the second stage of matching:

That shows a reduction of almost 60seconds in second stage matching due to the improvements in fast matching. (Remember all these numbers are particularly large because full profiling was done).

Conclusion

So there you have it, what has changed in AspectJ 1.6.7 and why it is faster. I will practically guarantee that any user of the weaver will see an improvement - but how much improvement will depend upon whether your pointcuts fit the common patterns outlined above. With the new timer infrastructure I'm hoping it will be much easier to diagnose slow weaving in future and over the next few releases I'm sure more enhancements will be put in place for further common pointcut patterns.

AspectJ 1.6.7 dev builds already include the enhancements mentioned above. The latest AJDT dev builds for Eclipse 3.5 also include this AspectJ, however the ability to switch on timers in AJDT is not possible yet.

Wim Jongman: OSGi: GESUNDHEIT!

noreply@blogger.com (Wim Jongman) — Mon, 16 Nov 2009 16:10:50 +0000

This blog is about the upcoming OSGi course run by Neil Bartlett. If you are writing moderate to large size Java applications and you have heard about OSGi but are still a little puzzled about what it does: OSGi is the biggest thing that happened to Java this century. Here are three reasons why this is the case:

1. OSGi enforces modularity

Making systems modular feels good to every engineer. It is just a logical thing to do when systems grow. We define and design modules in our systems. But once implemented, they cannot be taken out or replaced by a better version because they get entangled so quickly. When coding OSGi style, this will not happen. Why? Read on.

2. OSGi defines module boundaries

One reason modularity is enforced is because you define a clear entrance point in your modules which is the interface to the rest of your system. No unclear API due to many public classes, but a well defined set of visible classes that were meant to be API. The rest is hidden, public or not public. Why is this handy?

3. OSGi helps you manage complexity.

Once you can see your modules as giant blocks of LEGO(tm) (having a clear interface) you can think about what the weak blocks are and how they can be replaced or hardened. Do all your work inside the module but be faithful to the interfaces with the outside world. This is how they build Skyscrapers.

Although it sounds to good to be true, true it still is. And even though OSGi sounds like a sneeze, it is all about the GESUNDHEIT of your applications.

We host an OSGi course in December. There are a few places left. Neil Bartlett will be your teacher. By the way, Neil did write the book, a free book and the eye opening first chapter is right here.

Apart from the course we will take you on a Amsterdam by Night tour where you will get a good, but not too good, impression of the unique Amsterdam culture. It is about 30 minutes drive from the training location to the center of Amsterdam.

See you there!

Doug Gaff: My Next Adventure

noreply@blogger.com (Doug Gaff) — Mon, 16 Nov 2009 14:44:39 +0000

After almost 10 years at EmbeddedSupportTools/WindRiver/Intel, I'm heading off to pursue a new opportunity. I will be joining National Public Radio as Director of Technology for Public Interactive. This Boston-based division of NPR is responsible for the web technology platform used by many of the NPR affiliate stations. NPR is a great organization with a great mission, and I'm excited to be joining their team.

For my colleagues in Eclipse who know me as the embedded and mobile guy, the leader of DSDP, the guy who's always on the EclipseCon Program Committee, or one of your friendly Committer Reps, this is clearly "something completely different" as the Monty Python crew would say. In my new role, we will predominantly be users of Eclipse rather than contributors, and as such I will unfortunately be stepping down from my leadership roles in the Eclipse community.

I want to thank Wind River for supporting my work at Eclipse and for investing in the CDT, DSDP, and Platform projects. I also want to thank the many leaders in the Eclipse community and at the Foundation, from whom I've learned a great deal about meritocracy, IP policy, coopetition, copyright, governance, collaboration, and free beer.

Please stay in touch. Follow me on twitter or connect on linked in.

OpenNTF: Nice End User Tool Snippets from Detlev Poettgen

Mon, 16 Nov 2009 08:29:37 +0000

Detlev Poettgen and Onur Guengoeren have released a nice end user tool on OpenNTF under the Apache license - called Snippets.

Lotus Notes users can drag and drop snippets of texts and attachments from a sidebar panel into Notes documents. Users can define these snippets themselves or they can use shared snippets.

The application has been implemented via an Eclipse plugin that can be installed via drag and drop and a Notes database which needs to be installed manually.

Dave Orme: Speaking at Chicago Area Scala Enthusiasts Meeting

Sun, 15 Nov 2009 02:23:32 +0000

I'll be speaking at the Chicago Area Scala Enthusiasts (CASE) meeting this coming Thursday. We'll cover the following:

News from the Scala LiftOff East in Reston Virginia two weeks ago
I'll talk about using DSLs written in Scala to improve Java projects

Although I haven't decided on the final content yet, topics I'm considering in order to illustrate this second point include:

Showing how to use the excellent Specs unit testing DSL (a great way to get Scala into a Java shop)
A “Make”-like DSL I wrote as my first DSL (doesn't nearly everybody?)
Simplifying Java code by evolving Java into a Scala DSL by translating to Scala and then stepwise introducing Scala idioms

I'd love to hear about what people what to hear about. Please comment.

To sign up, please visit: http://www.meetup.com/chicagoscala/ before noon, the day of the event.

Read or add comments to this article

Sven Efftinge: Xtext - Tour Dates

noreply@blogger.com (Sven Efftinge) — Sat, 14 Nov 2009 06:31:09 +0000

I just realized that there's an invasion of Xtext presentations and demos about to overrun the world during the next couple of weeks. And all of them are free of charge!

Date	Country	City	Title	Presenter
2009/11/16	USA	New York	Modeling Day: Building DSLs with Xtext	Heiko Behrens
2009/11/16	USA	New York	Modeling Day: Converging Textual and Graphical Editors	Moritz Eysholdt
2009/11/17	France	Paris	Demo Camp: Building DSLs with Xtext	Sebastian Zarnekow
2009/11/17	Germany	Leipzig	Demo Camp: Und heute generier' ich	Alexander Nittka
2009/11/18	Germany	Hamburg	Java User Group: Building DSLs with Xtext	Sven Efftinge, Sebastian Zarnekow
2009/11/18	Canada	Toronto	Modeling Day: Building DSLs with Xtext	Heiko Behrens
2009/11/18	Canada	Toronto	Modeling Day: Converging Textual and Graphical Editors	Moritz Eysholdt
2009/11/23	Germany	Berlin	Demo Camp: Building DSLs with Xtext	Peter Friese
2009/11/26	Germany	Frankfurt	Demo Camp: Using Xtext in a large scale modeling and implementation project	Nicolai Busse
2009/11/26	Germany	Stuttgart	Demo Camp: Textual DSLs with Eclipse Xtext (and a little bit code code generation with Xpand)	Markus Völter
2009/11/30	Austria	Vienna	Demo Camp: Xtext	Michael Clay
2009/12/04	Germany	Hamburg	Demo Camp: Combining graphics and text in model editors	Jan Köhnlein
2009/12/10	Italy	Florence	Demo Camp: Xtext, a Textual Modeling Framework	Francesco Guidieri

Birt World: It's Movember

noreply@blogger.com (Scott Rosenbaum) — Sat, 14 Nov 2009 04:13:21 +0000

Movember, that time of year when the days grow shorter, the weather grows colder and the family gathers today for the holidays. Of course in my family the kids are looking at me and laughing, and I am getting 'that' look from Gretchen my wife.

Yes I am growing in a mustache in an effort to change the face of men's health. To quote my team lead (I am a part of Team Fat Cyclist).

"Movember is the month formerly known as November. During this month, men — manly men — grow mos as a way to call attention to themselves (hey, I’m just being honest here).

Then, when people ask you “Why are you growing a moustache?” — and they will ask you this question — you tell them about the cancers affecting men, and ask them to donate to your Mo donation page (the money will be channeled to the Prostate Cancer Foundation and to LiveStrong).

So really, a mo is kinda like wearing a pink ribbon for breast cancer awareness. But a lot more personal. And harder to remove. And it’s displayed a lot higher."

-The Fat Cyclist (Elden Nelson)

If you are interested in supporting me and helping to raise money for men's health issues, please visit my mo page and donate.

If not me, please visit another great team, the Eclipse Momitters.

Andrei Loskutov: Change happens...

Fri, 13 Nov 2009 22:54:07 +0000

It's Friday the 13th and I finally moved my last plugin hosted on Google Code to the Mercurial. This is an amazing (fast) distributed version control system...

Three month ago I had trouble to merge experimental FindBugs branch because of Subversion's silly merge implementation. SVN simply can't handle refactoring and merging on different branches at same time. So I had to decide: do I want to spent hours on resolving this idiotic SVN "tree conflicts" or simply use something, which is faster and does all the merge work for you.

My favorite was Git (because of Egit and the famous Linus video), but Google Code unfortunately doesn't have plans to move on it, so I've tried Mercurial. Because I'm an Eclipse guy, I've started to use MercurialEclipse plugin. The developers provided almost "feature complete" plugin for Mercurial, but unfortunately, plugin didn't satisfied my personal software quality criteria. To make my life easier, I've started to fix the issues I found in the plugin and in a short time I was a commiter. This is another amazing thing about DVCS systems: they allow very easy code exchange in BOTH directions.

Now, three months and hundreds of MercurialEclipse plugin builds later, all of my open source projects are converted to use Mercurial. I do not regret the move from SVN. I have almost no wait times, and the merge is not a nightmare anymore...

Despite the move to the Mercurial and Friday the 13th date, today is important for me for a completely different reason. At same time as I've started to play with DVCS, I've started a new challenging project, and today I've seen it's first heartbeats. Let see how it will evolve. Change happens...

Jeff McAffer: Another Eclipse Mommitter

Fri, 13 Nov 2009 18:39:06 +0000

Its mid-Movember and things are getting hairy in Eclipse-land. A dedicated team of committers, the Eclipse Mommitters, have banded together to grow moustaches to raise awareness of men’s health issues. Since I’m basically lazy and work at home, it happens that I’ve not shaved for a couple weeks. So, though late to Movember, I am fully prepared to produce a moustache.

Chris ran a poll to determine the kind of ’stache he should grow. Great community involvement in setting direction. Keying off that I’m going to try and illustrate the causal connection between contribution and results. This can be applied to any community effort whether its men’s health or Eclipse itself.

The plan is to grow as much facial hair as possible and allow the highest donor to choose what kind of moustache I should sport for the last week of Movember. As an added bonus, it turns out that that week I will be teaching a course at a customer and presenting at the Ottawa Eclipse DemoCamp so there is some risk here for me…

The person with the highest cumulative donations on Movember 22nd at 23:59ET (or thereabouts) will be identified in a comment on this blog entry. If it looks particularly dangerous for me, I reserve the right to override the donor with a 2x donation. I will wear the designated moustache for the following week.

So get out the credit cards and put in your donation now. You can check out Mo progress first hand next week at one of the EclipseRT days in Austin or Toronto.

Tom Schindl: Release QxWT-0.8.2-RC1

Fri, 13 Nov 2009 17:45:18 +0000

QxWT-0.8.2-rc1

I happy to announce that a first release candidate of the GWT-Wrapper for the Qooxdoo-Widget-Library can be downloaded from our project homepage.

I started working on QxWT because I needed a GWT-Widget library providing me access to advanced controls like tables and trees and is released under a license which makes it possible to get integrated in commercial applications without paying license fees. I know there are other libraries out who already provide such a features but none of them provided me all features I wanted to have – for the record I don’t want to mess around with stores, buy in to a special domain model technology, … ).

What is QxWT

QxWT is a GWT wrapper for the qooxdoo-JS-Library. The qooxdoo-library is used for example by the RAP team as the client-side widget library. QxWT follows the qooxdoo-API as much as possible but naturally some constructs available in JavaScript can not get translated the Java 1:1 so some API methods have been adjusted. The biggest difference is that QxWT adopts the GWT-Event-Handler-System instead of wrapping the one of Qooxdoo but then once more provides 99% the same API.

One of the most important things is that Java-Developers expect to have the API documentation available in their IDE and I’ve worked with many GWT-Libraries who are not providing a good documentation. QxWT will provide full JavaDoc of all API methods when we release the final version of QxWT-0.8.2. In the RC we have documented already 99% of the widget-API but e.g. the Event-API completely lacks JavaDoc.

The second important thing is that the qooxdoo-JS-Library as well as QxWT are released under EPL which should allow you to easily use in corporate environments as well as in opensource projects.

Future plans

QxWT

Release 0.8.2 with the following features:
- Based upon 0.8.2 release of Qooxdoo
- 95% of the Widget-API of qooxdoo
- 100% JavaDoced API
Release 0.8.3 with the following features:
- Based upon 0.8.3 release of Qooxdoo
- Eclipse-Wizard for setting up a QxWT-Project
- Postprocess step to optimize deployment size of Qooxdoo-JS

UFaceKit for QxWT
After the release of QxWT 0.8.3 we are going to provide the following UFaceKit-Implementations

Qx-Databinding
Qx-Viewers
Qx-UFaceKit-Implementation
GWT-Integration for e4 so that you can access workbench-services from GWT-Applications (See the wonderful PDE-Editor written by Boris Bokowski for e4-0.9)

Getting started with QxWT

The following should give you a jump start on how to create a QxWT-Application from scratch (I assume you have the Google-Eclipse-Tools installed).
Setup of a new project

Download the latest QxWT release form UFaceKit.org and unzip it somewhere on your hard drive
Create a new GWT-Application named “MyFirstQxApp”
Create a directory named “lib” in the “MyFirstQxApp”-Project and copy the qx-jars from the download into it
Copy the “class”-Folder from the download into the war-Folder of your project

Open the MyFirstQxApp.html and add the following lines directly below the title

<!--                                           -->
<!-- Any title is fine                         -->
<!--                                           -->
<title>Web Application Starter Project</title>
<script type="text/javascript">
  window.qxgwtmodule = "myfirstqxapp";
</script>

Please note that the “myfirstqxapp” must match the value you have as a “rename-to” in your “$MODULE.gwt.xml”

Beside that you can delete the HTML-Code in the body-Tag so that it looks like this:

<body>
<!-- OPTIONAL: include this if you want history support -->
 <iframe src="javascript:''" id="__gwt_historyFrame" tabIndex='-1' style="position:absolute;width:0;height:0;border:0"></iframe>
</body>

Add the Qx-jars to your build path

Make your GWT-Module inherit from Qx-Libraries like this:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE module PUBLIC "-//Google Inc.//DTD Google Web Toolkit 1.6.4//EN" "http://google-web-toolkit.googlecode.com/svn/tags/1.6.4/distro-source/core/src/gwt-module.dtd">
<module rename-to='myfirstqxapp'>
  <!-- Inherit the core Web Toolkit stuff.                        -->
  <inherits name='com.google.gwt.user.User'/>
  <inherits name="org.ufacekit.qx.wrapper.QxScript" />
  <inherits name="org.ufacekit.qx.QxEngine" />
</module>

Open MyFirstQxApp.java remove everything beside the class definition

package org.ufacekit.qx.my.client;

/**
 * Entry point classes define <code>onModuleLoad()</code>.
 */
public class MyFirstQxApp {
}

Your first cup of QxWT

In GWT every application starts with an entry point and so does a plain Qooxdoo-JS-Application. That’s why QxWT provides you a specialized class which bridges both systems. So the first thing you need to do is to make your GWT-EntryPoint class inherit from org.ufacekit.qx.wrapper.application.QooxdooApp
```
public class MyFirstQxApp extends QooxdooApp {
	@Override
	protected void run(QxAbstractGui application) {
		// TODO Auto-generated method stub
	}
}
```

The run method will by called once both framework start ups are finished and you are ready to create the application.

The QxAbstractGui is the application scope into which your QxWT-Application is running in currently the only thing it provides you access to is the viewport you can add your UI-Widgets (QxComposite) to. Let’s as a first exercise create a GroupBox somewhere on the screen
```
protected void run(QxAbstractGui application) {
  QxGroupBox container = new QxGroupBox();
  container.setContentPadding(16, 16, 16, 16);

  application.getRoot().add(container, QxOption.leftTop(50, 30, "%"));
}
```
This code creates a groupbox and positions it 50% to the left and 30% to the top of the browser window. As you’ll notice QxWT works different to SWT because you don’t pass the parent of a widget to the constructor but you add the widget later on to the parent together with some layout informations, for swing developers this should be quite familiar.
Your ui looks like this now:

QxWT like every other widget library provides the possibility to layout child-controls using layout managers so the next thing we do is to set a layout manager on the groupbox widget like this:

QxGridLayout layout = new QxGridLayout(9, 5);
layout.setColumnAlign(0, HAlign.LEFT, VAlign.MIDDLE);
layout.setColumnAlign(1, HAlign.RIGHT, VAlign.MIDDLE);

container.setLayout(layout);

and add 2 children (a label and a text field) like this:

QxLabel label = new QxLabel("Greeting");
container.add(label, QxOption.rowColumn(0, 0));

QxTextField field = new QxTextField();
container.add(field, QxOption.rowColumn(0, 1));

The code should be quite self-explanatory and result in this UI.

As a final step let’s add a button which invokes a remote services. So the first step is to add a button like this:
```
QxButton button = new QxButton("Submit");
container.add(button, QxOption.row(1), QxOption.column(0), QxOption.colSpan(2));
```
Once more quite self-explanatory beside the fact that the button is spaning 2 columns. The next thing to do is to react on button clicks which could be done in different ways but using a command which is attached to the control is the better one. So the first thing we do is to define a command and connect the button to it
```
QxCommand cmd = new QxCommand("CTRL+S");
button.setCommand(cmd);
```
As you might guess the advantage of a command is that you can attach a keyboard sequence so the command not only gets executed when the user presses the button but also when entering a the keyboard sequence CTRL+S. The last thing we need to do is to attach a listener to the command which gets informed when the command is called. So we are adding an inner-class which looks like this:
```
class QxExecuteHandlerImpl implements QxExecuteHandler {
  private QxTextField field;

  public QxExecuteHandlerImpl(QxTextField field) {
    this.field = field;
  }

  public void execute(QxExecuteEvent executeEvent) {
  }
}
```
and attach it to the command like this:
```
cmd.addExecuteHandler(new QxExecuteHandlerImpl(field));
```
The application should look like this now:

Next step is to call the remote service which should be quite familiar to people who know GWT already.

public void execute(QxExecuteEvent executeEvent) {
  GreetingServiceAsync service = GWT.create(GreetingService.class);
  service.greetServer(field.getValue(), new AsyncCallback<String>() {
    public void onFailure(Throwable caught) {}

    public void onSuccess(String result) {}
  });
}

and display the result for example using a QxWindow like this:

public void onFailure(Throwable caught) {
  QxWindow window = new QxWindow("Error");
  window.setLayout(new QxVBoxLayout(10));
  QxAtom atom = new QxAtom(caught.toString(),"/myfirstqxapp/qooxdoo-0.8.2-sdk/framework/source/resource/qx/icon/Oxygen/48/status/dialog-error.png");
  atom.setRich(true);
  window.add(atom);
  window.center();
  window.open();
}

public void onSuccess(String result) {
  QxWindow window = new QxWindow("Remote Answer");
  window.setLayout(new QxVBoxLayout(10));
  QxAtom atom = new QxAtom(result,"/myfirstqxapp/qooxdoo-0.8.2-sdk/framework/source/resource/qx/icon/Oxygen/48/status/dialog-information.png");
  atom.setRich(true);
  window.add(atom);
  window.center();
  window.open();
}

If you now run your application, enter a text and hit the submit button or as alternative press CTRL+S your application should react like this:

Here’s the complete application class once more for reference:

package org.ufacekit.qx.my.client;

import org.ufacekit.qx.wrapper.application.QooxdooApp;
import org.ufacekit.qx.wrapper.application.QxAbstractGui;
import org.ufacekit.qx.wrapper.event.QxCommand;
import org.ufacekit.qx.wrapper.event.type.gwt.QxExecuteEvent;
import org.ufacekit.qx.wrapper.event.type.gwt.QxExecuteHandler;
import org.ufacekit.qx.wrapper.ui.basic.QxAtom;
import org.ufacekit.qx.wrapper.ui.basic.QxLabel;
import org.ufacekit.qx.wrapper.ui.form.QxButton;
import org.ufacekit.qx.wrapper.ui.form.QxTextField;
import org.ufacekit.qx.wrapper.ui.groupbox.QxGroupBox;
import org.ufacekit.qx.wrapper.ui.layout.QxGridLayout;
import org.ufacekit.qx.wrapper.ui.layout.QxVBoxLayout;
import org.ufacekit.qx.wrapper.ui.layout.QxGridLayout.HAlign;
import org.ufacekit.qx.wrapper.ui.layout.QxGridLayout.VAlign;
import org.ufacekit.qx.wrapper.ui.window.QxWindow;
import org.ufacekit.qx.wrapper.util.gwt.QxOption;

import com.google.gwt.core.client.GWT;
import com.google.gwt.user.client.rpc.AsyncCallback;

/**
 * Entry point classes define <code>onModuleLoad()</code>.
 */
public class MyFirstQxApp extends QooxdooApp {

	class QxExecuteHandlerImpl implements QxExecuteHandler {
		private QxTextField field;

		public QxExecuteHandlerImpl(QxTextField field) {
			this.field = field;
		}

		public void execute(QxExecuteEvent executeEvent) {
			GreetingServiceAsync service = GWT.create(GreetingService.class);
			service.greetServer(field.getValue(), new AsyncCallback<String>() {

				public void onFailure(Throwable caught) {
					QxWindow window = new QxWindow("Error");
					window.setLayout(new QxVBoxLayout(10));
					QxAtom atom = new QxAtom(caught.toString(),"/myfirstqxapp/qooxdoo-0.8.2-sdk/framework/source/resource/qx/icon/Oxygen/48/status/dialog-error.png");
					atom.setRich(true);
					window.add(atom);
					window.center();
					window.open();
				}

				public void onSuccess(String result) {
					QxWindow window = new QxWindow("Remote Answer");
					window.setLayout(new QxVBoxLayout(10));
					QxAtom atom = new QxAtom(result,"/myfirstqxapp/qooxdoo-0.8.2-sdk/framework/source/resource/qx/icon/Oxygen/48/status/dialog-information.png");
					atom.setRich(true);
					window.add(atom);
					window.center();
					window.open();
				}

			});
		}
	}

	@Override
	protected void run(QxAbstractGui application) {
		QxGroupBox container = new QxGroupBox();
		container.setContentPadding(16, 16, 16, 16);

		QxGridLayout layout = new QxGridLayout(9, 5);
		layout.setColumnAlign(0, HAlign.LEFT, VAlign.MIDDLE);
		layout.setColumnAlign(1, HAlign.RIGHT, VAlign.MIDDLE);

		container.setLayout(layout);

		QxLabel label = new QxLabel("Greeting");
		container.add(label, QxOption.rowColumn(0, 0));

		QxTextField field = new QxTextField();
		container.add(field, QxOption.rowColumn(0, 1));

		QxButton button = new QxButton("Submit");
		container.add(button, QxOption.row(1), QxOption.column(0), QxOption.colSpan(2));

		QxCommand cmd = new QxCommand("CTRL+S");
		button.setCommand(cmd);

		cmd.addExecuteHandler(new QxExecuteHandlerImpl(field));

		application.getRoot().add(container, QxOption.leftTop(50, 30, "%"));

	}
}

If you want to learn more of the APIs you can take a look at the demo-Project in our subversion repository and naturally you can support my work on this by making a donation (See paypal button at the left of the page).

Stay tuned for more news on this and other cool stuff – there are a lot of ideas floating around in my head (some of them even translated into source-code)

David Green: NSLog Revisited

noreply@blogger.com (David Green) — Fri, 13 Nov 2009 17:27:14 +0000

Logging is an essential tool when developing for iPhone. Keeping things simple and code readable is a major challenge when scattering logging code throughout your application. A few recent posts on the topic have provided some great solutions, but if you're like me sometimes a dead-simple solution is exactly what you need.

This is what I use:

// in Implementation.m
#define DLog NSLog

...

// I need to log something
DLog(@"something interesting happended: %@",what)

When I want to disable logging in that file, I simply change the #define as follows:

#define DLog // NSLog

That's all!

Ekkehard Gentz: on the road again (e4 – xtext – cdo – emf – runtime – redview – …)

Fri, 13 Nov 2009 17:09:26 +0000

eclipse democamps and modeling days and runtime days, so it seems there are many projects “on the road” again

Canned Heat – On The Road Again
von Docteur_BoB

Eclipse E4

tom schindl with e4 http://tomsondev.bestsolution.at/2009/11/11/e4-on-the-road/

xtext developers http://blog.efftinge.de/2009/11/xtext-tour-dates.html

CDO with Eike Stepper at modeling days in Toronto and New York

Ed Merks at Modeling Days http://ed-merks.blogspot.com/2009/11/do-it-better-with-model.html

eclipse runtime – Jeff McAffer – http://eclipsesource.com/blogs/2009/11/09/eclipsert-days-and-democamps/ and Chris Aniszczyk http://eclipsesource.com/blogs/author/zx/ around the world

and of course also redView – Riena EMF Dynamic Views (not only) for Business Applications is on-tour

http://redview.wordpress.com/ in munich, karlsruhe, frankfurt, vienna, hamburg

ekke

Posted in Eclipse, redview

Donald Smith: EclipseCon 2010 Call For Sponsors

noreply@blogger.com (Donald Smith) — Fri, 13 Nov 2009 16:33:14 +0000

EclipseCon 2010 Call for Sponsors is off to a record start. Google, Instantiations, BSI AG, Genuitec, Froglogic and Purple Scout were all fast off the draw to secure their support - more are in process. The prospectus is available - if you're thinking of sponsoring EclipseCon this year as we've consolidated the Exhibit area to be more integrated with the conference and space is definitely limited.

- Don

Ekkehard Gentz: [helios] Eclipse 3.6 EPP for Windows 64-bit

Fri, 13 Nov 2009 13:48:40 +0000

Today the EPP Downloads for Helios (Eclipse 3.6) Milestone 3 are ready to download.

thanks to the EPP team – this makes it much easier to try out the next Eclipse Helios.

Since Galileo there are also downloads for MacOSX Cocoa – 64 bit, but there’s no direct download for Windows – 64 bit.

I’m running Windows 7 Professional 64 bit (under Parallels Desktop 5 on OSX 10.6 Snow Leopard) and I know that there are many other developers also trying to run 64-bit on Windows 7.

At first be sure that you have the JDK 6 in 64 – bit – if not you can download it from

Then it’s easy to use EPP Packages on Windows-7 64 bit:

1. Download SDK Windows 64 bit (eclipse-SDK-3.6M3-win32-x86_64.zip) from here

2. Install and start as usual

3. Add New Software Site for EPP

http://download.eclipse.org/technology/epp/packages/helios

4. Install New Software and select your EPP Package (per ex. RCP)

5. Next -> Finish -> Restart and you’re done

Eclipse EPP RCP on Windows 7 -64 bit

If you’re wondering about the Look of Windows 7 – there’s a new option “Use Mac Look” since Parallels Desktop 5 to make your windows look like osx

ekke

Posted in Eclipse, Helios

Jason van Zyl: Maven 3.0-alpha-3 Released!

Fri, 13 Nov 2009 11:40:21 +0000

For those you following along with our story on improving Maven, you’ll happy to know that we have made a significant step today with the release of Maven 3.0-alpha-3. Though we are marking this as an alpha release, we are largely feature complete for Maven 3.0 and consider this to be the best version of Maven that has ever existed.

Our primary goals with Maven 3.0 are:

1) Provide a drop-in replacement for Maven 2.x. You should not have to change your POMs, or rewrite plugins. Your projects should just work.

2) Provide a more reliable, stable and performant Maven. We have tried to make Maven 3.x faster and we’ve succeeded for any of the projects that we’ve tested. We have a performance framework in place to make sure we don’t regress. We are measuring network I/O, disk I/O, CPU utilization and memory usage. We also have a massive number of integration tests to make sure the behaviour remains consistent and compatible as we progress. We simply aren’t going to go backward at this point.

3) Synchronize the M2Eclipse releases with Maven 3.x so that we can immediately push fixes from Maven 3.x into M2Eclipse. For a long time M2Eclipse was out of sync with Maven trunk and created a great number of problems. We are now completely in sync and within hours of making changes in Maven 3.x they make it into the CI builds of M2Eclipse.

4) Provide an easy way to embed Maven as a library. I think we’ve really proven this with M2Eclipse but Sonatype has two other efforts taking place. The first is to embed Maven 3.0 into Hudson and the second is to embed Maven 3.0 into Nexus. The APIs that we are creating not being final is largely why we are still releasing alphas. From a CLI perspective we’re pretty much done, from an embedding perspective we still have some work to do.

4) Provide a solid base for extensions and reuse. There are three efforts going on here which are pushing the boundaries of Maven 3.x:

Tycho: Which is Sonatype’s toolchain for building OSGi bundles and Eclipse plugins & RCP applications. The changes that we made in Maven 3.x to accommodate the embedding of an OSGi runtime (in our case Equinox) was non-trivial. We’ve been working on this for over a year and we have what we believe to be the best hybridization of Maven and OSGi technologies. Maven was stretched, and pushed and pulled to get all of this to work. I believe the current adoption of Tycho by the Tigerstripe at Eclipse.org is a sign of things to come. Users want to build OSGi bundles and Eclipse plugins using real OSGi technologies with Maven and we have delivered.
Polyglot Maven: This is our attempt to create a great degree of flexibility in the core of Maven 3.x. We provide the ability to easily pull POM information from any data source and allow DSLs access to core functionality in Maven to create new tools using Maven 3.x. The development of Polyglot Maven has sparked a lot of interest and we hope to make public release in the next month.
Maven Shell: An attempt to provide an embedded form of Maven for typical CLI users. We are planning to
- Provide more intelligent caching implementation to make builds faster. Already we are seeing 100-200% speed increases over using the standard CLI (which itself is already faster then Maven 2.x).
- Integrate a powerful form of the Make-like reactor that is built into Maven 3.x to make working in the shell extremely efficient.
- Integrate an advanced form of Archetype so that we can provide a power scaffolding framework for general application development.

We are not forgetting about documentation either. All the work that has been done in Maven 3.x is currently being documented in Maven: The Definitive Guide and we will be complete when Maven 3.0 goes GA. We also have some pretty cool site generation tools that I am using to create a new Maven 3.0 site which is also be ready in time for the final release.

For now, Benjamin and I are preparing for any feedback from users who want to try the alpha-3 release and we’ll be standing by to apply patches and make fixes for anything that users find — just like we have for the last year. This is part of Sonatype’s ongoing committment to help sustain the Maven ecosystem to provide the support, tooling, and documentation to help get new users and developers involved.

You can download the Maven 3.0-alpha-3 here:

Enjoy!

Yves Yang: Declarative Data Binding - Part 1

Fri, 13 Nov 2009 11:34:53 +0000

Why Data Binding?

Data binding is a process that establishes a connection between the application UI and business logic. Since 2006, eclipse has worked on this solution. Here is the purpose of JFace data binding, given in JFace Data Binding Introduction:

Developing line of business applications as Eclipse Rich Client Platform applications presents a number of unique challenges.

How does one validate data entry when the number of possible interactions between validation rules rises proportional to the square of the number of data entry fields on an input form?
How does one avoid coding repetitive, dull, tedious, and error-prone SWT event handlers?
How can one improve reuse of data-driven user interfaces?

All of these concerns are improved upon by using JFace Data Binding.

This component gains the popularity day by day, not only in enterprise applications, but also in eclipse it-self. But in the practice, a lot of users have noticed this solution needs to be improved. There are still some problems which are still an obstacle for a wide adoption:

Requires a deep knowledge in the implementation of this component
A lot of codes with poor lisibility
Hard codes for a specific data model

What’s Declarative Data Binding?

Declarative Data Binding is an expression of the Data binding concept in abstract and high level langauge. XWT has developed this concept in two ways:

Pure XML
XWT Data Binding expression

For example, we have a class Person that contains two attributes: First name and last name. We’d like to create a UI presentation for this object:

Here is the declaration in pure XML,

<Label Text="First name:"/>
<Text>
   <Text.text>
     <Binding path="firstName"/>
   </Text.text>
</Text>
<Label Text="Last name:"/>
<Text>
   <Text.text>
     <Binding path="lastName"/>
   </Text.text>
</Text>

And the version in XWT Data Binding expression, which is more compact:

<Label Text="First name:"/>
<Text text="{Binding Path=FirstName}"/>
<Label Text="Last name:"/>
<Text text="{Binding Path=LastName}"/>

This solution presents the following benefices:

Data model neutral	The same Data binding expression can be used for any kind of data model like Java Bean, Pojo, Dynamic EMF, XML, Web services, etc. Even it is programming language independent.
Easy to use	Developers need only to know the basic concept of Data Binding,
Basic foundation of visual tools	It is really straight forward to provide a UI edition in a visual tools like VE. XWT Designer has provided this feature, which allows no software programmers to develop applications.

Martin Lippert: Coming Up: Eclipse Demo Camp in Hamburg at December, 4th

noreply@blogger.com (Martin Lippert) — Fri, 13 Nov 2009 09:49:23 +0000

The Eclipse Demo Camp in Hamburg is coming up on 4th of December (its a Friday) from 6:30pm - 10pm at the stylish EAST hotel (like the past demo camps in Hamburg). And I am pretty impressed about the number of participants: We already have more than 70 people registered for the event. Wow... Maybe one of the reasons is the exciting program we put together... :-)

Tom Schindl will talk about Eclipse e4
Jan Köhnlein talks about building graphical and textual editors for your domain-specific language.
Jochen Krause will showcase Eclipse RAP and how you can build your rich AJAX apps using the Eclipse UI metaphors.
Nils Hartmann and Gerd Wütherich will share some insights into the various ways of how to realize an automated build process for OSGi and Eclipse applications.
And Ekkehard Gentz will show us "redview", a technology to build dynamic views for enterprise applications based on Riena, EMF and CDO.

Thanks to all the speakers who have agreed to join us in Hamburg to give demos on cool technologies - some of them travelling to Hamburg especially for the camp. Thank you all very very very much!!!

If you haven't registered yet, go to the wiki page and put your name on the list (if you have no account for the wiki, just create one or send me an email and I will put you on the list). There is no fee or ticket you need to pay for, itemis and it-agile will sponsor the event. Thank you guys for that!!!

Its a great opportunity to see the technology in action, meet with the guys building that stuff and have a chat. See you at the Demo Camp in Hamburg. Don't miss it!

Stephane Bouchet: Do you know the eclipse project summary pages ?

noreply@blogger.com (Stéphane Bouchet) — Fri, 13 Nov 2009 09:22:00 +0000

In Eclipse world, each project has its own page describing some important informations for commiters or developers.

Take a look to the EMF summary page :
http://www.eclipse.org/projects/project_summary.php?projectid=modeling.emf

For EEF, this page is this one.

You can find here various links to help you to download the latest builds, download the PSF file, to know who are the commiters, and access to the web and wiki pages.