hot off the compiler i present to you perlipse 0.9.8. some items of interest:

• java 1.5 is now required
• todo task tags
• improved syntax highlighting
• detail formatters for debugging

head on over to the project page for more details.

but before I'll start let me show you my way to Eclipse Summit this year ;)

As I am student (really ;) ) I've got the student discount. Following the rule of savings I have flight to the Germany ;) . It was investment in time and money, train is twice as much time and $ painful. Anyway it was very lively travel. I took one car, one plain, one RE, one S-bahn to get to Ludwigsburg. I booked the chipest accommodation possible but it has at least three drawbacks:

• It is far to far form the city center.
  
• There is only one bus every half hour.
  
• breakfast are served till 9am.
  

But as I pay for everything from my pocket, money counts (lets say I don't like to spend on myself ;) )

Maybe later one I'll report on how Ludwigsburg looks like for me (first time I made whole trip by foot) but now let me say few words about conference itself.

There were 4 sessions today. the choices were sometimes hard. one not wisely made.
Talking only in superlatives I've heard several good speeches, I have some interesting conversation between them and I've seen how huge power is Eclipse community. As I have barely no time today (well it is rather matter of not having internet at my room, even hostel) I'll sum-up what I heard today tomorrow.
Of course I'm not the only person with camera at this event (Ed will probably present bunch of nice photos) but let me show you one (that how it started).

syntax highlighting improvements have landed, here's a list things that can now be highlighted:

• keywords, barewords, and file handles
• variables (arrays, hashes, scalars)
• quote like/regular expression operators
• package/subroutine name declarations

here's a quick screen shot of the highlighting in action:


i'm sure there are a plethora of edge cases that have yet to be discovered, so please feel free to file a bug report should you encounter one.

Markus Knauer and Harald Kornmayer presented the g-eclipse project at Eclipse Summit Europe earlier today (”From Grid to Cloud computing“). Markus gave a great demo of how g-eclipse can be used to manage a collection of computers running in (on?) Amazon’s cloud (there’s some good documentation that shows how it’s all done).

I cornered Markus and Harald after the talk and got them to record a video that briefly describes the work they’re doing (unfortunately, I can’t seem to convince Wordpress to embed the video).

There is an excellent article in CIO.com, about why Agile Projects can go bad. Basically, it's due to inexperience and wanting to follow check lists in a lot of cases. Agile development is not about following check lists, but following certain principles. The key though is like the laws of a football (soccer) game, they are interpretable, and certain rules may be applied more liberally in certain situations. From a referee standpoint this is called Law 19, Common Sense.

Agile is not about strictly following XP, Scrum, or any other methodology... it's about being able to adapt and change when necessary, this includes the process you are using. As always, use the right tool for the right job, and be open to tweaking when necessary.

There was really good turnout for the modeling symposium.


Well over forty people attended.


Markus Voelter started the symposium with a brief outline of the agenda and a description of how the "open space" discussion would be structured in the afternoon.


Lars Schneider of Siemens presented his position paper on model quality assurance based on his research work.


He defines qualitative metrics for assessing model quality, which he terms as smells. The idea is to detect problematic patterns, i.e., bad smells, and then to use refactoring to eliminate such patterns. He described how his refactoring tool can be used to apply basic refactoring transformations and he also showed how the his graphical tool is used to design transformations.

Sandro Boehme of inovex presented a description of how EMF's EStore is used to provide support for Java soft references, a good solution for dealing with models that are too big to fit within memory.


Recall that soft references will be garbage collected when the JVM runs low on memory. By generating an EObject implementation based on the generator's reflective delegation pattern, it's possible to delegate all data access onto an InternalEObject.EStore. The store itself delegates to a map that manages the soft references under the covers. He uses this approach to implement EMFT's JCRM so it can access and traverse models larger than can fit in available memory.

Dimitrios Kolovos of York University described how GMT's Epsilon can be used to navigator heterogeneous models.


It's often the case that we need to establish links between different types of models. He described an example problem of applying probability information to an activity diagram for simulation purposes. In this scenario, it's desirable to be able to treat such information as if were just properties directly on the model. To solve this problem, the Epsilon runtime queries the available models to determine which ones know something about a specific property being associated with some type object, i.e, which ones define bridges.

Hajo Eichler of ikv++ talked about executable models.


He described some existing approaches, which as he said, are interesting, but not EMF based, and hence don't directly solve the problem. He defines operational semantics by extending Ecore and has founded it on a well-defined formalism. There is a graphical editor for specifying the dynamic behavior. He showed the debugger directly working with specified behavior. Effectively this approach allows him them very quickly specify the full semantics of a complex domain specific language.

Moritz Eysholdt of itemis described his work on meta model evolution.


He described a simple example of a document with an author-name attribute evolving to become a model with an author object to carry that name attribute. The problem is of course what happens to existing instance serialized according to the old model? If one can record the changes made to the model, that information can be used to determine how the corresponding instances need to be transformed. It's also possible to simply compare the original and final versions. In general, one needs to collect information about how the original model was changed. That information is encoded as an Epatch which groups the changes in a meaningful so that corresponding changes can be interpreted in a meaningful way against the instances.

Markus Herrmannsdoerfer described coupled evolution of meta models and models.


He gave us choice of pretty slides or a demo, so naturally the audience wanted a demo. He showed how his tool records all the changes being made to his sample model. These changes can be grouped and then annotated with instructions for how to migrate the instances. He also has refactoring transformations that can be applied and have built-in meaning in terms of migrating the corresponding instances of the model. You can learn more at his website.

Miguel Garcia presented on techniques to extend languages in the style supported by LINQ
with a focus on how to apply the same types of ideas in Java.


Annotated Ecore models can be used to specify details for how best to query instances in an SQL-like way.

Jabier Martinez of European Software Institute talked about some of the challenges faced in model drive software development, i.e., versioning and transformation, particularly those that scale to very large instances.


These are the problems they are exploring and building tools to solve.

Peter Friese and Heiko Behrens of itemis talked about Xtext, a framework for developing textual DSLs.


The idea is to support syntax that's more human readable than XML. Certainly managing and working with textual source artifacts has a long history of support. The text of course represents deep structure but all structure is implied by the text so only the source files need to be version controlled. It's difficult to work in deep meaningful ways with just source though, so an alternative is to represent the deep structure in a repository, but that implies it's necessary to resurrect the textual form when the users needs to view it, which might be lossy in terms of formatting details. A third approach is to combine these two, i.e., create an index of the deep structure from the source and maintain both.

Jos Warmer of Orinda talked about an alternative approach to large models.


Current solutions include repositories and file storage. Their solution is simply to avoid having large models. They focus on a collection of small independent DSLs along with collections of small instances. So models are composed of a number of model units and scaling happens by virtue of scaling the number of units, not growing the unit size. References across units are soft references, e.g., reference by name. Of course this implies that you'll need an index, like CrossX, to understand the soft references in order to reason about the deep structure implied by them. Effectively this is like compiling your source models into a compact representation of the deep structure.

After the presentations Markus observed that the community is maturing as evidenced by the more sophisticated topics of the interesting presentations we just saw. He then proceeded to gather topics to focus the afternoon break-out discussions.

One was focused on modeling verses programming. Kenn said "programming is modeling but modeling is not necessarily programming." The implication is that programming involves a significant focus on behavior not just structure. What is the purpose of a model generally? Typically they are defined as a target for some program to manipulate, but Kenn claims that sometimes models are just meant to communicate information. Pretty pictures, oh no!

It was asked, why don't we focus modeling more around things we've done with languages like Java, i.e., much what like Jos talked about earlier. In other words, lots of small source files and indexing them. It's key to be able to answer queries about inverse references. A focus on use cases driven by real user needs is important to achieving the same type of comfortable experience that JDT provides. Two main parts of the issue is how to compute the closure for what's to be indexed and to identify which specific things are important enough to be indexed. So we all agree we need an indexing mechanism and a query language to exploit it. Sven will propose a project that focuses on indexing.

We digresses a little at that point about the need uniquely identify every object. A URI should suffice for that. Part of the contentious issue was readable names verses arbitrary fragments that might not be human readable, e.g., a UUID. Even the issue of how the resource is serialized becomes important to understanding the issue, i.e., does the reference to some object include that full URI or is it perhaps just name based, just like a name-based Java reference. It's a bit confusing that we mix up how a resources reference each other verses how, in general, we can reference any object.

We discussed scaling via lazy loading and importantly the ability to unload things so that the heap doesn't steadily grow. It's even important to partially load objects, i.e., proxies aren't enough because sometimes specific features can be hard to compute so you'd like to defer that computation. It's important that EMF allows integration with any persistent representation
so that XML, databases, object-based stores, or repositories can be used. Often the persistent representation has an impact on what type of query mechanisms are supported.

It was also asked if scaling be transparent to the programming model or if we should expect to write our models and algorithms differently to scale better. It seems generally important to think about scalability at design time; it doesn't generally come for free. We concluded that we need good information about examples and best practices based on experience; after all, EMF's EStore API can solve many of these problems. Kenn will start a wiki about best practices.

We the crashed the e4 symposium where an excellent modeling discussion was already underway. It was interesting to hear some of the arguments against modeling because they fit in so well with my classification of all the reasons modeling is stupid.

After that we had a quick summary of the breakout sessions. It was a long and tiring symposium, but very enjoyable.

Later in the evening, the members of the Architecture Council had a nice dinner after which I decided I had enough blog fodder to choke an army, so I'd needed to get it out of my system. Tomorrow promises to be full of interesting talks followed by a great reception. Stay tuned...

Excelsior just released Excelsior JET 6.5 beta 3. With Excelsior JET, you can compile your Java- and Eclipse-based applications into a “native” executable with an embedded JRE (no external JRE required). The new version features a GUI for compiling RCP applications. Their website contains a collection of compiled open source applications, including RSSOwl, that come complete with installers. If you’re shipping an Eclipse-based application, you should take a look.

Eclipse has built-in support for spell checking but it only includes two platform dictionaries: English (United Kingdom) and English (United States). Fortunately it is possible to use any aspell dictionary in Eclipse.

Here's how I enabled the Dutch aspell dictionary in Eclipse (on Ubuntu):

1. Execute
   

   sudo apt-get install aspell aspell-nl gawk

2. Execute
   

   aspell dump master nl | awk -F/ '{print $1}' >dictionary.txt

3. In Eclipse's preferences, open the page "General > Editors > Text Editors > Spelling".
4. Enter the path to your dictionary.txt file in the field User defined dictionary.
5. Restart Eclipse.

Based on this.

If you'd like to ship your product together with P2, but containing custom set of update sites in "Help -> Install New Software", then:
1. Go to "Help -> Install New Software -> Manage Sites"
2. Shape the list using Add/Remove/Modify, and press "OK" when you're done
3. Copy org.eclipse.equinox.p2.artifact.repository.prefs and org.eclipse.equinox.p2.metadata.repository.prefs from eclipse/configuration/.settings/
to your final build configuration directory

By default Eclipse comes with two sites configured this way - linking to ganymede release train and updates.

Ed Merks recently blogged about the Eclipse members meeting. My favorite take way from this meeting was that SAP chose OSGi (Equinox) as their application platform. On top of that, SAP is going to contribute to the Equinox project to make sure that it is "enterprise ready."



I was pretty sure Equinox was "enterprise ready" already, but I learned that "enterprise ready" in SAP terms is meaning to support something like 50,000 bundles running... sounds like fun! It was also very encouraging to see SAP adopt open-source technology where it makes sense and even commit resources to the open-source projects that are important to them. The move from simply a consumer to a producer of open-source technology is a huge one. For large companies like SAP, this isn't always easy due to corporate culture.

It was also interesting to see that SAP was very methodical in their choice of OSGi framework. During the members meeting, they showed their test results pitting the various frameworks against each other:



It's cool to see Equinox come on top most of the time. I'm sure with SAP's involvement in the future, Equinox will shine even more.

It was almost exactly 10 months ago that I blogged about leaving IBM. A lot has happened since. Perhaps the coolest work-related thing is the announcement that came out this morning here at the Eclipse Summit Europe. Today we announced that Code 9 and Innoopract have created EclipseSource. The idea of EclipseSource is to really get behind the Eclipse runtime vision and push Equinox, RAP, RCP, e4, ECF, … to new levels of consumability — both at the technical level and the pragmatic business level.

Jochen Krause (Innoopract CEO) and I will lead this new team. We share the vision of a commercially backed, highly modular runtime platform. Technology for which businesses know they can get support, technology enhancements and extensions, and industrial-strength management infrastructure. That technology is Equinox, the runtime elements of Eclipse, in concert with product offerings that will be announced in the near future.

After a good night's sleep, Monday was the start of beautiful sunny day. We did some sightseeing in town to begin the day.


In the afternoon, I attended the members meeting. There are now roughly 190 members, 22 of which are strategic members, and there are 932 committers from 75 organizations. These days we get roughly 1,000,000 package download requests per month. We are expecting about 400 ESE attendees and there are roughly 35 sponsors.

Mike talked about the initiative to create industry working groups as a way to drive the growth of the foundation and to diversify its membership. Eclipse has good infrastructure and processes, including a sound intellectual property process, to help facilitate collaboration. The working groups can leverage existing projects, feed back their requirements to those projects, and even initiate projects to address any gaps. Our first example is the Mobile Industry Working Group led by Motorola and Nokia which will focus on creating a Model Application Development Kit.

There were questions about licensing issues for these working groups, i.e, will they be stuck with EPL? Mike pointed out that 3 projects are already dual licensed, e.g., EclipseLink is also licensed under BSD so that it be consumed by GPL and be part of the JPA reference implementation. He also indicated that there are efforts underway at the board to make it possible for something like CDT's Wascana distro to be hosted at Eclipse.

Karsten Schmidt talked about the SAP Eclipse story.


SAP decided to support Java in 2000. They chose Borland's JBuilder as their IDE but they needed better access to source than was provided by JBuilder in order to build their own specific extensions, so they evaluated Eclipse and NetBeans. They also needed a model abstraction layer. By 2003 they had a version of NewWeaver based on J2EE 1.3 with Selena as their modeling layer. At that time, Borland acquired TogetherSoft and Modeling Infrastructure (MOIN) based on MOF 1.4 was started as a research project. They decided not to use EMF because they needed something that worked on the server side; how odd given that EMF has always worked there. By 2006, they became the first major vendor certified for JEE 5. By 2007 they first signed the Eclipse committer Agreement and supported a committer on WTP. They also donated their memory analyzer project to Eclipse and they now have a BPMN modeler based on MOIN.

Some challenges they faced included their conservative policies that kept them from participating; without participation they could not have real influence. Things like the EMF/MOIN split are an unfortunate consequence of that lack of direct involvement. Karsten expressed regret that they were not able to get directly involved with EMF many years ago; I was certainly very hopeful after last year's "Big Models" meeting that we'd be able to work more closely together. Unfortunately decisions made at the executive levels don't always match the wishes or expectations of those of us in the trenches. Karsten is still hopeful that perhaps it's possible to better align EMF and MOIN in the future. They also expect to fully align their current component structure onto a uniform OSGi base, and they plan to focus on the Equinox implementation for that, because the benchmarks for Equinox generally give it the lead and therefore make it the best choice. The fact that it's hosted at Eclipse makes it easier for them to participate in its evolution. It's a brave and bold new future for SAP and Eclipse.

Jeff McAffer presented an overview of the runtime project's vision of the future.


The trend these days, as Karsen just demonstrated, is that people are more and more willing to consume from open source. One problem this surfaces is how to combine those components to build solutions. Many things are possible, including the ability to install a thin Equinox WAR into which you embed your OSGi bundles. The Utopian vision is to be able to use the same component model and deploy it anywhere. We already have all major JEE vendors building on OSGi, although they don't surface that as a component model for their users. A consistent, flexible, configurable component model that allows you to integrate a diversity of components is key.

Next Jochen Krause presented on the motivation behind the e4 effort and the progress it's made.


It needs to be easier to build plugins including doing so in other languages like Javascript. Richer more flexible support for styling is an important goal, along with a service-based application model able to target the web. He wanted to reassure the community that we will remain committed to the 3.x stream for five years or more, and that we plan that 3.x plugins will continue to work in a compatibility mode in e4. We will strive to provide more uniform APIs that avoid singletons and are more finely structured as small components. Even the resource model needs to be more flexible and we need to exploit patterns like Dependency Injection. We expect that the entire workbench will be formally modeled. Overall, the goal is to create a simpler and more powerful application model. An interesting approach that has been prototyped is cross compiling SWT to Flex. He also showed Boris' sample e4 application running normally and running as a brower application; pretty impressive! Of course of invited folks to get involved!

Chris Brockman presented on some of the problems that need to be solved in the business world.


The integration of disparate sources of information across the enterprise is key issue to many. The same information can be interpreted in different ways and often separate sources of information need to be related as if they originated from a uniform semantic source. The SMILA approach is focused on this. The idea is to create a shared architecture standard. Just a single company like Volkswagen might have 500 applications running just in Germany, so even just maintaining connectors for these applications is a significant cost. It's easier for application based on Eclipse because providers can be more easily encouraged to provide integration directly. Important players like SAP have gotten involved. He also drew attention to Eclipse's IP process, which, although can seem onerous, is something that's key to using open source in a way that's enterprise friendly. Ultimately it has extreme value for corporate consumers.

To help bring in the schedule, Ian Skerret gave a very rapid overview of the Mobile Working Group Mike talked about earlier.


It's a great example of the foundation's successful new approach for attracting new types of members.

Martin Oberhuber presented an overview of the Architecture Council, what it is, and what it's doing.


There is a representative for each PMC, a representative for each strategic member, as well as members appointed based on merit. The AC council facilitates mentorship and all new projects must have at least two mentors from the AC. It fields community requests via bugzilla; did you know you could do that? It interacts directly with the EMO. And it acts as a channel for raising high level issues to the board. An example of how an issue was addressed was the change to make the committers mailing list be moderated so it can remain open without becoming a frustrating source of SPAM. The AC can help offload work for the foundation staff by fielding questions directly; we have a lot of experience to share. In general, its overview of the community helps it act as a filter when it comes to issues reaching the EMO and the board. Martin has done an outstanding job making the AC active and effective.

Our beloved Bjorn, acting as Rich, talked very briefly about the activities of the Planning Council,
which has recently set itself up as the body to drive the release train for the Galileo release.


He talked about the impact of the tragedy of the commons, i.e., how everyone might want something but no one is wiling to help make it come about, with the hope others will do it for them. See how he's going to crush those who don't pony up? They don't call him knuckles for nothing. We fully expect that Galileo will release on time and on schedule just as every previous release.

Maxim Groouchevoi introduced instinctools, a new Eclipse member based in Belarus.


He talked about the DITA technology developed by his company. The idea is to provide single-source support for the documentation process and to support the full documentation life cycle.

Finally Ralph talked about the growth of Eclipse in Europe. There he is explaining how he's carving up the European pie.


All this talking and listening is hungry work so a group of us stormed a local restaurant in search of a cozy table for 22.


It was a long hard day, but even the walk back was pretty.


I was looking forward to the symposiums!

Since I am grounded this year as I didn’t come to ESE,

I made a page to help people access the source code of the BPMN modeler here:
http://www.eclipse.org/bpmn/source_code.php

It contains several teamsets that I am sure people will find nice to use to import the projects simply.

The source code location is updated to the new location, everything is back in order now, even though it’d be great to check the build system.

Looking forward to your feedback (when you’re done having fun over there in Germany).

This post is a little late but ESE is just starting and I wanted to highlight the Equinox Hackathon that is going on at the conference. This event is designed to encourage people to start building bundles, experimenting with Equinox and looking at services.  It’s a great chance to experiment and try things out.  Feel free to participate whether you are at the conference or not.  There will be a presentation at then end of the conference to highlight some of the things that were put together.

I am on my way back from the EclipseSummit in Ludwigsburg, sitting on a bench in front of Stuttgart’s main station and I am trying to recall the things that we have discussed during the Runtime Symposium this morning. One thing that comes to my mind is the confusion caused by the term ‘Cloud Computing’. Everyone seems to have his or her own association and there are many definitions available (probably too many), all of them make sense in there domain.

And what are we offering in this domain? Join our talk about Cloud Computing tomorrow and you’ll see!

If you happen to be attending CA World in Las Vegas this week, please make a point to attend a session presented by COSMOS committer and Data Collection team lead Jimmy Mohsin. The session is titled Management Data Abstraction: An Overview of CA and Cosmos and runs 9:45-10:45 AM tomorrow. Here’s the scoop of what he’s planning to talk about, from the abstract:

This session will describe CA’s participation and contribution to Eclipse COSMOS 1.0. Additionally, a few key use cases involving COSMOS and CA products will be described.

If you go, make sure you ask him why we call him the Godfather of COSMOS.